vendor/guzzlehttp/guzzle/src/Middleware.php line 72

Open in your IDE?
  1. <?php
  3. namespace GuzzleHttp;
  5. use GuzzleHttp\Cookie\CookieJarInterface;
  6. use GuzzleHttp\Exception\RequestException;
  7. use GuzzleHttp\Promise as P;
  8. use GuzzleHttp\Promise\PromiseInterface;
  9. use Psr\Http\Message\RequestInterface;
  10. use Psr\Http\Message\ResponseInterface;
  11. use Psr\Log\LoggerInterface;
  13. /**
  14.  * Functions used to create and wrap handlers with handler middleware.
  15.  */
  16. final class Middleware
  17. {
  18.     /**
  19.      * Middleware that adds cookies to requests.
  20.      *
  21.      * The options array must be set to a CookieJarInterface in order to use
  22.      * cookies. This is typically handled for you by a client.
  23.      *
  24.      * @return callable Returns a function that accepts the next handler.
  25.      */
  26.     public static function cookies(): callable
  27.     {
  28.         return static function (callable $handler): callable {
  29.             return static function ($request, array $options) use ($handler) {
  30.                 if (empty($options['cookies'])) {
  31.                     return $handler($request, $options);
  32.                 } elseif (!($options['cookies'] instanceof CookieJarInterface)) {
  33.                     throw new \InvalidArgumentException('cookies must be an instance of GuzzleHttp\Cookie\CookieJarInterface');
  34.                 }
  35.                 $cookieJar = $options['cookies'];
  36.                 $request = $cookieJar->withCookieHeader($request);
  38.                 return $handler($request, $options)
  39.                     ->then(
  40.                         static function (ResponseInterface $response) use ($cookieJar, $request): ResponseInterface {
  41.                             $cookieJar->extractCookies($request, $response);
  43.                             return $response;
  44.                         }
  45.                     );
  46.             };
  47.         };
  48.     }
  50.     /**
  51.      * Middleware that throws exceptions for 4xx or 5xx responses when the
  52.      * "http_errors" request option is set to true.
  53.      *
  54.      * @param BodySummarizerInterface|null $bodySummarizer The body summarizer to use in exception messages.
  55.      *
  56.      * @return callable(callable): callable Returns a function that accepts the next handler.
  57.      */
  58.     public static function httpErrors(BodySummarizerInterface $bodySummarizer = null): callable
  59.     {
  60.         return static function (callable $handler) use ($bodySummarizer): callable {
  61.             return static function ($request, array $options) use ($handler, $bodySummarizer) {
  62.                 if (empty($options['http_errors'])) {
  63.                     return $handler($request, $options);
  64.                 }
  66.                 return $handler($request, $options)->then(
  67.                     static function (ResponseInterface $response) use ($request, $bodySummarizer) {
  68.                         $code = $response->getStatusCode();
  69.                         if ($code < 400) {
  70.                             return $response;
  71.                         }
  72.                         throw RequestException::create($request, $response, null, [], $bodySummarizer);
  73.                     }
  74.                 );
  75.             };
  76.         };
  77.     }
  79.     /**
  80.      * Middleware that pushes history data to an ArrayAccess container.
  81.      *
  82.      * @param array|\ArrayAccess<int, array> $container Container to hold the history (by reference).
  83.      *
  84.      * @return callable(callable): callable Returns a function that accepts the next handler.
  85.      *
  86.      * @throws \InvalidArgumentException if container is not an array or ArrayAccess.
  87.      */
  88.     public static function history(&$container): callable
  89.     {
  90.         if (!\is_array($container) && !$container instanceof \ArrayAccess) {
  91.             throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
  92.         }
  94.         return static function (callable $handler) use (&$container): callable {
  95.             return static function (RequestInterface $request, array $options) use ($handler, &$container) {
  96.                 return $handler($request, $options)->then(
  97.                     static function ($value) use ($request, &$container, $options) {
  98.                         $container[] = [
  99.                             'request' => $request,
  100.                             'response' => $value,
  101.                             'error' => null,
  102.                             'options' => $options,
  103.                         ];
  105.                         return $value;
  106.                     },
  107.                     static function ($reason) use ($request, &$container, $options) {
  108.                         $container[] = [
  109.                             'request' => $request,
  110.                             'response' => null,
  111.                             'error' => $reason,
  112.                             'options' => $options,
  113.                         ];
  115.                         return P\Create::rejectionFor($reason);
  116.                     }
  117.                 );
  118.             };
  119.         };
  120.     }
  122.     /**
  123.      * Middleware that invokes a callback before and after sending a request.
  124.      *
  125.      * The provided listener cannot modify or alter the response. It simply
  126.      * "taps" into the chain to be notified before returning the promise. The
  127.      * before listener accepts a request and options array, and the after
  128.      * listener accepts a request, options array, and response promise.
  129.      *
  130.      * @param callable $before Function to invoke before forwarding the request.
  131.      * @param callable $after  Function invoked after forwarding.
  132.      *
  133.      * @return callable Returns a function that accepts the next handler.
  134.      */
  135.     public static function tap(callable $before = null, callable $after = null): callable
  136.     {
  137.         return static function (callable $handler) use ($before, $after): callable {
  138.             return static function (RequestInterface $request, array $options) use ($handler, $before, $after) {
  139.                 if ($before) {
  140.                     $before($request, $options);
  141.                 }
  142.                 $response = $handler($request, $options);
  143.                 if ($after) {
  144.                     $after($request, $options, $response);
  145.                 }
  147.                 return $response;
  148.             };
  149.         };
  150.     }
  152.     /**
  153.      * Middleware that handles request redirects.
  154.      *
  155.      * @return callable Returns a function that accepts the next handler.
  156.      */
  157.     public static function redirect(): callable
  158.     {
  159.         return static function (callable $handler): RedirectMiddleware {
  160.             return new RedirectMiddleware($handler);
  161.         };
  162.     }
  164.     /**
  165.      * Middleware that retries requests based on the boolean result of
  166.      * invoking the provided "decider" function.
  167.      *
  168.      * If no delay function is provided, a simple implementation of exponential
  169.      * backoff will be utilized.
  170.      *
  171.      * @param callable $decider Function that accepts the number of retries,
  172.      *                          a request, [response], and [exception] and
  173.      *                          returns true if the request is to be retried.
  174.      * @param callable $delay   Function that accepts the number of retries and
  175.      *                          returns the number of milliseconds to delay.
  176.      *
  177.      * @return callable Returns a function that accepts the next handler.
  178.      */
  179.     public static function retry(callable $decider, callable $delay = null): callable
  180.     {
  181.         return static function (callable $handler) use ($decider, $delay): RetryMiddleware {
  182.             return new RetryMiddleware($decider, $handler, $delay);
  183.         };
  184.     }
  186.     /**
  187.      * Middleware that logs requests, responses, and errors using a message
  188.      * formatter.
  189.      *
  190.      * @phpstan-param \Psr\Log\LogLevel::* $logLevel  Level at which to log requests.
  191.      *
  192.      * @param LoggerInterface                            $logger    Logs messages.
  193.      * @param MessageFormatterInterface|MessageFormatter $formatter Formatter used to create message strings.
  194.      * @param string                                     $logLevel  Level at which to log requests.
  195.      *
  196.      * @return callable Returns a function that accepts the next handler.
  197.      */
  198.     public static function log(LoggerInterface $logger, $formatter, string $logLevel = 'info'): callable
  199.     {
  200.         // To be compatible with Guzzle 7.1.x we need to allow users to pass a MessageFormatter
  201.         if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
  202.             throw new \LogicException(sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
  203.         }
  205.         return static function (callable $handler) use ($logger, $formatter, $logLevel): callable {
  206.             return static function (RequestInterface $request, array $options = []) use ($handler, $logger, $formatter, $logLevel) {
  207.                 return $handler($request, $options)->then(
  208.                     static function ($response) use ($logger, $request, $formatter, $logLevel): ResponseInterface {
  209.                         $message = $formatter->format($request, $response);
  210.                         $logger->log($logLevel, $message);
  212.                         return $response;
  213.                     },
  214.                     static function ($reason) use ($logger, $request, $formatter): PromiseInterface {
  215.                         $response = $reason instanceof RequestException ? $reason->getResponse() : null;
  216.                         $message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
  217.                         $logger->error($message);
  219.                         return P\Create::rejectionFor($reason);
  220.                     }
  221.                 );
  222.             };
  223.         };
  224.     }
  226.     /**
  227.      * This middleware adds a default content-type if possible, a default
  228.      * content-length or transfer-encoding header, and the expect header.
  229.      */
  230.     public static function prepareBody(): callable
  231.     {
  232.         return static function (callable $handler): PrepareBodyMiddleware {
  233.             return new PrepareBodyMiddleware($handler);
  234.         };
  235.     }
  237.     /**
  238.      * Middleware that applies a map function to the request before passing to
  239.      * the next handler.
  240.      *
  241.      * @param callable $fn Function that accepts a RequestInterface and returns
  242.      *                     a RequestInterface.
  243.      */
  244.     public static function mapRequest(callable $fn): callable
  245.     {
  246.         return static function (callable $handler) use ($fn): callable {
  247.             return static function (RequestInterface $request, array $options) use ($handler, $fn) {
  248.                 return $handler($fn($request), $options);
  249.             };
  250.         };
  251.     }
  253.     /**
  254.      * Middleware that applies a map function to the resolved promise's
  255.      * response.
  256.      *
  257.      * @param callable $fn Function that accepts a ResponseInterface and
  258.      *                     returns a ResponseInterface.
  259.      */
  260.     public static function mapResponse(callable $fn): callable
  261.     {
  262.         return static function (callable $handler) use ($fn): callable {
  263.             return static function (RequestInterface $request, array $options) use ($handler, $fn) {
  264.                 return $handler($request, $options)->then($fn);
  265.             };
  266.         };
  267.     }
  268. }