Adding support for static factories

src/InputTypeGenerator.php

@@ -8,6 +8,7 @@
 use GraphQL\Type\Definition\ObjectType;
 use phpDocumentor\Reflection\Fqsen;
 use phpDocumentor\Reflection\Types\Object_;
+use Psr\Container\ContainerInterface;
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionType;
@@ -48,20 +49,26 @@ public function __construct(InputTypeUtils $inputTypeUtils,
     }
 
     /**
-     * @param object $factory
+     * @param string $factory
      * @param string $methodName
      * @param RecursiveTypeMapperInterface $recursiveTypeMapper
      * @return InputObjectType
      */
-    public function mapFactoryMethod($factory, string $methodName, RecursiveTypeMapperInterface $recursiveTypeMapper): InputObjectType
+    public function mapFactoryMethod(string $factory, string $methodName, RecursiveTypeMapperInterface $recursiveTypeMapper, ContainerInterface $container): InputObjectType
     {
         $method = new ReflectionMethod($factory, $methodName);
 
+        if ($method->isStatic()) {
+            $object = $factory;
+        } else {
+            $object = $container->get($factory);
+        }
+
         [$inputName, $className] = $this->inputTypeUtils->getInputTypeNameAndClassName($method);
 
         if (!isset($this->cache[$inputName])) {
             // TODO: add comment argument.
-            $this->cache[$inputName] = new ResolvableInputObjectType($inputName, $this->fieldsBuilderFactory, $recursiveTypeMapper, $factory, $methodName, $this->hydrator, null);
+            $this->cache[$inputName] = new ResolvableInputObjectType($inputName, $this->fieldsBuilderFactory, $recursiveTypeMapper, $object, $methodName, $this->hydrator, null);
         }
 
         return $this->cache[$inputName];

src/InputTypeUtils.php

@@ -4,7 +4,10 @@
 namespace TheCodingMachine\GraphQLite;
 
 use phpDocumentor\Reflection\Fqsen;
+use phpDocumentor\Reflection\Type;
 use phpDocumentor\Reflection\Types\Object_;
+use phpDocumentor\Reflection\Types\Self_;
+use ReflectionClass;
 use ReflectionMethod;
 
 class InputTypeUtils
@@ -57,10 +60,25 @@ private function validateReturnType(ReflectionMethod $refMethod): Fqsen
         $typeResolver = new \phpDocumentor\Reflection\TypeResolver();
 
         $phpdocType = $typeResolver->resolve($type);
+        $phpdocType = $this->resolveSelf($phpdocType, $refMethod->getDeclaringClass());
         if (!$phpdocType instanceof Object_) {
             throw MissingTypeHintException::invalidReturnType($refMethod);
         }
 
         return $phpdocType->getFqsen();
     }
+
+    /**
+     * Resolves "self" types into the class type.
+     *
+     * @param Type $type
+     * @return Type
+     */
+    private function resolveSelf(Type $type, ReflectionClass $reflectionClass): Type
+    {
+        if ($type instanceof Self_) {
+            return new Object_(new Fqsen('\\'.$reflectionClass->getName()));
+        }
+        return $type;
+    }
 }

src/Mappers/GlobTypeMapper.php

@@ -653,7 +653,7 @@ public function mapClassToInputType(string $className, RecursiveTypeMapperInterf
             $factory = $map[$className];
         }
 
-        return $this->inputTypeGenerator->mapFactoryMethod($this->container->get($factory[0]), $factory[1], $recursiveTypeMapper);
+        return $this->inputTypeGenerator->mapFactoryMethod($factory[0], $factory[1], $recursiveTypeMapper, $this->container);
     }
 
     /**
@@ -687,7 +687,7 @@ public function mapNameToType(string $typeName, RecursiveTypeMapperInterface $re
             return $this->typeGenerator->mapAnnotatedObject($typeClassName, $recursiveTypeMapper);
         }
         if (isset($factory)) {
-            return $this->inputTypeGenerator->mapFactoryMethod($this->container->get($factory[0]), $factory[1], $recursiveTypeMapper);
+            return $this->inputTypeGenerator->mapFactoryMethod($factory[0], $factory[1], $recursiveTypeMapper, $this->container);
         }
 
         throw CannotMapTypeException::createForName($typeName);

src/Types/ResolvableInputObjectType.php

@@ -37,7 +37,7 @@ class ResolvableInputObjectType extends InputObjectType implements ResolvableInp
      * @param string $name
      * @param FieldsBuilderFactory $controllerQueryProviderFactory
      * @param RecursiveTypeMapperInterface $recursiveTypeMapper
-     * @param object $factory
+     * @param object|string $factory
      * @param string $methodName
      * @param HydratorInterface $hydrator
      * @param null|string $comment

tests/Fixtures/Integration/Controllers/FilterController.php

@@ -0,0 +1,21 @@
+<?php
+
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Integration\Controllers;
+
+
+use TheCodingMachine\GraphQLite\Annotations\Query;
+use TheCodingMachine\GraphQLite\Fixtures\Integration\Models\Filter;
+use function var_export;
+
+class FilterController
+{
+    /**
+     * @Query()
+     * @return string[]
+     */
+    public function echoFilters(Filter $filter): array
+    {
+        return $filter->getValues();
+    }
+}

tests/Fixtures/Integration/Models/Filter.php

@@ -0,0 +1,41 @@
+<?php
+
+
+namespace TheCodingMachine\GraphQLite\Fixtures\Integration\Models;
+
+
+use TheCodingMachine\GraphQLite\Annotations\Factory;
+
+class Filter
+{
+    /**
+     * @var string[]|int[]
+     */
+    private $values;
+
+    /**
+     * Filter constructor.
+     * @param string[]|int[] $values
+     */
+    public function __construct(array $values)
+    {
+        $this->values = $values;
+    }
+
+    /**
+     * @return string[]|int[]
+     */
+    public function getValues(): array
+    {
+        return $this->values;
+    }
+
+    /**
+     * @Factory()
+     * @param string[] $values
+     */
+    public static function create(array $values): self
+    {
+        return new self($values);
+    }
+}

tests/Integration/EndToEndTest.php

@@ -462,4 +462,28 @@ public function testEndToEnd2Iterators()
         ], $result->toArray(Debug::RETHROW_INTERNAL_EXCEPTIONS)['data']);
 
     }
+
+    public function testEndToEndStaticFactories()
+    {
+        /**
+         * @var Schema $schema
+         */
+        $schema = $this->mainContainer->get(Schema::class);
+
+        $queryString = '
+        query {
+            echoFilters(filter: {values: ["foo", "bar"]})
+        }
+        ';
+
+        $result = GraphQL::executeQuery(
+            $schema,
+            $queryString
+        );
+
+        $this->assertSame([
+            'echoFilters' => [ "foo", "bar" ]
+        ], $result->toArray(Debug::RETHROW_INTERNAL_EXCEPTIONS)['data']);
+    }
+
 }