Merge pull request #1228 from hercemer42/eager-loading

dunglas · web-flow · commit 131c91ba12c1 · 2017-07-19T19:41:08.000+02:00
Implement maxDepth in eager loading extension
diff --git a/features/main/recursive.feature b/features/main/recursive.feature
@@ -0,0 +1,72 @@
+Feature: Max depth handling
+  In order to handle recursive resources
+  As a developer
+  I need to be able to limit their depth with @maxDepth
+
+  @createSchema
+  Scenario: Create a non-recursive resource
+    When I add "Content-Type" header equal to "application/ld+json"
+    And I send a "POST" request to "/recursives" with body:
+    """
+    {
+      "name": "Fry's grandpa",
+      "child": {
+        "name": "Fry"
+      }
+    }
+    """
+    Then the response status code should be 201
+    And the response should be in JSON
+    And the header "Content-Type" should be equal to "application/ld+json; charset=utf-8"
+    And the JSON should be equal to:
+    """
+    {
+      "@context": "/contexts/Recursive",
+      "@id": "/recursives/1",
+      "@type": "Recursive",
+      "id": 1,
+      "name": "Fry's grandpa",
+      "child": {
+        "@id": "/recursive_children/1",
+        "@type": "RecursiveChild",
+        "id": 1,
+        "name": "Fry",
+        "parent": null
+      }
+    }
+    """
+
+  @dropSchema
+  Scenario: Make the resource recursive
+    When I add "Content-Type" header equal to "application/ld+json"
+    And I send a "PUT" request to "recursives/1" with body:
+    """
+    {
+      "@id": "/recursives/1",
+      "child": {
+        "@id": "/recursive_children/1",
+        "parent": "/recursives/1"
+      }
+    }
+    """
+    Then print last JSON response
+    And the response status code should be 200
+    And the response should be in JSON
+    And the header "Content-Type" should be equal to "application/ld+json; charset=utf-8"
+    And the JSON should be equal to:
+    """
+    {
+      "@context": "/contexts/Recursive",
+      "@id": "/recursives/1",
+      "@type": "Recursive",
+      "id": 1,
+      "name": "Fry's grandpa",
+      "child": {
+        "@id": "/recursive_children/1",
+        "@type": "RecursiveChild",
+        "id": 1,
+        "name": "Fry",
+        "parent": "/recursives/1"
+      }
+    }
+    """
diff --git a/src/Bridge/Doctrine/Orm/Extension/EagerLoadingExtension.php b/src/Bridge/Doctrine/Orm/Extension/EagerLoadingExtension.php
@@ -25,6 +25,7 @@
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
 use Doctrine\ORM\QueryBuilder;
 use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
 
 /**
  * Eager loads relations.
@@ -40,18 +41,20 @@ final class EagerLoadingExtension implements QueryCollectionExtensionInterface,
 
     private $propertyNameCollectionFactory;
     private $propertyMetadataFactory;
+    private $classMetadataFactory;
     private $maxJoins;
     private $serializerContextBuilder;
     private $requestStack;
 
     /**
      * @TODO move $fetchPartial after $forceEager (@soyuka) in 3.0
      */
-    public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, ResourceMetadataFactoryInterface $resourceMetadataFactory, int $maxJoins = 30, bool $forceEager = true, RequestStack $requestStack = null, SerializerContextBuilderInterface $serializerContextBuilder = null, bool $fetchPartial = false)
+    public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, ResourceMetadataFactoryInterface $resourceMetadataFactory, int $maxJoins = 30, bool $forceEager = true, RequestStack $requestStack = null, SerializerContextBuilderInterface $serializerContextBuilder = null, bool $fetchPartial = false, ClassMetadataFactoryInterface $classMetadataFactory = null)
     {
         $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
         $this->propertyMetadataFactory = $propertyMetadataFactory;
         $this->resourceMetadataFactory = $resourceMetadataFactory;
+        $this->classMetadataFactory = $classMetadataFactory;
         $this->maxJoins = $maxJoins;
         $this->forceEager = $forceEager;
         $this->fetchPartial = $fetchPartial;
@@ -72,10 +75,11 @@ public function applyToCollection(QueryBuilder $queryBuilder, QueryNameGenerator
 
         $forceEager = $this->shouldOperationForceEager($resourceClass, $options);
         $fetchPartial = $this->shouldOperationFetchPartial($resourceClass, $options);
+        $serializerContext = $this->getSerializerContext($resourceClass, 'normalization_context', $options);
 
-        $groups = $this->getSerializerGroups($resourceClass, $options, 'normalization_context');
+        $groups = $this->getSerializerGroups($options, $serializerContext);
 
-        $this->joinRelations($queryBuilder, $queryNameGenerator, $resourceClass, $forceEager, $fetchPartial, $queryBuilder->getRootAliases()[0], $groups);
+        $this->joinRelations($queryBuilder, $queryNameGenerator, $resourceClass, $forceEager, $fetchPartial, $queryBuilder->getRootAliases()[0], $groups, $serializerContext);
     }
 
     /**
@@ -92,16 +96,16 @@ public function applyToItem(QueryBuilder $queryBuilder, QueryNameGeneratorInterf
 
         $forceEager = $this->shouldOperationForceEager($resourceClass, $options);
         $fetchPartial = $this->shouldOperationFetchPartial($resourceClass, $options);
+        $contextType = isset($context['api_denormalize']) ? 'denormalization_context' : 'normalization_context';
+        $serializerContext = $this->getSerializerContext($context['resource_class'] ?? $resourceClass, $contextType, $options);
 
         if (isset($context['groups'])) {
             $groups = ['serializer_groups' => $context['groups']];
-        } elseif (isset($context['resource_class'])) {
-            $groups = $this->getSerializerGroups($context['resource_class'], $options, isset($context['api_denormalize']) ? 'denormalization_context' : 'normalization_context');
         } else {
-            $groups = $this->getSerializerGroups($resourceClass, $options, 'normalization_context');
+            $groups = $this->getSerializerGroups($options, $serializerContext);
         }
 
-        $this->joinRelations($queryBuilder, $queryNameGenerator, $resourceClass, $forceEager, $fetchPartial, $queryBuilder->getRootAliases()[0], $groups);
+        $this->joinRelations($queryBuilder, $queryNameGenerator, $resourceClass, $forceEager, $fetchPartial, $queryBuilder->getRootAliases()[0], $groups, $serializerContext);
     }
 
     /**
@@ -113,21 +117,30 @@ public function applyToItem(QueryBuilder $queryBuilder, QueryNameGeneratorInterf
      * @param bool                        $forceEager
      * @param string                      $parentAlias
      * @param array                       $propertyMetadataOptions
+     * @param array                       $context
      * @param bool                        $wasLeftJoin             if the relation containing the new one had a left join, we have to force the new one to left join too
      * @param int                         $joinCount               the number of joins
+     * @param int                         $currentDepth            the current max depth
      *
      * @throws RuntimeException when the max number of joins has been reached
      */
-    private function joinRelations(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, bool $forceEager, bool $fetchPartial, string $parentAlias, array $propertyMetadataOptions = [], bool $wasLeftJoin = false, int &$joinCount = 0)
+    private function joinRelations(QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, bool $forceEager, bool $fetchPartial, string $parentAlias, array $propertyMetadataOptions = [], array $context = [], bool $wasLeftJoin = false, int &$joinCount = 0, int $currentDepth = null)
     {
         if ($joinCount > $this->maxJoins) {
-            throw new RuntimeException('The total number of joined relations has exceeded the specified maximum. Raise the limit if necessary.');
+            throw new RuntimeException('The total number of joined relations has exceeded the specified maximum. Raise the limit if necessary, or use the "max_depth" option of the Symfony serializer.');
         }
 
+        $currentDepth = $currentDepth > 0 ? $currentDepth - 1 : $currentDepth;
         $entityManager = $queryBuilder->getEntityManager();
         $classMetadata = $entityManager->getClassMetadata($resourceClass);
+        $attributesMetadata = $this->classMetadataFactory ? $this->classMetadataFactory->getMetadataFor($resourceClass)->getAttributesMetadata() : null;
 
         foreach ($classMetadata->associationMappings as $association => $mapping) {
+            //Don't join if max depth is enabled and the current depth limit is reached
+            if (isset($context['enable_max_depth']) && 0 === $currentDepth) {
+                continue;
+            }
+
             try {
                 $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $association, $propertyMetadataOptions);
             } catch (PropertyNotFoundException $propertyNotFoundException) {
@@ -174,7 +187,16 @@ private function joinRelations(QueryBuilder $queryBuilder, QueryNameGeneratorInt
                 continue;
             }
 
-            $this->joinRelations($queryBuilder, $queryNameGenerator, $mapping['targetEntity'], $forceEager, $fetchPartial, $associationAlias, $propertyMetadataOptions, $method === 'leftJoin', $joinCount);
+            if (isset($attributesMetadata[$association])) {
+                $maxDepth = $attributesMetadata[$association]->getMaxDepth();
+
+                // The current depth is the lowest max depth available in the ancestor tree.
+                if (null !== $maxDepth && (null === $currentDepth || $maxDepth < $currentDepth)) {
+                    $currentDepth = $maxDepth;
+                }
+            }
+
+            $this->joinRelations($queryBuilder, $queryNameGenerator, $mapping['targetEntity'], $forceEager, $fetchPartial, $associationAlias, $propertyMetadataOptions, $context, $method === 'leftJoin', $joinCount, $currentDepth);
         }
     }
 
@@ -215,15 +237,15 @@ private function addSelect(QueryBuilder $queryBuilder, string $entity, string $a
     }
 
     /**
-     * Gets serializer groups if available, if not it returns the $options array.
+     * Gets serializer context.
      *
      * @param string $resourceClass
+     * @param string $contextType   normalization_context or denormalization_context
      * @param array  $options       represents the operation name so that groups are the one of the specific operation
-     * @param string $context       normalization_context or denormalization_context
      *
      * @return array
      */
-    private function getSerializerGroups(string $resourceClass, array $options, string $context): array
+    private function getSerializerContext(string $resourceClass, string $contextType, array $options): array
     {
         $request = null;
 
@@ -232,23 +254,32 @@ private function getSerializerGroups(string $resourceClass, array $options, stri
         }
 
         if (null !== $this->serializerContextBuilder && null !== $request) {
-            $contextFromRequest = $this->serializerContextBuilder->createFromRequest($request, $context === 'normalization_context');
-
-            if (isset($contextFromRequest['groups'])) {
-                return ['serializer_groups' => $contextFromRequest['groups']];
-            }
+            return $this->serializerContextBuilder->createFromRequest($request, 'normalization_context' === $contextType);
         }
 
         $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
 
         if (isset($options['collection_operation_name'])) {
-            $context = $resourceMetadata->getCollectionOperationAttribute($options['collection_operation_name'], $context, null, true);
+            $context = $resourceMetadata->getCollectionOperationAttribute($options['collection_operation_name'], $contextType, null, true);
         } elseif (isset($options['item_operation_name'])) {
-            $context = $resourceMetadata->getItemOperationAttribute($options['item_operation_name'], $context, null, true);
+            $context = $resourceMetadata->getItemOperationAttribute($options['item_operation_name'], $contextType, null, true);
         } else {
-            $context = $resourceMetadata->getAttribute($context);
+            $context = $resourceMetadata->getAttribute($contextType);
         }
 
+        return $context ? $context : [];
+    }
+
+    /**
+     * Gets serializer groups if available, if not it returns the $options array.
+     *
+     * @param array $options represents the operation name so that groups are the one of the specific operation
+     * @param array $context
+     *
+     * @return array
+     */
+    private function getSerializerGroups(array $options, array $context): array
+    {
         if (empty($context['groups'])) {
             return $options;
         }
diff --git a/src/Bridge/Symfony/Bundle/Resources/config/doctrine_orm.xml b/src/Bridge/Symfony/Bundle/Resources/config/doctrine_orm.xml
@@ -114,6 +114,7 @@
             <argument type="service" id="request_stack" />
             <argument type="service" id="api_platform.serializer.context_builder" />
             <argument>%api_platform.eager_loading.fetch_partial%</argument>
+            <argument type="service" id="serializer.mapping.class_metadata_factory"></argument>
 
             <tag name="api_platform.doctrine.orm.query_extension.item" priority="64" />
             <tag name="api_platform.doctrine.orm.query_extension.collection" priority="64" />
diff --git a/tests/Bridge/Doctrine/Orm/Extension/EagerLoadingExtensionTest.php b/tests/Bridge/Doctrine/Orm/Extension/EagerLoadingExtensionTest.php
@@ -36,6 +36,9 @@
 use Prophecy\Argument;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Serializer\Mapping\AttributeMetadata;
+use Symfony\Component\Serializer\Mapping\ClassMetadataInterface;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
 
 /**
  * @author Amrouche Hamza <hamza.simperfit@gmail.com>
@@ -316,9 +319,9 @@ public function testDenormalizeItemWithExistingGroups()
 
     /**
      * @expectedException \ApiPlatform\Core\Exception\RuntimeException
-     * @expectedExceptionMessage The total number of joined relations has exceeded the specified maximum. Raise the limit if necessary.
+     * @expectedExceptionMessage The total number of joined relations has exceeded the specified maximum. Raise the limit if necessary, or use the "max_depth" option of the Symfony serializer.
      */
-    public function testMaxDepthReached()
+    public function testMaxJoinsReached()
     {
         $resourceMetadataFactoryProphecy = $this->prophesize(ResourceMetadataFactoryInterface::class);
         $resourceMetadataFactoryProphecy->create(Dummy::class)->willReturn(new ResourceMetadata());
@@ -367,6 +370,74 @@ public function testMaxDepthReached()
         $eagerExtensionTest->applyToCollection($queryBuilderProphecy->reveal(), new QueryNameGenerator(), Dummy::class);
     }
 
+    public function testMaxDepth()
+    {
+        $resourceMetadataFactoryProphecy = $this->prophesize(ResourceMetadataFactoryInterface::class);
+        $resourceMetadata = new ResourceMetadata();
+        $resourceMetadata = $resourceMetadata->withAttributes(['normalization_context' => ['enable_max_depth' => 'true']]);
+
+        $resourceMetadataFactoryProphecy->create(Dummy::class)->willReturn($resourceMetadata);
+
+        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
+
+        $relatedNameCollection = new PropertyNameCollection(['dummy']);
+        $dummyNameCollection = new PropertyNameCollection(['relatedDummy']);
+
+        $propertyNameCollectionFactoryProphecy->create(RelatedDummy::class)->willReturn($relatedNameCollection)->shouldBeCalled();
+        $propertyNameCollectionFactoryProphecy->create(Dummy::class)->willReturn($dummyNameCollection)->shouldBeCalled();
+
+        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
+        $relationPropertyMetadata = new PropertyMetadata();
+        $relationPropertyMetadata = $relationPropertyMetadata->withReadableLink(true);
+
+        $propertyMetadataFactoryProphecy->create(Dummy::class, 'relatedDummy', [])->willReturn($relationPropertyMetadata)->shouldBeCalled();
+
+        $relatedPropertyMetadata = new PropertyMetadata();
+        $relatedPropertyMetadata = $relatedPropertyMetadata->withReadableLink(true);
+
+        $propertyMetadataFactoryProphecy->create(RelatedDummy::class, 'dummy', [])->willReturn($relatedPropertyMetadata)->shouldBeCalled();
+
+        $classMetadataProphecy = $this->prophesize(ClassMetadata::class);
+        $classMetadataProphecy->associationMappings = [
+            'relatedDummy' => ['fetch' => 3, 'joinColumns' => [['nullable' => false]], 'targetEntity' => RelatedDummy::class],
+        ];
+
+        $relatedClassMetadataProphecy = $this->prophesize(ClassMetadata::class);
+        $relatedClassMetadataProphecy->associationMappings = [
+            'dummy' => ['fetch' => 3, 'joinColumns' => [['nullable' => false]], 'targetEntity' => Dummy::class],
+        ];
+
+        $dummyClassMetadataInterfaceProphecy = $this->prophesize(ClassMetadataInterface::class);
+        $relatedClassMetadataInterfaceProphecy = $this->prophesize(ClassMetadataInterface::class);
+        $classMetadataFactoryProphecy = $this->prophesize(ClassMetadataFactoryInterface::class);
+
+        $dummyAttributeMetadata = new AttributeMetadata('dummy');
+        $dummyAttributeMetadata->setMaxDepth(2);
+
+        $relatedAttributeMetadata = new AttributeMetadata('relatedDummy');
+        $relatedAttributeMetadata->setMaxDepth(4);
+
+        $dummyClassMetadataInterfaceProphecy->getAttributesMetadata()->willReturn(['relatedDummy' => $dummyAttributeMetadata]);
+        $relatedClassMetadataInterfaceProphecy->getAttributesMetadata()->willReturn(['dummy' => $relatedAttributeMetadata]);
+
+        $classMetadataFactoryProphecy->getMetadataFor(RelatedDummy::class)->willReturn($relatedClassMetadataInterfaceProphecy->reveal());
+        $classMetadataFactoryProphecy->getMetadataFor(Dummy::class)->willReturn($dummyClassMetadataInterfaceProphecy->reveal());
+
+        $emProphecy = $this->prophesize(EntityManager::class);
+        $emProphecy->getClassMetadata(Dummy::class)->shouldBeCalled()->willReturn($classMetadataProphecy->reveal());
+        $emProphecy->getClassMetadata(RelatedDummy::class)->shouldBeCalled()->willReturn($relatedClassMetadataProphecy->reveal());
+
+        $queryBuilderProphecy = $this->prophesize(QueryBuilder::class);
+        $queryBuilderProphecy->getRootAliases()->willReturn(['o']);
+        $queryBuilderProphecy->getEntityManager()->willReturn($emProphecy);
+
+        $queryBuilderProphecy->innerJoin(Argument::type('string'), Argument::type('string'))->shouldBeCalledTimes(2);
+        $queryBuilderProphecy->addSelect(Argument::type('string'))->shouldBeCalled();
+
+        $eagerExtensionTest = new EagerLoadingExtension($propertyNameCollectionFactoryProphecy->reveal(), $propertyMetadataFactoryProphecy->reveal(), $resourceMetadataFactoryProphecy->reveal(), 30, false, null, null, true, $classMetadataFactoryProphecy->reveal());
+        $eagerExtensionTest->applyToCollection($queryBuilderProphecy->reveal(), new QueryNameGenerator(), Dummy::class);
+    }
+
     public function testForceEager()
     {
         $resourceMetadata = new ResourceMetadata();
diff --git a/tests/Fixtures/TestBundle/Entity/Recursive.php b/tests/Fixtures/TestBundle/Entity/Recursive.php
diff --git a/tests/Fixtures/TestBundle/Entity/RecursiveChild.php b/tests/Fixtures/TestBundle/Entity/RecursiveChild.php
