Middleware 4.0

Author: WyriHaximus

src/Middleware.php

@@ -2,37 +2,42 @@
 
 namespace ApiClients\Middleware\Timer\Response;
 
-use ApiClients\Foundation\Middleware\ErrorTrait;
+use ApiClients\Foundation\Middleware\Annotation\First;
+use ApiClients\Foundation\Middleware\Annotation\Last;
 use ApiClients\Foundation\Middleware\MiddlewareInterface;
-use ApiClients\Foundation\Middleware\Priority;
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use React\Promise\CancellablePromiseInterface;
+use Throwable;
 use function React\Promise\resolve;
 
 final class Middleware implements MiddlewareInterface
 {
-    use ErrorTrait;
-
     const HEADER = 'X-Middleware-Timer-Response';
 
     /**
-     * @var float
+     * @var float[]
      */
-    private $time;
+    private $times;
 
     /**
      * Return the processed $request via a fulfilled promise.
      * When implementing cache or other feature that returns a response, do it with a rejected promise.
      * If neither is possible, e.g. on some kind of failure, resolve the unaltered request.
      *
      * @param  RequestInterface            $request
+     * @param  string                      $transactionId
      * @param  array                       $options
      * @return CancellablePromiseInterface
+     *
+     * @Last()
      */
-    public function pre(RequestInterface $request, array $options = []): CancellablePromiseInterface
-    {
-        $this->time = microtime(true);
+    public function pre(
+        RequestInterface $request,
+        string $transactionId,
+        array $options = []
+    ): CancellablePromiseInterface {
+        $this->times[$transactionId] = microtime(true);
 
         return resolve($request);
     }
@@ -41,24 +46,34 @@ public function pre(RequestInterface $request, array $options = []): Cancellable
      * Return the processed $response via a promise.
      *
      * @param  ResponseInterface           $response
+     * @param  string                      $transactionId
      * @param  array                       $options
      * @return CancellablePromiseInterface
+     *
+     * @First()
      */
-    public function post(ResponseInterface $response, array $options = []): CancellablePromiseInterface
-    {
-        $time = microtime(true) - $this->time;
+    public function post(
+        ResponseInterface $response,
+        string $transactionId,
+        array $options = []
+    ): CancellablePromiseInterface {
+        $time = microtime(true) - $this->times[$transactionId];
+        unset($this->times[$transactionId]);
 
         return resolve($response->withAddedHeader(self::HEADER, (string)$time));
     }
 
     /**
-     * Priority ranging from 0 to 1000. Where 1000 will be executed first on `pre` and 0 last on `pre`.
-     * For `post` the order is reversed.
-     *
-     * @return int
+     * @param  Throwable                   $throwable
+     * @param  string                      $transactionId
+     * @param  array                       $options
+     * @return CancellablePromiseInterface
      */
-    public function priority(): int
-    {
-        return Priority::FIRST;
+    public function error(
+        Throwable $throwable,
+        string $transactionId,
+        array $options = []
+    ): CancellablePromiseInterface {
+        unset($this->times[$transactionId]);
     }
 }

tests/MiddlewareTest.php

@@ -13,13 +13,16 @@ final class MiddlewareTest extends TestCase
 {
     public function testPost()
     {
+        $idA = 'Abc';
+        $idB = 'aBc';
         $response = new Response(200, []);
         $middleware = new Middleware();
-        $middleware->pre(new Request('GET', 'https://example.com/'));
-        $responseObject = await($middleware->post($response), Factory::create());
+        $middleware->pre(new Request('GET', 'https://example.com/'), $idA, []);
+        $middleware->pre(new Request('GET', 'https://example.com/'), $idB, []);
+        $responseObject = await($middleware->post($response, $idA, []), Factory::create());
         self::assertTrue((float)$responseObject->getHeaderLine(Middleware::HEADER) < 1);
         sleep(1);
-        $responseObject = await($middleware->post($response), Factory::create());
+        $responseObject = await($middleware->post($response, $idB, []), Factory::create());
         self::assertTrue((float)$responseObject->getHeaderLine(Middleware::HEADER) > 1);
     }
 }