Merge pull request #21 from WyriHaximus/extended-middleware

Extended Middleware

Author: WyriHaximus

composer.json

@@ -21,11 +21,13 @@
     "react/dns": "^0.4.17 || ^1.0.0",
     "roave/better-reflection": "^3.5",
     "voryx/pgasync": "^2.0",
+    "wyrihaximus/constants": "^1.1",
     "wyrihaximus/doctrine-annotation-autoloader": "^1.0",
     "wyrihaximus/iterator-or-array-to-array": "^1.1"
   },
   "require-dev": {
     "robmorgan/phinx": "^0.10.7 || ^0.11.0",
+    "thecodingmachine/safe": "^0.1.16",
     "vlucas/phpdotenv": "^3.3",
     "wyrihaximus/async-test-utilities": "^1.1"
   },

composer.lock

@@ -33,6 +33,11 @@
                  "WyriHaximus\\React\\SimpleORM\\Repository::translateFieldName"
              ]
          },
+         "Increment": {
+             "ignore": [
+                 "WyriHaximus\\React\\SimpleORM\\Middleware\\QueryCountMiddleware::query"
+             ]
+         },
          "OneZeroInteger": {
              "ignore": [
                  "WyriHaximus\\React\\SimpleORM\\Repository::count",

infection.json.dist

@@ -7,10 +7,12 @@
 use PgAsync\Client as PgClient;
 use Plasma\SQL\Grammar\PostgreSQL;
 use Plasma\SQL\QueryBuilder;
+use React\Promise\PromiseInterface;
 use Rx\Observable;
 use WyriHaximus\React\SimpleORM\Middleware\ExecuteQueryMiddleware;
 use WyriHaximus\React\SimpleORM\Middleware\GrammarMiddleware;
 use function ApiClients\Tools\Rx\unwrapObservableFromPromise;
+use function React\Promise\resolve;
 
 final class Client implements ClientInterface
 {
@@ -51,7 +53,6 @@ private function __construct(PgClient $client, Reader $annotationReader, Middlew
         $this->entityInspector = new EntityInspector($annotationReader);
 
         $middleware[] = new GrammarMiddleware(new PostgreSQL());
-        $middleware[] = new ExecuteQueryMiddleware($this->client);
 
         $this->middlewareRunner = new MiddlewareRunner(...$middleware);
     }
@@ -67,6 +68,12 @@ public function getRepository(string $entity): RepositoryInterface
 
     public function query(QueryBuilder $query): Observable
     {
-        return unwrapObservableFromPromise($this->middlewareRunner->query($query));
+        return unwrapObservableFromPromise($this->middlewareRunner->query(
+            $query,
+            function (QueryBuilder $query): PromiseInterface
+            {
+                return resolve($this->client->executeStatement($query->getQuery(), $query->getParameters()));
+            }
+        ));
     }
 }

src/Client.php

@@ -18,8 +18,8 @@ public function __construct(GrammarInterface $grammer)
         $this->grammer = $grammer;
     }
 
-    public function query(QueryBuilder $query): PromiseInterface
+    public function query(QueryBuilder $query, callable $next): PromiseInterface
     {
-        return resolve($query->withGrammar($this->grammer));
+        return resolve($next($query->withGrammar($this->grammer)));
     }
 }

src/Middleware/ExecuteQueryMiddleware.php

@@ -5,30 +5,74 @@
 use PgAsync\Client as PgClient;
 use Plasma\SQL\QueryBuilder;
 use React\Promise\PromiseInterface;
+use Rx\Observable;
+use Throwable;
 use WyriHaximus\React\SimpleORM\MiddlewareInterface;
+use function React\Promise\reject;
 use function React\Promise\resolve;
 
 final class QueryCountMiddleware implements MiddlewareInterface
 {
     private const ZERO = 0;
 
     /** @var int */
-    private $count = self::ZERO;
+    private $initiatedCount = self::ZERO;
 
-    public function query(QueryBuilder $query): PromiseInterface
+    /** @var int */
+    private $successfulCount = self::ZERO;
+
+    /** @var int */
+    private $erroredCount = self::ZERO;
+
+    /** @var int */
+    private $slowCount = self::ZERO;
+
+    /** @var int */
+    private $slowQueryTime;
+
+    public function __construct(int $slowQueryTime)
     {
-        $this->count++;
+        $this->slowQueryTime = $slowQueryTime;
+    }
+
+    public function query(QueryBuilder $query, callable $next): PromiseInterface
+    {
+        $this->initiatedCount++;
+
+        $startTime = hrtime()[0];
+
+        return resolve($next($query))->then(function (Observable $observable) use ($startTime): PromiseInterface {
+            $this->successfulCount++;
+
+            if (hrtime()[0] - $startTime > $this->slowQueryTime) {
+                $this->slowCount++;
+            }
+
+            return resolve($observable);
+        }, function (Throwable $throwable) use ($startTime): PromiseInterface {
+            $this->erroredCount++;
+
+            if (hrtime()[0] - $startTime > $this->slowQueryTime) {
+                $this->slowCount++;
+            }
 
-        return resolve($query);
+            return reject($throwable);
+        });
     }
 
-    public function getCount(): int
+    public function getCounters(): iterable
     {
-        return $this->count;
+        yield 'initiated' => $this->initiatedCount;
+        yield 'successful' => $this->successfulCount;
+        yield 'errored' => $this->erroredCount;
+        yield 'slow' => $this->slowCount;
     }
 
-    public function resetCount(): void
+    public function resetCounters(): void
     {
-        $this->count = 0;
+        $this->initiatedCount = self::ZERO;
+        $this->successfulCount = self::ZERO;
+        $this->erroredCount = self::ZERO;
+        $this->slowCount = self::ZERO;
     }
 }

src/Middleware/GrammarMiddleware.php

@@ -11,8 +11,9 @@ interface MiddlewareInterface
      * Returns the (modified) query through a promise.
      *
      * @param QueryBuilder $query
+     * @param callable $next
      *
      * @return PromiseInterface
      */
-    public function query(QueryBuilder $query): PromiseInterface;
+    public function query(QueryBuilder $query, callable $next): PromiseInterface;
 }

src/Middleware/QueryCountMiddleware.php

@@ -5,6 +5,12 @@
 use Plasma\SQL\QueryBuilder;
 use Psr\Http\Message\ServerRequestInterface;
 use React\Promise\PromiseInterface;
+use const WyriHaximus\Constants\Numeric\ONE;
+use const WyriHaximus\Constants\Numeric\ZERO;
+
+/**
+ * @internal
+ */
 
 final class MiddlewareRunner
 {
@@ -19,20 +25,20 @@ public function __construct(MiddlewareInterface ...$middleware)
         $this->middleware = $middleware;
     }
 
-    public function query(QueryBuilder $query): PromiseInterface
+    public function query(QueryBuilder $query, callable $last): PromiseInterface
     {
-        return $this->call($query, 0);
+        return $this->call($query, ZERO, $last);
     }
 
-    private function call(QueryBuilder $query, int $position): PromiseInterface
+    private function call(QueryBuilder $query, int $position, callable $last): PromiseInterface
     {
         // final request handler will be invoked without hooking into the promise
-        if (!array_key_exists($position + 1, $this->middleware)) {
-            return $this->middleware[$position]->query($query);
+        if (!array_key_exists($position + ONE, $this->middleware)) {
+            return $this->middleware[$position]->query($query, $last);
         }
 
-        return $this->middleware[$position]->query($query)->then(function (QueryBuilder $query) use ($position) {
-            return $this->call($query, $position + 1);
+        return $this->middleware[$position]->query($query, function (QueryBuilder $query) use ($position, $last) {
+            return $this->call($query, $position + ONE, $last);
         });
     }
 }