vendor/api-platform/core/src/Core/Bridge/Doctrine/Orm/Extension/PaginationExtension.php line 119

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the API Platform project.
  5.  *
  6.  * (c) Kévin Dunglas <dunglas@gmail.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. declare(strict_types=1);
  14. namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Extension;
  16. use ApiPlatform\Core\Bridge\Doctrine\Orm\AbstractPaginator;
  17. use ApiPlatform\Core\Bridge\Doctrine\Orm\Paginator;
  18. use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryChecker;
  19. use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
  20. use ApiPlatform\Core\DataProvider\Pagination;
  21. use ApiPlatform\Core\Exception\InvalidArgumentException;
  22. use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
  23. use ApiPlatform\Core\Metadata\Resource\ResourceMetadata;
  24. use Doctrine\ORM\QueryBuilder;
  25. use Doctrine\ORM\Tools\Pagination\CountWalker;
  26. use Doctrine\ORM\Tools\Pagination\Paginator as DoctrineOrmPaginator;
  27. use Doctrine\Persistence\ManagerRegistry;
  28. use Symfony\Component\HttpFoundation\Request;
  29. use Symfony\Component\HttpFoundation\RequestStack;
  31. // Help opcache.preload discover always-needed symbols
  32. class_exists(AbstractPaginator::class);
  34. /**
  35.  * Applies pagination on the Doctrine query for resource collection when enabled.
  36.  *
  37.  * @author Kévin Dunglas <dunglas@gmail.com>
  38.  * @author Samuel ROZE <samuel.roze@gmail.com>
  39.  */
  40. final class PaginationExtension implements ContextAwareQueryResultCollectionExtensionInterface
  41. {
  42.     private $managerRegistry;
  43.     private $requestStack;
  44.     /**
  45.      * @var ResourceMetadataFactoryInterface
  46.      */
  47.     private $resourceMetadataFactory;
  48.     private $enabled;
  49.     private $clientEnabled;
  50.     private $clientItemsPerPage;
  51.     private $itemsPerPage;
  52.     private $pageParameterName;
  53.     private $enabledParameterName;
  54.     private $itemsPerPageParameterName;
  55.     private $maximumItemPerPage;
  56.     private $partial;
  57.     private $clientPartial;
  58.     private $partialParameterName;
  59.     /**
  60.      * @var Pagination|null
  61.      */
  62.     private $pagination;
  64.     /**
  65.      * @param ResourceMetadataFactoryInterface|RequestStack $resourceMetadataFactory
  66.      * @param Pagination|ResourceMetadataFactoryInterface   $pagination
  67.      */
  68.     public function __construct(ManagerRegistry $managerRegistry, /* ResourceMetadataFactoryInterface */ $resourceMetadataFactory, /* Pagination */ $pagination)
  69.     {
  70.         if ($resourceMetadataFactory instanceof RequestStack && $pagination instanceof ResourceMetadataFactoryInterface) {
  71.             @trigger_error(sprintf('Passing an instance of "%s" as second argument of "%s" is deprecated since API Platform 2.4 and will not be possible anymore in API Platform 3. Pass an instance of "%s" instead.', RequestStack::class, self::class, ResourceMetadataFactoryInterface::class), \E_USER_DEPRECATED);
  72.             @trigger_error(sprintf('Passing an instance of "%s" as third argument of "%s" is deprecated since API Platform 2.4 and will not be possible anymore in API Platform 3. Pass an instance of "%s" instead.', ResourceMetadataFactoryInterface::class, self::class, Pagination::class), \E_USER_DEPRECATED);
  74.             $this->requestStack = $resourceMetadataFactory;
  75.             $resourceMetadataFactory = $pagination;
  76.             $pagination = null;
  78.             $args = \array_slice(\func_get_args(), 3);
  79.             $legacyPaginationArgs = [
  80.                 ['arg_name' => 'enabled', 'type' => 'bool', 'default' => true],
  81.                 ['arg_name' => 'clientEnabled', 'type' => 'bool', 'default' => false],
  82.                 ['arg_name' => 'clientItemsPerPage', 'type' => 'bool', 'default' => false],
  83.                 ['arg_name' => 'itemsPerPage', 'type' => 'int', 'default' => 30],
  84.                 ['arg_name' => 'pageParameterName', 'type' => 'string', 'default' => 'page'],
  85.                 ['arg_name' => 'enabledParameterName', 'type' => 'string', 'default' => 'pagination'],
  86.                 ['arg_name' => 'itemsPerPageParameterName', 'type' => 'string', 'default' => 'itemsPerPage'],
  87.                 ['arg_name' => 'maximumItemPerPage', 'type' => 'int', 'default' => null],
  88.                 ['arg_name' => 'partial', 'type' => 'bool', 'default' => false],
  89.                 ['arg_name' => 'clientPartial', 'type' => 'bool', 'default' => false],
  90.                 ['arg_name' => 'partialParameterName', 'type' => 'string', 'default' => 'partial'],
  91.             ];
  93.             foreach ($legacyPaginationArgs as $pos => $arg) {
  94.                 if (\array_key_exists($pos, $args)) {
  95.                     @trigger_error(sprintf('Passing "$%s" arguments is deprecated since API Platform 2.4 and will not be possible anymore in API Platform 3. Pass an instance of "%s" as third argument instead.', implode('", "$', array_column($legacyPaginationArgs, 'arg_name')), Paginator::class), \E_USER_DEPRECATED);
  97.                     if (!((null === $arg['default'] && null === $args[$pos]) || \call_user_func("is_{$arg['type']}", $args[$pos]))) {
  98.                         throw new InvalidArgumentException(sprintf('The "$%s" argument is expected to be a %s%s.', $arg['arg_name'], $arg['type'], null === $arg['default'] ? ' or null' : ''));
  99.                     }
  101.                     $value = $args[$pos];
  102.                 } else {
  103.                     $value = $arg['default'];
  104.                 }
  106.                 $this->{$arg['arg_name']} = $value;
  107.             }
  108.         } elseif (!$resourceMetadataFactory instanceof ResourceMetadataFactoryInterface) {
  109.             throw new InvalidArgumentException(sprintf('The "$resourceMetadataFactory" argument is expected to be an implementation of the "%s" interface.', ResourceMetadataFactoryInterface::class));
  110.         } elseif (!$pagination instanceof Pagination) {
  111.             throw new InvalidArgumentException(sprintf('The "$pagination" argument is expected to be an instance of the "%s" class.', Pagination::class));
  112.         }
  114.         $this->managerRegistry = $managerRegistry;
  115.         $this->resourceMetadataFactory = $resourceMetadataFactory;
  116.         $this->pagination = $pagination;
  117.     }
  119.     public function applyToCollection(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, string $operationName = null, array $context = [])
  120.     {
  121.         if (null === $pagination = $this->getPagination($queryBuilder, $resourceClass, $operationName, $context)) {
  122.             return;
  123.         }
  125.         [$offset, $limit] = $pagination;
  127.         $queryBuilder
  128.             ->setFirstResult($offset)
  129.             ->setMaxResults($limit);
  130.     }
  132.     public function supportsResult(string $resourceClass, string $operationName = null, array $context = []): bool
  133.     {
  134.         if ($context['graphql_operation_name'] ?? false) {
  135.             return $this->pagination->isGraphQlEnabled($resourceClass, $operationName, $context);
  136.         }
  138.         if (null === $this->requestStack) {
  139.             return $this->pagination->isEnabled($resourceClass, $operationName, $context);
  140.         }
  142.         if (null === $request = $this->requestStack->getCurrentRequest()) {
  143.             return false;
  144.         }
  146.         return $this->isPaginationEnabled($request, $this->resourceMetadataFactory->create($resourceClass), $operationName);
  147.     }
  149.     public function getResult(QueryBuilder $queryBuilder, string $resourceClass = null, string $operationName = null, array $context = []): iterable
  150.     {
  151.         $query = $queryBuilder->getQuery();
  153.         // Only one alias, without joins, disable the DISTINCT on the COUNT
  154.         if (1 === \count($queryBuilder->getAllAliases())) {
  155.             $query->setHint(CountWalker::HINT_DISTINCT, false);
  156.         }
  158.         $doctrineOrmPaginator = new DoctrineOrmPaginator($query, $this->shouldDoctrinePaginatorFetchJoinCollection($queryBuilder, $resourceClass, $operationName, $context));
  159.         $doctrineOrmPaginator->setUseOutputWalkers($this->shouldDoctrinePaginatorUseOutputWalkers($queryBuilder, $resourceClass, $operationName, $context));
  161.         if (null === $this->requestStack) {
  162.             $isPartialEnabled = $this->pagination->isPartialEnabled($resourceClass, $operationName, $context);
  163.         } else {
  164.             $isPartialEnabled = $this->isPartialPaginationEnabled(
  165.                 $this->requestStack->getCurrentRequest(),
  166.                 null === $resourceClass ? null : $this->resourceMetadataFactory->create($resourceClass),
  167.                 $operationName
  168.             );
  169.         }
  171.         if ($isPartialEnabled) {
  172.             return new class($doctrineOrmPaginator) extends AbstractPaginator {
  173.             };
  174.         }
  176.         return new Paginator($doctrineOrmPaginator);
  177.     }
  179.     /**
  180.      * @throws InvalidArgumentException
  181.      */
  182.     private function getPagination(QueryBuilder $queryBuilder, string $resourceClass, ?string $operationName, array $context): ?array
  183.     {
  184.         $request = null;
  185.         if (null !== $this->requestStack && null === $request = $this->requestStack->getCurrentRequest()) {
  186.             return null;
  187.         }
  189.         if (null === $request) {
  190.             if (!$this->pagination->isEnabled($resourceClass, $operationName, $context)) {
  191.                 return null;
  192.             }
  194.             if (($context['graphql_operation_name'] ?? false) && !$this->pagination->isGraphQlEnabled($resourceClass, $operationName, $context)) {
  195.                 return null;
  196.             }
  198.             $context = $this->addCountToContext($queryBuilder, $context);
  200.             return \array_slice($this->pagination->getPagination($resourceClass, $operationName, $context), 1);
  201.         }
  203.         $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
  204.         if (!$this->isPaginationEnabled($request, $resourceMetadata, $operationName)) {
  205.             return null;
  206.         }
  208.         $itemsPerPage = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_items_per_page', $this->itemsPerPage, true);
  209.         if ($request->attributes->getBoolean('_graphql', false)) {
  210.             $collectionArgs = $request->attributes->get('_graphql_collections_args', []);
  211.             $itemsPerPage = $collectionArgs[$resourceClass]['first'] ?? $itemsPerPage;
  212.         }
  214.         if ($resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_client_items_per_page', $this->clientItemsPerPage, true)) {
  215.             $maxItemsPerPage = $resourceMetadata->getCollectionOperationAttribute($operationName, 'maximum_items_per_page', null, true);
  217.             if (null !== $maxItemsPerPage) {
  218.                 @trigger_error('The "maximum_items_per_page" option has been deprecated since API Platform 2.5 in favor of "pagination_maximum_items_per_page" and will be removed in API Platform 3.', \E_USER_DEPRECATED);
  219.             }
  221.             $maxItemsPerPage = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_maximum_items_per_page', $maxItemsPerPage ?? $this->maximumItemPerPage, true);
  223.             $itemsPerPage = (int) $this->getPaginationParameter($request, $this->itemsPerPageParameterName, $itemsPerPage);
  224.             $itemsPerPage = (null !== $maxItemsPerPage && $itemsPerPage >= $maxItemsPerPage ? $maxItemsPerPage : $itemsPerPage);
  225.         }
  227.         if (0 > $itemsPerPage) {
  228.             throw new InvalidArgumentException('Item per page parameter should not be less than 0');
  229.         }
  231.         $page = (int) $this->getPaginationParameter($request, $this->pageParameterName, 1);
  233.         if (1 > $page) {
  234.             throw new InvalidArgumentException('Page should not be less than 1');
  235.         }
  237.         if (0 === $itemsPerPage && 1 < $page) {
  238.             throw new InvalidArgumentException('Page should not be greater than 1 if itemsPerPage is equal to 0');
  239.         }
  241.         $firstResult = ($page - 1) * $itemsPerPage;
  242.         if ($request->attributes->getBoolean('_graphql', false)) {
  243.             $collectionArgs = $request->attributes->get('_graphql_collections_args', []);
  244.             if (isset($collectionArgs[$resourceClass]['after'])) {
  245.                 $after = base64_decode($collectionArgs[$resourceClass]['after'], true);
  246.                 $firstResult = (int) $after;
  247.                 $firstResult = false === $after ? $firstResult : ++$firstResult;
  248.             }
  249.         }
  251.         return [$firstResult, $itemsPerPage];
  252.     }
  254.     private function isPartialPaginationEnabled(Request $request = null, ResourceMetadata $resourceMetadata = null, string $operationName = null): bool
  255.     {
  256.         $enabled = $this->partial;
  257.         $clientEnabled = $this->clientPartial;
  259.         if ($resourceMetadata) {
  260.             $enabled = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_partial', $enabled, true);
  262.             if ($request) {
  263.                 $clientEnabled = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_client_partial', $clientEnabled, true);
  264.             }
  265.         }
  267.         if ($clientEnabled && $request) {
  268.             $enabled = filter_var($this->getPaginationParameter($request, $this->partialParameterName, $enabled), \FILTER_VALIDATE_BOOLEAN);
  269.         }
  271.         return $enabled;
  272.     }
  274.     private function isPaginationEnabled(Request $request, ResourceMetadata $resourceMetadata, string $operationName = null): bool
  275.     {
  276.         $enabled = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_enabled', $this->enabled, true);
  277.         $clientEnabled = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_client_enabled', $this->clientEnabled, true);
  279.         if ($clientEnabled) {
  280.             $enabled = filter_var($this->getPaginationParameter($request, $this->enabledParameterName, $enabled), \FILTER_VALIDATE_BOOLEAN);
  281.         }
  283.         return $enabled;
  284.     }
  286.     private function getPaginationParameter(Request $request, string $parameterName, $default = null)
  287.     {
  288.         if (null !== $paginationAttribute = $request->attributes->get('_api_pagination')) {
  289.             return \array_key_exists($parameterName, $paginationAttribute) ? $paginationAttribute[$parameterName] : $default;
  290.         }
  292.         return $request->query->all()[$parameterName] ?? $default;
  293.     }
  295.     private function addCountToContext(QueryBuilder $queryBuilder, array $context): array
  296.     {
  297.         if (!($context['graphql_operation_name'] ?? false)) {
  298.             return $context;
  299.         }
  301.         if (isset($context['filters']['last']) && !isset($context['filters']['before'])) {
  302.             $context['count'] = (new DoctrineOrmPaginator($queryBuilder))->count();
  303.         }
  305.         return $context;
  306.     }
  308.     /**
  309.      * Determines the value of the $fetchJoinCollection argument passed to the Doctrine ORM Paginator.
  310.      */
  311.     private function shouldDoctrinePaginatorFetchJoinCollection(QueryBuilder $queryBuilder, string $resourceClass = null, string $operationName = null, array $context = []): bool
  312.     {
  313.         if (null !== $resourceClass) {
  314.             $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
  316.             if (isset($context['collection_operation_name']) && null !== $fetchJoinCollection = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_fetch_join_collection', null, true)) {
  317.                 return $fetchJoinCollection;
  318.             }
  320.             if (isset($context['graphql_operation_name']) && null !== $fetchJoinCollection = $resourceMetadata->getGraphqlAttribute($operationName, 'pagination_fetch_join_collection', null, true)) {
  321.                 return $fetchJoinCollection;
  322.             }
  323.         }
  325.         /*
  326.          * "Cannot count query which selects two FROM components, cannot make distinction"
  327.          *
  328.          * @see https://github.com/doctrine/orm/blob/v2.6.3/lib/Doctrine/ORM/Tools/Pagination/WhereInWalker.php#L81
  329.          * @see https://github.com/doctrine/doctrine2/issues/2910
  330.          */
  331.         if (QueryChecker::hasRootEntityWithCompositeIdentifier($queryBuilder, $this->managerRegistry)) {
  332.             return false;
  333.         }
  335.         if (QueryChecker::hasJoinedToManyAssociation($queryBuilder, $this->managerRegistry)) {
  336.             return true;
  337.         }
  339.         // disable $fetchJoinCollection by default (performance)
  340.         return false;
  341.     }
  343.     /**
  344.      * Determines whether the Doctrine ORM Paginator should use output walkers.
  345.      */
  346.     private function shouldDoctrinePaginatorUseOutputWalkers(QueryBuilder $queryBuilder, string $resourceClass = null, string $operationName = null, array $context = []): bool
  347.     {
  348.         if (null !== $resourceClass) {
  349.             $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
  351.             if (isset($context['collection_operation_name']) && null !== $useOutputWalkers = $resourceMetadata->getCollectionOperationAttribute($operationName, 'pagination_use_output_walkers', null, true)) {
  352.                 return $useOutputWalkers;
  353.             }
  355.             if (isset($context['graphql_operation_name']) && null !== $useOutputWalkers = $resourceMetadata->getGraphqlAttribute($operationName, 'pagination_use_output_walkers', null, true)) {
  356.                 return $useOutputWalkers;
  357.             }
  358.         }
  360.         /*
  361.          * "Cannot count query that uses a HAVING clause. Use the output walkers for pagination"
  362.          *
  363.          * @see https://github.com/doctrine/orm/blob/v2.6.3/lib/Doctrine/ORM/Tools/Pagination/CountWalker.php#L56
  364.          */
  365.         if (QueryChecker::hasHavingClause($queryBuilder)) {
  366.             return true;
  367.         }
  369.         /*
  370.          * "Cannot count query which selects two FROM components, cannot make distinction"
  371.          *
  372.          * @see https://github.com/doctrine/orm/blob/v2.6.3/lib/Doctrine/ORM/Tools/Pagination/CountWalker.php#L64
  373.          */
  374.         if (QueryChecker::hasRootEntityWithCompositeIdentifier($queryBuilder, $this->managerRegistry)) {
  375.             return true;
  376.         }
  378.         /*
  379.          * "Paginating an entity with foreign key as identifier only works when using the Output Walkers. Call Paginator#setUseOutputWalkers(true) before iterating the paginator."
  380.          *
  381.          * @see https://github.com/doctrine/orm/blob/v2.6.3/lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryWalker.php#L77
  382.          */
  383.         if (QueryChecker::hasRootEntityWithForeignKeyIdentifier($queryBuilder, $this->managerRegistry)) {
  384.             return true;
  385.         }
  387.         /*
  388.          * "Cannot select distinct identifiers from query with LIMIT and ORDER BY on a column from a fetch joined to-many association. Use output walkers."
  389.          *
  390.          * @see https://github.com/doctrine/orm/blob/v2.6.3/lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryWalker.php#L150
  391.          */
  392.         if (QueryChecker::hasMaxResults($queryBuilder) && QueryChecker::hasOrderByOnFetchJoinedToManyAssociation($queryBuilder, $this->managerRegistry)) {
  393.             return true;
  394.         }
  396.         // Disable output walkers by default (performance)
  397.         return false;
  398.     }
  399. }