Merge pull request #2549 from alanpoulain/mongodb-limit-0

[MongoDB] Allow limit 0

Author: soyuka

features/hydra/collection.feature

@@ -396,7 +396,6 @@ Feature: Collections support
     }
     """
 
-  @!mongodb
   @createSchema
   Scenario: Allow passing 0 to `itemsPerPage`
     When I send a "GET" request to "/dummies?itemsPerPage=0"

src/Bridge/Doctrine/MongoDbOdm/Extension/PaginationExtension.php

@@ -64,12 +64,18 @@ public function applyToCollection(Builder $aggregationBuilder, string $resourceC
             throw new RuntimeException(sprintf('The repository for "%s" must be an instance of "%s".', $resourceClass, DocumentRepository::class));
         }
 
+        $resultsAggregationBuilder = $repository->createAggregationBuilder()->skip($offset);
+        if ($limit > 0) {
+            $resultsAggregationBuilder->limit($limit);
+        } else {
+            // Results have to be 0 but MongoDB does not support a limit equal to 0.
+            $resultsAggregationBuilder->match()->field(Paginator::LIMIT_ZERO_MARKER_FIELD)->equals(Paginator::LIMIT_ZERO_MARKER);
+        }
+
         $aggregationBuilder
             ->facet()
             ->field('results')->pipeline(
-                $repository->createAggregationBuilder()
-                    ->skip($offset)
-                    ->limit($limit)
+                $resultsAggregationBuilder
             )
             ->field('count')->pipeline(
                 $repository->createAggregationBuilder()

src/Bridge/Doctrine/MongoDbOdm/Paginator.php

@@ -28,6 +28,9 @@
  */
 final class Paginator implements \IteratorAggregate, PaginatorInterface
 {
+    public const LIMIT_ZERO_MARKER_FIELD = '___';
+    public const LIMIT_ZERO_MARKER = 'limit0';
+
     /**
      * @var Iterator
      */
@@ -76,7 +79,7 @@ public function __construct(Iterator $mongoDbOdmIterator, UnitOfWork $unitOfWork
          * skip/limit parameters of the query, the values set in the facet stage are used instead.
          */
         $this->firstResult = $this->getStageInfo($resultsFacetInfo, '$skip');
-        $this->maxResults = $this->getStageInfo($resultsFacetInfo, '$limit');
+        $this->maxResults = $this->hasLimitZeroStage($resultsFacetInfo) ? 0 : $this->getStageInfo($resultsFacetInfo, '$limit');
         $this->totalItems = $mongoDbOdmIterator->toArray()[0]['count'][0]['count'] ?? 0;
     }
 
@@ -85,6 +88,10 @@ public function __construct(Iterator $mongoDbOdmIterator, UnitOfWork $unitOfWork
      */
     public function getCurrentPage(): float
     {
+        if (0 >= $this->maxResults) {
+            return 1.;
+        }
+
         return floor($this->firstResult / $this->maxResults) + 1.;
     }
 
@@ -93,6 +100,10 @@ public function getCurrentPage(): float
      */
     public function getLastPage(): float
     {
+        if (0 >= $this->maxResults) {
+            return 1.;
+        }
+
         return ceil($this->totalItems / $this->maxResults) ?: 1.;
     }
 
@@ -161,4 +172,15 @@ private function getStageInfo(array $resultsFacetInfo, string $stage): int
 
         throw new InvalidArgumentException("$stage stage was not applied to the facet stage of the aggregation pipeline.");
     }
+
+    private function hasLimitZeroStage(array $resultsFacetInfo): bool
+    {
+        foreach ($resultsFacetInfo as $resultFacetInfo) {
+            if (self::LIMIT_ZERO_MARKER === ($resultFacetInfo['$match'][self::LIMIT_ZERO_MARKER_FIELD] ?? null)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

tests/Bridge/Doctrine/MongoDbOdm/Extension/PaginationExtensionTest.php

@@ -14,6 +14,7 @@
 namespace ApiPlatform\Core\Tests\Bridge\Doctrine\MongoDbOdm\Extension;
 
 use ApiPlatform\Core\Bridge\Doctrine\MongoDbOdm\Extension\PaginationExtension;
+use ApiPlatform\Core\Bridge\Doctrine\MongoDbOdm\Paginator;
 use ApiPlatform\Core\DataProvider\Pagination;
 use ApiPlatform\Core\DataProvider\PaginatorInterface;
 use ApiPlatform\Core\DataProvider\PartialPaginatorInterface;
@@ -24,7 +25,7 @@
 use Doctrine\ODM\MongoDB\Aggregation\Builder;
 use Doctrine\ODM\MongoDB\Aggregation\Stage\Count;
 use Doctrine\ODM\MongoDB\Aggregation\Stage\Facet;
-use Doctrine\ODM\MongoDB\Aggregation\Stage\Limit;
+use Doctrine\ODM\MongoDB\Aggregation\Stage\Match;
 use Doctrine\ODM\MongoDB\Aggregation\Stage\Skip;
 use Doctrine\ODM\MongoDB\DocumentManager;
 use Doctrine\ODM\MongoDB\Iterator\Iterator;
@@ -391,10 +392,15 @@ private function getPaginationExtensionResult()
 
     private function mockAggregationBuilder($expectedOffset, $expectedLimit)
     {
-        $limitProphecy = $this->prophesize(Limit::class);
-
         $skipProphecy = $this->prophesize(Skip::class);
-        $skipProphecy->limit($expectedLimit)->shouldBeCalled()->willReturn($limitProphecy->reveal());
+        if ($expectedLimit > 0) {
+            $skipProphecy->limit($expectedLimit)->shouldBeCalled();
+        } else {
+            $matchProphecy = $this->prophesize(Match::class);
+            $matchProphecy->field(Paginator::LIMIT_ZERO_MARKER_FIELD)->shouldBeCalled()->willReturn($matchProphecy);
+            $matchProphecy->equals(Paginator::LIMIT_ZERO_MARKER)->shouldBeCalled();
+            $skipProphecy->match()->shouldBeCalled()->willReturn($matchProphecy->reveal());
+        }
 
         $resultsAggregationBuilderProphecy = $this->prophesize(Builder::class);
         $resultsAggregationBuilderProphecy->skip($expectedOffset)->shouldBeCalled()->willReturn($skipProphecy->reveal());
@@ -416,7 +422,7 @@ private function mockAggregationBuilder($expectedOffset, $expectedLimit)
         $this->managerRegistryProphecy->getManagerForClass('Foo')->shouldBeCalled()->willReturn($objectManagerProphecy->reveal());
 
         $facetProphecy = $this->prophesize(Facet::class);
-        $facetProphecy->pipeline($limitProphecy)->shouldBeCalled()->willReturn($facetProphecy);
+        $facetProphecy->pipeline($skipProphecy)->shouldBeCalled()->willReturn($facetProphecy);
         $facetProphecy->pipeline($countProphecy)->shouldBeCalled()->willReturn($facetProphecy);
         $facetProphecy->field('count')->shouldBeCalled()->willReturn($facetProphecy);
         $facetProphecy->field('results')->shouldBeCalled()->willReturn($facetProphecy);

tests/Bridge/Doctrine/MongoDbOdm/PaginatorTest.php

@@ -74,6 +74,15 @@ public function testInitializeWithLimitStageNotApplied()
         $this->getPaginatorWithMissingStage(true, true, true, true);
     }
 
+    public function testInitializeWithLimitZeroStageApplied()
+    {
+        $paginator = $this->getPaginator(0, 5, 0, true);
+
+        $this->assertEquals(1, $paginator->getCurrentPage());
+        $this->assertEquals(1, $paginator->getLastPage());
+        $this->assertEquals(0, $paginator->getItemsPerPage());
+    }
+
     public function testInitializeWithNoCount()
     {
         $paginator = $this->getPaginatorWithNoCount();
@@ -90,15 +99,15 @@ public function testGetIterator()
         $this->assertSame($paginator->getIterator(), $paginator->getIterator(), 'Iterator should be cached');
     }
 
-    private function getPaginator($firstResult = 1, $maxResults = 15, $totalItems = 42)
+    private function getPaginator($firstResult = 1, $maxResults = 15, $totalItems = 42, $limitZero = false)
     {
         $iterator = $this->prophesize(Iterator::class);
         $pipeline = [
             [
                 '$facet' => [
                     'results' => [
                         ['$skip' => $firstResult],
-                        ['$limit' => $maxResults],
+                        $limitZero ? ['$match' => [Paginator::LIMIT_ZERO_MARKER_FIELD => Paginator::LIMIT_ZERO_MARKER]] : ['$limit' => $maxResults],
                     ],
                     'count' => [
                         ['$count' => 'count'],