IBX-10458: Fixed count

Author: barw4

src/contracts/Persistence/Content/Type/CriterionHandlerInterface.php

@@ -13,17 +13,17 @@
 use Ibexa\Core\Persistence\Legacy\Content\Type\Gateway\CriterionVisitor\CriterionVisitor;
 
 /**
- * @template T of \Ibexa\Contracts\Core\Repository\Values\ContentType\Query\CriterionInterface
+ * @template TCriterion of \Ibexa\Contracts\Core\Repository\Values\ContentType\Query\CriterionInterface
  */
 interface CriterionHandlerInterface
 {
     /**
-     * @param \Ibexa\Contracts\Core\Repository\Values\ContentType\Query\CriterionInterface $criterion
+     * @param TCriterion $criterion
      */
     public function supports(CriterionInterface $criterion): bool;
 
     /**
-     * @param \Ibexa\Contracts\Core\Repository\Values\ContentType\Query\CriterionInterface $criterion
+     * @param TCriterion $criterion
      *
      * @return string|\Doctrine\DBAL\Query\Expression\CompositeExpression
      */

src/lib/Persistence/Legacy/Content/Type/Gateway.php

@@ -37,6 +37,8 @@ abstract public function insertGroup(Group $group): int;
 
     abstract public function updateGroup(GroupUpdateStruct $group): void;
 
+    abstract public function countTypes(): int;
+
     abstract public function countTypesInGroup(int $groupId): int;
 
     abstract public function countGroupsForType(int $typeId, int $status): int;
@@ -174,7 +176,7 @@ abstract public function removeFieldDefinitionTranslation(
     abstract public function removeByUserAndVersion(int $userId, int $version): void;
 
     /**
-     * @return array<int,array<string,mixed>>
+     * @return array{items: array<int,array<string,mixed>>, count: int}
      */
     abstract public function findContentTypes(?ContentTypeQuery $query = null): array;
 }

src/lib/Persistence/Legacy/Content/Type/Gateway/DoctrineDatabase.php

@@ -207,6 +207,16 @@ public function updateGroup(GroupUpdateStruct $group): void
         $query->execute();
     }
 
+    public function countTypes(): int
+    {
+        $query = $this->connection->createQueryBuilder();
+        $query
+            ->select($this->dbPlatform->getCountExpression('id'))
+            ->from(self::CONTENT_TYPE_TABLE);
+
+        return (int)$query->execute()->fetchOne();
+    }
+
     public function countTypesInGroup(int $groupId): int
     {
         $query = $this->connection->createQueryBuilder();
@@ -1419,12 +1429,23 @@ public function removeByUserAndVersion(int $userId, int $version): void
 
     public function findContentTypes(?ContentTypeQuery $query = null): array
     {
+        $totalCount = $this->countTypes();
+        if ($totalCount === 0) {
+            return [
+                'count' => $totalCount,
+                'items' => [],
+            ];
+        }
+
         $queryBuilder = $this->getLoadTypeQueryBuilder();
 
         if ($query === null) {
             $queryBuilder->setMaxResults(ContentTypeQuery::DEFAULT_LIMIT);
 
-            return $queryBuilder->execute()->fetchAllAssociative();
+            return [
+                'count' => $totalCount,
+                'items' => $queryBuilder->execute()->fetchAllAssociative(),
+            ];
         }
 
         if (!empty($query->getCriterion())) {
@@ -1442,7 +1463,10 @@ public function findContentTypes(?ContentTypeQuery $query = null): array
             $queryBuilder->addOrderBy($column, $this->getQuerySortingDirection($sortClause->direction));
         }
 
-        return $queryBuilder->execute()->fetchAllAssociative();
+        return [
+            'count' => $totalCount,
+            'items' => $queryBuilder->execute()->fetchAllAssociative(),
+        ];
     }
 
     /**

src/lib/Persistence/Legacy/Content/Type/Gateway/ExceptionConversion.php

@@ -59,6 +59,15 @@ public function updateGroup(GroupUpdateStruct $group): void
         }
     }
 
+    public function countTypes(): int
+    {
+        try {
+            return $this->innerGateway->countTypes();
+        } catch (DBALException | PDOException $e) {
+            throw DatabaseException::wrap($e);
+        }
+    }
+
     public function countTypesInGroup(int $groupId): int
     {
         try {

src/lib/Persistence/Legacy/Content/Type/Handler.php

@@ -200,12 +200,12 @@ public function findContentTypes(?ContentTypeQuery $query = null): array
     {
         $rows = $this->contentTypeGateway->findContentTypes($query);
         $items = $this->mapper->extractTypesFromRows(
-            $rows,
+            $rows['items'],
             true
         );
 
         return [
-            'count' => count($items),
+            'count' => $rows['count'],
             'items' => $items,
         ];
     }

tests/integration/Core/Repository/ContentTypeService/FindContentTypesTest.php

@@ -44,14 +44,26 @@ public function testFindContentTypes(ContentTypeQuery $query, array $expectedIde
     {
         $contentTypeService = self::getContentTypeService();
 
+        $expectedCount = $contentTypeService->findContentTypes(
+            new ContentTypeQuery(
+                null,
+                [],
+                0,
+                0,
+            )
+        );
+        $expectedCount = count($expectedCount->getContentTypes());
+
         $contentTypes = $contentTypeService->findContentTypes($query);
+
         $identifiers = array_map(
             static fn (ContentType $contentType): string => $contentType->getIdentifier(),
             $contentTypes->getContentTypes(),
         );
 
         self::assertCount(count($expectedIdentifiers), $identifiers);
         self::assertEqualsCanonicalizing($expectedIdentifiers, $identifiers);
+        self::assertSame($expectedCount, $contentTypes->getTotalCount());
     }
 
     public function testFindContentTypesAscSortedByIdentifier(): void
@@ -73,6 +85,34 @@ public function testFindContentTypesAscSortedByIdentifier(): void
         self::assertSame(['article', 'file', 'folder', 'user'], $identifiers);
     }
 
+    public function testPagination(): void
+    {
+        $contentTypeService = self::getContentTypeService();
+
+        $collectedContentTypeIDs = [];
+        $pageSize = 10;
+        $noOfPages = 3;
+
+        for ($offset = 0; $offset < $noOfPages; $offset += $pageSize) {
+            $searchResult = $contentTypeService->findContentTypes(
+                new ContentTypeQuery(null, [], $offset, $pageSize),
+            );
+
+            // an actual number of items on a current page
+            self::assertCount($pageSize, $searchResult);
+
+            // check if results are not duplicated across multiple pages
+            foreach ($searchResult->getContentTypes() as $contentType) {
+                self::assertNotContains(
+                    $contentType->getIdentifier(),
+                    $collectedContentTypeIDs,
+                    "Content type '{$contentType->getIdentifier()}' exists on multiple pages"
+                );
+                $collectedContentTypeIDs[] = $contentType->getIdentifier();
+            }
+        }
+    }
+
     public function testFindContentTypesContainingFieldDefinitions(): void
     {
         $contentTypeService = self::getContentTypeService();