Merge pull request #735 from bartv2/patch-2

Fix Input Field annotations handling

Author: Vincz

docs/annotations/index.md

@@ -116,6 +116,27 @@ In the previous example, the generated `resolve` config of the `something` field
 
 ## Type & Args auto-guessing
 
+### @Field type auto-guessing when defined on a property with a type hint
+
+The type of the `@Field` annotation can be auto-guessed if it's defined on a property with a type hint.
+If the property has a usable type hint this is used and no futher guessing is done.
+
+For example:
+
+```php
+/**
+ * @GQL\Type
+ */
+class MyType {
+    /**
+     * @GQL\Field
+     */
+    protected string $property;
+}
+```
+
+In this example, the type `String!` will be auto-guessed from the type hint of the property.  
+
 ### @Field type auto-guessing from Doctrine ORM Annotations
 
 Based on other Doctrine annotations on your fields, the corresponding GraphQL type can sometimes be guessed automatically.  

src/Config/Parser/AnnotationParser.php

@@ -585,7 +585,7 @@ private static function getTypeFieldConfigurationFromReflector(GraphClass $graph
                     }
                 } else {
                     try {
-                        $fieldConfiguration['type'] = self::guessType($graphClass, $annotations);
+                        $fieldConfiguration['type'] = self::guessType($graphClass, $reflector, self::VALID_OUTPUT_TYPES);
                     } catch (Exception $e) {
                         throw new InvalidArgumentException(sprintf('The attribute "type" on "@%s" defined on "%s" is required and cannot be auto-guessed : %s.', $fieldAnnotationName, $reflector->getName(), $e->getMessage()));
                     }
@@ -622,16 +622,29 @@ private static function getGraphQLInputFieldsFromAnnotations(GraphClass $graphCl
         foreach ($reflectors as $reflector) {
             $annotations = $graphClass->getAnnotations($reflector);
 
-            /** @var GQL\Field $fieldAnnotation */
+            /** @var GQL\Field|null $fieldAnnotation */
             $fieldAnnotation = self::getFirstAnnotationMatching($annotations, GQL\Field::class);
 
+            // No field annotation found
+            if (null === $fieldAnnotation) {
+                continue;
+            }
+
             // Ignore field with resolver when the type is an Input
             if (isset($fieldAnnotation->resolve)) {
                 return [];
             }
 
             $fieldName = $reflector->getName();
-            $fieldType = $fieldAnnotation->type;
+            if (isset($fieldAnnotation->type)) {
+                $fieldType = $fieldAnnotation->type;
+            } else {
+                try {
+                    $fieldType = self::guessType($graphClass, $reflector, self::VALID_INPUT_TYPES);
+                } catch (Exception $e) {
+                    throw new InvalidArgumentException(sprintf('The attribute "type" on GraphQL annotation "@%s" is missing on property "%s" and cannot be auto-guessed as there is no type hint or Doctrine annotation.', GQL\Field::class, $reflector->getName()));
+                }
+            }
             $fieldConfiguration = [];
             if ($fieldType) {
                 // Resolve a PHP class from a GraphQL type
@@ -839,8 +852,17 @@ private static function suffixName(string $name, string $suffix): string
      *
      * @throws RuntimeException
      */
-    private static function guessType(GraphClass $graphClass, array $annotations): string
+    private static function guessType(GraphClass $graphClass, ReflectionProperty $reflector, array $filterGraphQLTypes = []): string
     {
+        if ($reflector->hasType()) {
+            try {
+                // @phpstan-ignore-next-line
+                return self::resolveGraphQLTypeFromReflectionType($reflector->getType(), $filterGraphQLTypes);
+            } catch (Exception $e) {
+            }
+        }
+
+        $annotations = $graphClass->getAnnotations($reflector);
         $columnAnnotation = self::getFirstAnnotationMatching($annotations, Column::class);
         if (null !== $columnAnnotation) {
             $type = self::resolveTypeFromDoctrineType($columnAnnotation->type);

tests/Config/Parser/AnnotationParserTest.php

@@ -188,6 +188,10 @@ public function testInput(): void
             'fields' => [
                 'name' => ['type' => 'String!'],
                 'population' => ['type' => 'Int!'],
+                'description' => ['type' => 'String!'],
+                'diameter' => ['type' => 'Int'],
+                'variable' => ['type' => 'Int!'],
+                'tags' => ['type' => '[String]!'],
             ],
         ]);
     }

tests/Config/Parser/fixtures/annotations/Input/Planet.php

@@ -4,6 +4,7 @@
 
 namespace Overblog\GraphQLBundle\Tests\Config\Parser\fixtures\annotations\Input;
 
+use Doctrine\ORM\Mapping as ORM;
 use Overblog\GraphQLBundle\Annotation as GQL;
 
 /**
@@ -21,4 +22,31 @@ class Planet
      * @GQL\Field(type="Int!")
      */
     protected string $population;
+
+    /**
+     * @GQL\Field
+     */
+    protected string $description;
+
+    /**
+     * @GQL\Field
+     * @ORM\Column(type="integer", nullable=true)
+     */
+    // @phpstan-ignore-next-line
+    protected $diameter;
+
+    /**
+     * @GQL\Field
+     * @ORM\Column(type="boolean")
+     */
+    protected int $variable;
+
+    // @phpstan-ignore-next-line
+    protected $dummy;
+
+    /**
+     * @GQL\Field
+     * @ORM\Column(type="text[]")
+     */
+    protected array $tags;
 }

tests/Config/Parser/fixtures/annotations/Type/Droid.php

@@ -13,7 +13,7 @@
 class Droid extends Character
 {
     /**
-     * @GQL\Field(type="Int!")
+     * @GQL\Field
      */
     protected int $memory;
 }

tests/Config/Parser/fixtures/annotations/Type/Lightsaber.php

@@ -23,38 +23,44 @@ class Lightsaber
      * @ORM\Column(type="integer", nullable=true)
      * @GQL\Field
      */
-    protected int $size;
+    // @phpstan-ignore-next-line
+    protected $size;
 
     /**
      * @ORM\OneToMany(targetEntity="Hero")
      * @GQL\Field
      */
-    protected Hero $holders;
+    // @phpstan-ignore-next-line
+    protected $holders;
 
     /**
      * @ORM\ManyToOne(targetEntity="Hero")
      * @GQL\Field
      */
-    protected Hero $creator;
+    // @phpstan-ignore-next-line
+    protected $creator;
 
     /**
      * @ORM\OneToOne(targetEntity="Crystal")
      * @GQL\Field
      */
-    protected Crystal $crystal;
+    // @phpstan-ignore-next-line
+    protected $crystal;
 
     /**
      * @ORM\ManyToMany(targetEntity="Battle")
      * @GQL\Field
      */
-    protected Battle $battles;
+    // @phpstan-ignore-next-line
+    protected $battles;
 
     /**
      * @GQL\Field
      * @ORM\OneToOne(targetEntity="Hero")
      * @ORM\JoinColumn(nullable=true)
      */
-    protected Hero $currentHolder;
+    // @phpstan-ignore-next-line
+    protected $currentHolder;
 
     /**
      * @GQL\Field