Merge pull request #337 from vincentchalamon/filter_nested

Doctrine filters: Allow nested properties (across relations)

Author: dunglas

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.1.0
+
+* Support nested properties in Doctrine filters
+* Add method to avoid naming collision of DQL join alias and bound parameter name
+
 ## 1.0.0 beta 3
 
 * The Hydra documentation URL is now `/apidoc` (was `/vocab`)

Doctrine/Orm/DataProvider.php

@@ -16,6 +16,7 @@
 use Doctrine\ORM\Tools\Pagination\Paginator as DoctrineOrmPaginator;
 use Doctrine\ORM\QueryBuilder;
 use Dunglas\ApiBundle\Doctrine\Orm\Filter\FilterInterface;
+use Dunglas\ApiBundle\Doctrine\Orm\Util\QueryChecker;
 use Dunglas\ApiBundle\Model\DataProviderInterface;
 use Dunglas\ApiBundle\Api\ResourceInterface;
 use Symfony\Component\HttpFoundation\Request;
@@ -140,6 +141,14 @@ public function getCollection(ResourceInterface $resource, Request $request)
         return $this->getPaginator($queryBuilder);
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function supports(ResourceInterface $resource)
+    {
+        return null !== $this->managerRegistry->getManagerForClass($resource->getEntityClass());
+    }
+
     /**
      * Gets the paginator.
      *
@@ -151,16 +160,49 @@ protected function getPaginator(QueryBuilder $queryBuilder)
     {
         $doctrineOrmPaginator = new DoctrineOrmPaginator($queryBuilder);
         // Disable output walkers by default (performance)
-        $doctrineOrmPaginator->setUseOutputWalkers(false);
+        $doctrineOrmPaginator->setUseOutputWalkers($this->useOutputWalkers($queryBuilder));
 
         return new Paginator($doctrineOrmPaginator);
     }
 
     /**
-     * {@inheritdoc}
+     * Determines whether output walkers should be used.
+     *
+     * @param QueryBuilder $queryBuilder
+     *
+     * @return bool
      */
-    public function supports(ResourceInterface $resource)
+    private function useOutputWalkers(QueryBuilder $queryBuilder)
     {
-        return null !== $this->managerRegistry->getManagerForClass($resource->getEntityClass());
+        /*
+         * "Cannot count query that uses a HAVING clause. Use the output walkers for pagination"
+         *
+         * @see https://github.com/doctrine/doctrine2/blob/900b55d16afdcdeb5100d435a7166d3a425b9873/lib/Doctrine/ORM/Tools/Pagination/CountWalker.php#L50
+         */
+        if (QueryChecker::hasHavingClause($queryBuilder)) {
+            return true;
+        }
+        /*
+         * "Paginating an entity with foreign key as identifier only works when using the Output Walkers. Call Paginator#setUseOutputWalkers(true) before iterating the paginator."
+         *
+         * @see https://github.com/doctrine/doctrine2/blob/900b55d16afdcdeb5100d435a7166d3a425b9873/lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryWalker.php#L87
+         */
+        if (QueryChecker::hasRootEntityWithForeignKeyIdentifier($queryBuilder, $this->managerRegistry)) {
+            return true;
+        }
+        /*
+         * "Cannot select distinct identifiers from query with LIMIT and ORDER BY on a column from a fetch joined to-many association. Use output walkers."
+         *
+         * @see https://github.com/doctrine/doctrine2/blob/900b55d16afdcdeb5100d435a7166d3a425b9873/lib/Doctrine/ORM/Tools/Pagination/LimitSubqueryWalker.php#L149
+         */
+        if (
+            QueryChecker::hasMaxResults($queryBuilder)
+            && QueryChecker::hasOrderByOnToManyJoin($queryBuilder, $this->managerRegistry)
+        ) {
+            return true;
+        }
+
+        // Disable output walkers by default (performance)
+        return false;
     }
 }

Doctrine/Orm/Filter/AbstractFilter.php

@@ -14,6 +14,7 @@
 use Doctrine\Common\Persistence\ManagerRegistry;
 use Doctrine\Common\Persistence\Mapping\ClassMetadata;
 use Dunglas\ApiBundle\Api\ResourceInterface;
+use Dunglas\ApiBundle\Util\RequestParser;
 use Symfony\Component\HttpFoundation\Request;
 
 /**
@@ -23,6 +24,7 @@
  *
  * @author Kévin Dunglas <[email protected]>
  * @author Théo FIDRY <[email protected]>
+ * @author Vincent Chalamon <[email protected]>
  */
 abstract class AbstractFilter implements FilterInterface
 {
@@ -61,15 +63,102 @@ protected function getClassMetadata(ResourceInterface $resource)
     }
 
     /**
-     * Is the given property enabled?
+     * Determines whether the given property is enabled.
      *
      * @param string $property
      *
      * @return bool
      */
     protected function isPropertyEnabled($property)
     {
-        return null === $this->properties || array_key_exists($property, $this->properties);
+        if (null === $this->properties) {
+            // to ensure sanity, nested properties must still be explicitly enabled
+            return !$this->isPropertyNested($property);
+        }
+
+        return array_key_exists($property, $this->properties);
+    }
+
+    /**
+     * Determines whether the given property is mapped.
+     *
+     * @param string            $property
+     * @param ResourceInterface $resource
+     * @param bool              $allowAssociation
+     *
+     * @return bool
+     */
+    protected function isPropertyMapped($property, ResourceInterface $resource, $allowAssociation = false)
+    {
+        if ($this->isPropertyNested($property)) {
+            $propertyParts = $this->splitPropertyParts($property);
+            $metadata = $this->getNestedMetadata($resource, $propertyParts['associations']);
+            $property = $propertyParts['field'];
+        } else {
+            $metadata = $this->getClassMetadata($resource);
+        }
+
+        return $metadata->hasField($property) || ($allowAssociation && $metadata->hasAssociation($property));
+    }
+
+    /**
+     * Determines whether the given property is nested.
+     *
+     * @param string $property
+     *
+     * @return bool
+     */
+    protected function isPropertyNested($property)
+    {
+        return false !== strpos($property, '.');
+    }
+
+    /**
+     * Gets nested class metadata for the given resource.
+     *
+     * @param ResourceInterface $resource
+     * @param string[]          $associations
+     *
+     * @return ClassMetadata
+     */
+    protected function getNestedMetadata(ResourceInterface $resource, array $associations)
+    {
+        $metadata = $this->getClassMetadata($resource);
+
+        foreach ($associations as $association) {
+            if ($metadata->hasAssociation($association)) {
+                $associationClass = $metadata->getAssociationTargetClass($association);
+
+                $metadata = $this
+                    ->managerRegistry
+                    ->getManagerForClass($associationClass)
+                    ->getClassMetadata($associationClass)
+                ;
+            }
+        }
+
+        return $metadata;
+    }
+
+    /**
+     * Splits the given property into parts.
+     *
+     * Returns an array with the following keys:
+     *   - associations: array of associations according to nesting order
+     *   - field: string holding the actual field (leaf node)
+     *
+     * @param string $property
+     *
+     * @return array
+     */
+    protected function splitPropertyParts($property)
+    {
+        $parts = explode('.', $property);
+
+        return [
+            'associations' => array_slice($parts, 0, -1),
+            'field' => end($parts),
+        ];
     }
 
     /**
@@ -81,6 +170,20 @@ protected function isPropertyEnabled($property)
      */
     protected function extractProperties(Request $request)
     {
+        $needsFixing = false;
+
+        if (null !== $this->properties) {
+            foreach ($this->properties as $property => $value) {
+                if ($this->isPropertyNested($property) && $request->query->has(str_replace('.', '_', $property))) {
+                    $needsFixing = true;
+                }
+            }
+        }
+
+        if ($needsFixing) {
+            $request = RequestParser::parseAndDuplicateRequest($request);
+        }
+
         return $request->query->all();
     }
 }