Merge pull request #37 from WyriHaximus/add-constraint-support-to-count

Add constraint support to count

Author: WyriHaximus

src/Repository.php

@@ -66,10 +66,16 @@ public function __construct(InspectedEntityInterface $entity, ClientInterface $c
         $this->hydrator     = new Hydrator();
     }
 
-    public function count(): PromiseInterface
+    /** @phpstan-ignore-next-line */
+    public function count(?Where $where = null): PromiseInterface
     {
+        $query = $this->queryFactory->select(alias(func('COUNT', '*'), 'count'))->from(alias($this->entity->table(), 't0'));
+        if ($where instanceof Where) {
+            $query = $this->applyWhereToQuery($where, $query);
+        }
+
         return $this->client->query(
-            $this->queryFactory->select(alias(func('COUNT', '*'), 'count'))->from($this->entity->table())->asExpression()
+            $query->asExpression()
         )->take(self::SINGLE)->toPromise()->then(static function (array $row): int {
             return (int) $row['count'];
         });
@@ -147,9 +153,19 @@ public function delete(EntityInterface $entity): PromiseInterface
     private function buildSelectQuery(Where $constraints, Order $order): SelectQuery
     {
         $query = $this->buildBaseSelectQuery();
-
         $query = $query->columns(...array_values($this->fields));
+        $query = $this->applyWhereToQuery($constraints, $query);
+
+        foreach ($order->orders() as $by) {
+            $field = $this->translateFieldName($by->field());
+            $query = $query->orderBy($field, $by->order());
+        }
 
+        return $query;
+    }
+
+    private function applyWhereToQuery(Where $constraints, SelectQuery $query): SelectQuery
+    {
         foreach ($constraints->wheres() as $i => $constraint) {
             if ($constraint instanceof Expression) {
                 $where = $constraint->expression();
@@ -169,11 +185,6 @@ private function buildSelectQuery(Where $constraints, Order $order): SelectQuery
             $query = $query->andWhere($where);
         }
 
-        foreach ($order->orders() as $by) {
-            $field = $this->translateFieldName($by->field());
-            $query = $query->orderBy($field, $by->order());
-        }
-
         return $query;
     }
 

src/RepositoryInterface.php

@@ -13,7 +13,8 @@ interface RepositoryInterface
 {
     public const DEFAULT_PER_PAGE = 50;
 
-    public function count(): PromiseInterface;
+    /** @phpstan-ignore-next-line */
+    public function count(?Where $where = null): PromiseInterface;
 
     /** @phpstan-ignore-next-line */
     public function page(int $page, ?Where $where = null, ?Order $order = null, int $perPage = self::DEFAULT_PER_PAGE): Observable;

tests/FunctionalTest.php

@@ -14,6 +14,7 @@
 use WyriHaximus\React\SimpleORM\Client;
 use WyriHaximus\React\SimpleORM\ClientInterface;
 use WyriHaximus\React\SimpleORM\Middleware\QueryCountMiddleware;
+use WyriHaximus\React\SimpleORM\Query\Where;
 use WyriHaximus\React\Tests\SimpleORM\Stub\BlogPostStub;
 use WyriHaximus\React\Tests\SimpleORM\Stub\CommentStub;
 use WyriHaximus\React\Tests\SimpleORM\Stub\UserStub;
@@ -560,4 +561,26 @@ public function userSelf(): void
             'completed' => 2,
         ], iteratorOrArrayToArray($this->counter->counters()));
     }
+
+    /**
+     * @test
+     */
+    public function countWithoutConstraints(): void
+    {
+        $repository = $this->client->repository(BlogPostStub::class);
+
+        $count = $this->await($repository->count(), $this->loop, self::AWAIT_TIMEOUT);
+        self::assertSame(2, $count);
+    }
+
+    /**
+     * @test
+     */
+    public function countWithConstraints(): void
+    {
+        $repository = $this->client->repository(BlogPostStub::class);
+
+        $count = $this->await($repository->count(new Where(new Where\Field('author_id', 'eq', ['fb175cbc-04cc-41c7-8e35-6b817ac016ca']))), $this->loop, self::AWAIT_TIMEOUT);
+        self::assertSame(1, $count);
+    }
 }

tests/RepositoryTest.php

@@ -61,6 +61,36 @@ public function testCount(): void
         self::assertSame(123, $this->await($repository->count()));
     }
 
+    public function testCountWithContraints(): void
+    {
+        $this->client->query(Argument::that(static function (ExpressionInterface $expression): bool {
+            self::assertCount(1, $expression->params(new PostgresEngine()));
+            $query = $expression->sql(new PostgresEngine());
+            self::assertStringContainsString('FROM "users"', $query);
+            self::assertStringContainsString('COUNT(*) AS "count"', $query);
+            self::assertStringContainsString('WHERE "t0"."field" = ?', $query);
+
+            return true;
+        }))->shouldBeCalled()->willReturn(observableFromArray([
+            ['count' => '123'],
+        ]));
+
+        $client = $this->client->reveal();
+        assert($client instanceof ClientInterface);
+
+        $repository = new Repository(
+            (new EntityInspector(new AnnotationReader()))->entity(UserStub::class),
+            $client,
+            new QueryFactory()
+        );
+
+        self::assertSame(123, $this->await($repository->count(
+            new Where(
+                new Where\Field('field', 'eq', ['values']),
+            ),
+        )));
+    }
+
     public function testCountWithJoins(): void
     {
         $this->client->repository(CommentStub::class)->shouldNotBeCalled();