Entity without relations must not have an empty FilterGroupJoin

GraphQL does not allow to have type without any fields, so we must
check that before outputing FilterGroupJoin.

Fixes #22

Author: PowerKiKi

src/Factory/Type/FilterGroupJoinTypeFactory.php

@@ -77,4 +77,16 @@ private function getJoinsFields(string $className): array
 
         return $fields;
     }
+
+    /**
+     * Return whether it is possible to create a valid type for join
+     *
+     * @param string $className
+     *
+     * @return bool
+     */
+    public function canCreate(string $className): bool
+    {
+        return !empty($this->entityManager->getClassMetadata($className)->associationMappings);
+    }
 }

src/Factory/Type/FilterTypeFactory.php

@@ -75,27 +75,32 @@ public function create(string $className, string $typeName): Type
      */
     private function getGroupType(string $className, string $typeName): InputObjectType
     {
+        $fields = [
+            [
+                'name' => 'groupLogic',
+                'type' => $this->types->get('LogicalOperator'),
+                'description' => 'The logic operator to be used to append this group',
+                'defaultValue' => 'AND',
+            ],
+            [
+                'name' => 'conditionsLogic',
+                'type' => $this->types->get('LogicalOperator'),
+                'description' => 'The logic operator to be used within all conditions in this group',
+                'defaultValue' => 'AND',
+            ],
+            $this->filterGroupConditionTypeFactory->getField($className),
+        ];
+
+        // Only create join type, if there is anything to join on
+        if ($this->filterGroupJoinTypeFactory->canCreate($className)) {
+            $fields[] = $this->filterGroupJoinTypeFactory->getField($className);
+        }
+
         $conditionType = new InputObjectType([
             'name' => $typeName . 'Group',
             'description' => 'Specify a set of joins and conditions to filter `' . Utils::getTypeName($className) . '`',
-            'fields' => [
-                [
-                    'name' => 'groupLogic',
-                    'type' => $this->types->get('LogicalOperator'),
-                    'description' => 'The logic operator to be used to append this group',
-                    'defaultValue' => 'AND',
-                ],
-                [
-                    'name' => 'conditionsLogic',
-                    'type' => $this->types->get('LogicalOperator'),
-                    'description' => 'The logic operator to be used within all conditions in this group',
-                    'defaultValue' => 'AND',
-                ],
-                $this->filterGroupJoinTypeFactory->getField($className),
-                $this->filterGroupConditionTypeFactory->getField($className),
-            ],
+            'fields' => $fields,
         ]);
-
         $this->types->registerInstance($conditionType);
 
         return $conditionType;

tests/FilterTypesTest.php

@@ -20,7 +20,7 @@ public function testCanGetPostFilter(): void
         $this->assertAllTypes('tests/data/PostFilter.graphqls', $actual);
     }
 
-    public function testCanInheritSortingFromTraits(): void
+    public function testCanInheritFilterFromTraits(): void
     {
         $actual = $this->types->getFilter(ModelWithTraits::class);
         $this->assertAllTypes('tests/data/ModelWithTraitsFilter.graphqls', $actual);

tests/TypesTrait.php

@@ -7,9 +7,11 @@
 use DateTime;
 use GraphQL\Doctrine\Types;
 use GraphQL\Type\Definition\BooleanType;
+use GraphQL\Type\Definition\InputType;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\OutputType;
 use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\WrappingType;
 use GraphQL\Type\Schema;
 use GraphQL\Utils\SchemaPrinter;
 use GraphQLTests\Doctrine\Blog\Types\CustomType;
@@ -72,29 +74,39 @@ private function assertAllTypes(string $expectedFile, Type $type): void
      */
     private function getSchemaForType(Type $type): Schema
     {
-        if ($type instanceof OutputType) {
-            $config = [
-                'query' => new ObjectType([
-                    'name' => 'query',
-                    'fields' => [
-                        'defaultField' => $type,
-                    ],
-                ]),
-            ];
+        if ($type instanceof WrappingType) {
+            $wrappedType = $type->getWrappedType(true);
         } else {
-            $config = [
-                'query' => new ObjectType([
-                    'name' => 'query',
-                ]),
-                'mutation' => new ObjectType([
-                    'name' => 'mutation',
-                    'fields' => [
-                        'defaultField' => $type,
-                    ],
-                ]),
+            $wrappedType = $type;
+        }
+
+        if ($wrappedType instanceof OutputType) {
+            $outputType = $type;
+            $args = [];
+        } elseif ($wrappedType instanceof InputType) {
+            $outputType = Type::boolean();
+            $args = [
+                'defaultArg' => $type,
             ];
+        } else {
+            throw new \Exception('Unsupported type: ' . get_class($wrappedType));
         }
 
-        return new Schema($config);
+        $config = [
+            'query' => new ObjectType([
+                'name' => 'query',
+                'fields' => [
+                    'defaultField' => [
+                        'type' => $outputType,
+                        'args' => $args,
+                    ],
+                ],
+            ]),
+        ];
+
+        $schema = new Schema($config);
+        $schema->assertValid();
+
+        return $schema;
     }
 }

tests/data/ModelWithTraitsFilter.graphqls

@@ -1,6 +1,5 @@
 schema {
   query: query
-  mutation: mutation
 }
 
 input BetweenOperatorID {
@@ -74,11 +73,6 @@ input ModelWithTraitsFilterGroup {
   """The logic operator to be used within all conditions in this group"""
   conditionsLogic: LogicalOperator = AND
 
-  """
-  Optional joins to either filter the query or fetch related objects from DB in a single query
-  """
-  joins: ModelWithTraitsFilterGroupJoin
-
   """Conditions to be applied on fields"""
   conditions: [ModelWithTraitsFilterGroupCondition!]
 }
@@ -108,11 +102,6 @@ input ModelWithTraitsFilterGroupConditionId {
   group: GroupOperatorID
 }
 
-"""Type to specify join tables in a filter"""
-input ModelWithTraitsFilterGroupJoin {
-
-}
-
 input NullOperatorID {
   not: Boolean = false
 }
@@ -121,10 +110,6 @@ input SearchOperatorString {
   term: String!
 }
 
-type mutation {
-  defaultField: ModelWithTraitsFilter
-}
-
 type query {
-
+  defaultField(defaultArg: ModelWithTraitsFilter): Boolean
 }

tests/data/ModelWithTraitsSorting.graphqls

@@ -20,5 +20,5 @@ enum SortingOrder {
 }
 
 type query {
-  defaultField: [ModelWithTraitsSorting!]
+  defaultField(defaultArg: [ModelWithTraitsSorting!]): Boolean
 }

tests/data/PostFilter.graphqls

@@ -1,6 +1,5 @@
 schema {
   query: query
-  mutation: mutation
 }
 
 input BetweenOperatorBoolean {
@@ -299,13 +298,13 @@ input PostFilterGroup {
   """The logic operator to be used within all conditions in this group"""
   conditionsLogic: LogicalOperator = AND
 
+  """Conditions to be applied on fields"""
+  conditions: [PostFilterGroupCondition!]
+
   """
   Optional joins to either filter the query or fetch related objects from DB in a single query
   """
   joins: PostFilterGroupJoin
-
-  """Conditions to be applied on fields"""
-  conditions: [PostFilterGroupCondition!]
 }
 
 """Type to specify conditions on fields"""
@@ -560,10 +559,6 @@ input UserFilterGroupJoin {
   manager: JoinOnUser
 }
 
-type mutation {
-  defaultField: PostFilter
-}
-
 type query {
-
+  defaultField(defaultArg: PostFilter): Boolean
 }

tests/data/PostSorting.graphqls

@@ -26,5 +26,5 @@ enum SortingOrder {
 }
 
 type query {
-  defaultField: [PostSorting!]
+  defaultField(defaultArg: [PostSorting!]): Boolean
 }