Add options

src/Exceptions/MaxRetriesExceededException.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Farzai\Transport\Exceptions;
+
+class MaxRetriesExceededException extends \RuntimeException
+{
+    //
+}

src/Transport.php

@@ -4,49 +4,62 @@
 
 namespace Farzai\Transport;
 
+use Farzai\Transport\Exceptions\MaxRetriesExceededException;
 use GuzzleHttp\Psr7\Uri;
 use Psr\Http\Client\ClientInterface as PsrClientInterface;
 use Psr\Http\Message\RequestInterface as PsrRequestInterface;
 use Psr\Http\Message\ResponseInterface as PsrResponseInterface;
+use Psr\Log\LoggerInterface as PsrLoggerInterface;
 
 class Transport implements PsrClientInterface
 {
     const CLIENT_NAME = 'fz';
 
-    const VERSION = '1.0.0';
+    const VERSION = '1.2.0';
 
     /**
      * The client instance.
      */
     private PsrClientInterface $client;
 
+    /**
+     * The logger instance.
+     */
+    private PsrLoggerInterface $logger;
+
     /**
      * The base URI.
      */
     private string $uri = '/';
 
+    /**
+     * The headers.
+     *
+     * @var array<string, string>
+     */
+    private array $headers = [];
+
+    private int $timeout = 30;
+
+    private int $retries = 0;
+
     /**
      * Create a new client instance.
      */
-    public function __construct(PsrClientInterface $client)
+    public function __construct(PsrClientInterface $client, PsrLoggerInterface $logger)
     {
         $this->client = $client;
+        $this->logger = $logger;
     }
 
     /**
-     * Send the request.
+     * Set the base URI.
      */
-    public function sendRequest(PsrRequestInterface $request): PsrResponseInterface
+    public function setUri(string $uri): self
     {
-        $uri = $request->getUri();
+        $this->uri = $uri;
 
-        if (empty($uri->getHost())) {
-            $request = $request->withUri(new Uri($this->getUri().$uri->getPath()));
-        }
-
-        $request = $request->withHeader('User-Agent', self::CLIENT_NAME.'/'.self::VERSION);
-
-        return $this->client->sendRequest($request);
+        return $this;
     }
 
     /**
@@ -58,10 +71,132 @@ public function getUri(): string
     }
 
     /**
-     * Get psr client.
+     * Set the timeout.
+     */
+    public function setTimeout(int $timeout): self
+    {
+        if ($timeout < 0) {
+            throw new \InvalidArgumentException('Timeout must be greater than or equal to 0.');
+        }
+
+        $this->timeout = $timeout;
+
+        return $this;
+    }
+
+    /**
+     * Get the timeout.
+     */
+    public function getTimeout(): int
+    {
+        return $this->timeout;
+    }
+
+    /**
+     * Set the retries.
+     */
+    public function setRetries(int $retries): self
+    {
+        if ($retries < 0) {
+            throw new \InvalidArgumentException('Retries must be greater than or equal to 0.');
+        }
+
+        $this->retries = $retries;
+
+        return $this;
+    }
+
+    /**
+     * Get the retries.
+     */
+    public function getRetries(): int
+    {
+        return $this->retries;
+    }
+
+    /**
+     * Set the headers.
+     *
+     * @param  array<string, string>  $headers
      */
+    public function setHeaders(array $headers): self
+    {
+        $this->headers = array_merge($this->headers, $headers);
+
+        return $this;
+    }
+
+    /**
+     * Get the headers.
+     *
+     * @return array<string, string>
+     */
+    public function getHeaders(): array
+    {
+        return $this->headers;
+    }
+
+    public function getLogger(): PsrLoggerInterface
+    {
+        return $this->logger;
+    }
+
+    public function sendRequest(PsrRequestInterface $request): PsrResponseInterface
+    {
+        $request = $this->setupRequest($request);
+
+        while ($this->retries >= 0) {
+            try {
+                return $this->client->sendRequest($request);
+            } catch (\Throwable $e) {
+                $this->logger->error($e->getMessage());
+            }
+
+            $this->retries--;
+
+            if ($this->retries >= 0) {
+                $this->logger->info('Retrying request...');
+            }
+        }
+
+        throw ($e ?? new MaxRetriesExceededException('Max retries exceeded.'));
+    }
+
     public function getPsrClient(): PsrClientInterface
     {
         return $this->client;
     }
+
+    public function setupRequest(PsrRequestInterface $request): PsrRequestInterface
+    {
+        $uri = $request->getUri();
+
+        if (empty($uri->getHost())) {
+            $request = $this->setupConnectionUri($request);
+        }
+
+        $request = $this->decorateRequest($request);
+
+        return $request;
+    }
+
+    public function setupConnectionUri(PsrRequestInterface $request): PsrRequestInterface
+    {
+        $uri = new Uri($this->uri);
+        $uri = $uri->withPath($uri->getPath().$request->getUri()->getPath());
+        $uri = $uri->withQuery($request->getUri()->getQuery());
+
+        return $request->withUri($uri);
+    }
+
+    public function decorateRequest(PsrRequestInterface $request): PsrRequestInterface
+    {
+        $request = $request->withHeader('User-Agent', self::CLIENT_NAME.'/'.self::VERSION);
+
+        foreach ($this->headers as $name => $value) {
+            $request = $request->withHeader($name, $value);
+        }
+
+        return $request;
+    }
 }

src/TransportBuilder.php

@@ -9,7 +9,7 @@
 use Psr\Log\LoggerInterface;
 use Psr\Log\NullLogger;
 
-class TransportBuilder
+final class TransportBuilder
 {
     /**
      * The client instance.
@@ -39,6 +39,11 @@ public function setClient(ClientInterface $client)
         return $this;
     }
 
+    public function getClient(): ?ClientInterface
+    {
+        return $this->client;
+    }
+
     /**
      * Set the logger
      */
@@ -49,16 +54,22 @@ public function setLogger(LoggerInterface $logger)
         return $this;
     }
 
+    public function getLogger(): ?LoggerInterface
+    {
+        return $this->logger;
+    }
+
     /**
      * Build the transport.
      */
     public function build(): Transport
     {
+        $logger = $this->logger ?? new NullLogger();
+        $client = $this->client ?? new GuzzleClient();
+
         return new Transport(
-            client: new LoggerAdapter(
-                client: $this->client ?? new GuzzleClient(),
-                logger: $this->logger ?? new NullLogger(),
-            ),
+            client: $client,
+            logger: $logger,
         );
     }
 }