Allow class annotations in the entire class hierarchy, including traits

This allow to declare common Filter and Sorting parent classes or traits
used by the classes.

Author: PowerKiKi

src/Factory/Type/AbstractTypeFactory.php

@@ -7,7 +7,6 @@
 use GraphQL\Doctrine\Exception;
 use GraphQL\Doctrine\Factory\AbstractFactory;
 use GraphQL\Type\Definition\Type;
-use ReflectionClass;
 
 /**
  * A factory to create an ObjectType from a Doctrine entity
@@ -53,15 +52,15 @@ final protected function getDescription(string $className): ?string
     /**
      * Throw an exception if the given type does not inherit expected type
      *
-     * @param ReflectionClass $class
+     * @param string $classWithAnnotation
      * @param string $annotation
-     * @param string $expected
-     * @param string $className
+     * @param string $expectedClassName
+     * @param string $actualClassName
      */
-    final protected function throwIfInvalidAnnotation(ReflectionClass $class, string $annotation, string $expected, string $className): void
+    final protected function throwIfInvalidAnnotation(string $classWithAnnotation, string $annotation, string $expectedClassName, string $actualClassName): void
     {
-        if (!is_a($className, $expected, true)) {
-            throw new Exception('On class `' . $class->getName() . '` the annotation `@API\\' . $annotation . '` expects a FQCN implementing `' . $expected . '`, but instead got: ' . $className);
+        if (!is_a($actualClassName, $expectedClassName, true)) {
+            throw new Exception('On class `' . $classWithAnnotation . '` the annotation `@API\\' . $annotation . '` expects a FQCN implementing `' . $expectedClassName . '`, but instead got: ' . $actualClassName);
         }
     }
 }

src/Factory/Type/FilterTypeFactory.php

@@ -175,7 +175,6 @@ private function getConditionFieldsType(string $className, string $typeName): In
                 $metadata = $this->entityManager->getClassMetadata($className);
 
                 // Get custom operators
-                $this->customOperators = [];
                 $this->readCustomOperatorsFromAnnotation($metadata->reflClass);
 
                 // Get all scalar fields
@@ -294,24 +293,21 @@ private function getOperators(string $fieldName, LeafType $leafType, bool $isAss
      */
     private function readCustomOperatorsFromAnnotation(ReflectionClass $class): void
     {
-        $filters = $this->getAnnotationReader()->getClassAnnotation($class, Filters::class);
-        if ($filters) {
+        $allFilters = Utils::getRecursiveClassAnnotations($this->getAnnotationReader(), $class, Filters::class);
+        $this->customOperators = [];
+        foreach ($allFilters as $classWithAnnotation => $filters) {
 
             /** @var Filter $filter */
             foreach ($filters->filters as $filter) {
                 $className = $filter->operator;
-                $this->throwIfInvalidAnnotation($class, 'Filter', AbstractOperator::class, $className);
+                $this->throwIfInvalidAnnotation($classWithAnnotation, 'Filter', AbstractOperator::class, $className);
 
                 if (!isset($this->customOperators[$filter->field])) {
                     $this->customOperators[$filter->field] = [];
                 }
                 $this->customOperators[$filter->field][] = $filter;
             }
         }
-
-        if ($class->getParentClass()) {
-            $this->readCustomOperatorsFromAnnotation($class->getParentClass());
-        }
     }
 
     /**

src/Factory/Type/SortingTypeFactory.php

@@ -132,22 +132,18 @@ private function fillCache(string $className): void
      */
     private function getFromAnnotation(ReflectionClass $class): array
     {
-        $result = [];
+        $sortings = Utils::getRecursiveClassAnnotations($this->getAnnotationReader(), $class, Sorting::class);
 
-        $sorting = $this->getAnnotationReader()->getClassAnnotation($class, Sorting::class);
-        if ($sorting) {
+        $result = [];
+        foreach ($sortings as $classWithAnnotation => $sorting) {
             foreach ($sorting->classes as $className) {
-                $this->throwIfInvalidAnnotation($class, 'Sorting', SortingInterface::class, $className);
+                $this->throwIfInvalidAnnotation($classWithAnnotation, 'Sorting', SortingInterface::class, $className);
 
                 $name = lcfirst(preg_replace('~Type$~', '', Utils::getTypeName($className)));
                 $result[$name] = new $className();
             }
         }
 
-        if ($class->getParentClass()) {
-            return array_merge($result, $this->getFromAnnotation($class->getParentClass()));
-        }
-
         return $result;
     }
 }

src/Utils.php

@@ -4,9 +4,11 @@
 
 namespace GraphQL\Doctrine;
 
+use Doctrine\Common\Annotations\Reader;
 use GraphQL\Type\Definition\EnumType;
 use GraphQL\Type\Definition\LeafType;
 use GraphQL\Type\Definition\ScalarType;
+use ReflectionClass;
 
 /**
  * A few utils
@@ -39,4 +41,34 @@ public static function getOperatorTypeName(string $className, LeafType $type): s
     {
         return preg_replace('~Type$~', '', self::getTypeName($className)) . ucfirst($type->name);
     }
+
+    /**
+     * Return an array of all annotations found in the class hierarchy, including its traits, indexed by the class name
+     *
+     * @param Reader $reader
+     * @param ReflectionClass $class
+     * @param string $annotationName
+     *
+     * @return array annotations indexed by the class name where they were found
+     */
+    public static function getRecursiveClassAnnotations(Reader $reader, ReflectionClass $class, string $annotationName): array
+    {
+        $result = [];
+
+        $annotation = $reader->getClassAnnotation($class, $annotationName);
+        if ($annotation) {
+            $result[$class->getName()] = $annotation;
+        }
+
+        foreach ($class->getTraits() as $trait) {
+            $result = array_merge($result, self::getRecursiveClassAnnotations($reader, $trait, $annotationName));
+        }
+
+        $parent = $class->getParentClass();
+        if ($parent) {
+            $result = array_merge($result, self::getRecursiveClassAnnotations($reader, $parent, $annotationName));
+        }
+
+        return $result;
+    }
 }

tests/Blog/Model/Special/ModelWithTraits.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQLTests\Doctrine\Blog\Model\Special;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\MappedSuperclass
+ */
+final class ModelWithTraits
+{
+    use TraitWithSortingAndFilter;
+
+    /**
+     * @var int
+     *
+     * @ORM\Column(type="integer", options={"unsigned" = true})
+     * @ORM\Id
+     * @ORM\GeneratedValue(strategy="IDENTITY")
+     */
+    private $id;
+}

tests/Blog/Model/Special/TraitWithSortingAndFilter.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GraphQLTests\Doctrine\Blog\Model\Special;
+
+use GraphQL\Doctrine\Annotation as API;
+
+/**
+ * @API\Sorting({"GraphQLTests\Doctrine\Blog\Sorting\UserName"})
+ * @API\Filters({
+ *     @API\Filter(field="customFromTrait", operator="GraphQLTests\Doctrine\Blog\Filtering\SearchOperatorType", type="string"),
+ * })
+ */
+trait TraitWithSortingAndFilter
+{
+}

tests/Blog/Sorting/PseudoRandom.php

@@ -18,6 +18,6 @@ public function __invoke(QueryBuilder $queryBuilder, string $order): void
         $alias = $queryBuilder->getRootAliases()[0];
 
         $queryBuilder->addSelect('MOD(' . $alias . '.id, 5) AS HIDDEN score');
-        $queryBuilder->orderBy('score', $order);
+        $queryBuilder->addOrderBy('score', $order);
     }
 }

tests/Blog/Sorting/UserName.php

@@ -18,6 +18,6 @@ public function __invoke(QueryBuilder $queryBuilder, string $order): void
         $alias = $queryBuilder->getRootAliases()[0];
 
         $queryBuilder->join($alias . '.user', 'sortingUser');
-        $queryBuilder->orderBy('sortingUser.name', $order);
+        $queryBuilder->addOrderBy('sortingUser.name', $order);
     }
 }

tests/FilterTypesTest.php

@@ -7,6 +7,7 @@
 use GraphQL\Type\Definition\Type;
 use GraphQLTests\Doctrine\Blog\Model\Post;
 use GraphQLTests\Doctrine\Blog\Model\Special\InvalidFilter;
+use GraphQLTests\Doctrine\Blog\Model\Special\ModelWithTraits;
 
 final class FilterTypesTest extends \PHPUnit\Framework\TestCase
 {
@@ -18,6 +19,12 @@ public function testCanGetPostFilter(): void
         $this->assertAllTypes('tests/data/PostFilter.graphqls', $actual);
     }
 
+    public function testCanInheritSortingFromTraits(): void
+    {
+        $actual = $this->types->getFilter(ModelWithTraits::class);
+        $this->assertAllTypes('tests/data/ModelWithTraitsFilter.graphqls', $actual);
+    }
+
     public function providerFilteredQueryBuilder(): array
     {
         $values = [];

tests/SortingTypesTest.php

@@ -5,6 +5,7 @@
 namespace GraphQLTests\Doctrine;
 
 use GraphQLTests\Doctrine\Blog\Model\Post;
+use GraphQLTests\Doctrine\Blog\Model\Special\ModelWithTraits;
 
 final class SortingTypesTest extends \PHPUnit\Framework\TestCase
 {
@@ -15,4 +16,10 @@ public function testCanGetPostSorting(): void
         $actual = $this->types->getSorting(Post::class);
         $this->assertAllTypes('tests/data/PostSorting.graphqls', $actual);
     }
+
+    public function testCanInheritSortingFromTraits(): void
+    {
+        $actual = $this->types->getSorting(ModelWithTraits::class);
+        $this->assertAllTypes('tests/data/ModelWithTraitsSorting.graphqls', $actual);
+    }
 }