Adding support for migrations

Author: moufmouf

src/Annotations/Mutation.php

@@ -0,0 +1,12 @@
+<?php
+
+
+namespace TheCodingMachine\GraphQL\Controllers\Annotations;
+
+/**
+ * @Annotation
+ */
+class Mutation
+{
+
+}

src/ControllerQueryProvider.php

@@ -12,6 +12,7 @@
 use Roave\BetterReflection\Reflection\ReflectionMethod;
 use Doctrine\Common\Annotations\Reader;
 use phpDocumentor\Reflection\Types\Integer;
+use TheCodingMachine\GraphQL\Controllers\Annotations\Mutation;
 use TheCodingMachine\GraphQL\Controllers\Annotations\Query;
 use Youshido\GraphQL\Field\Field;
 use Youshido\GraphQL\Type\ListType\ListType;
@@ -58,6 +59,22 @@ public function __construct($controller, Reader $annotationReader, TypeMapperInt
      * @return Field[]
      */
     public function getQueries(): array
+    {
+        return $this->getFieldsByAnnotations(Query::class);
+    }
+
+    /**
+     * @return Field[]
+     */
+    public function getMutations(): array
+    {
+        return $this->getFieldsByAnnotations(Mutation::class);
+    }
+
+    /**
+     * @return Field[]
+     */
+    private function getFieldsByAnnotations(string $annotationName): array
     {
         $refClass = ReflectionClass::createFromInstance($this->controller);
 
@@ -66,7 +83,7 @@ public function getQueries(): array
         foreach ($refClass->getMethods() as $refMethod) {
             $standardPhpMethod = new \ReflectionMethod(get_class($this->controller), $refMethod->getName());
             // First, let's check the "Query" annotation
-            $queryAnnotation = $this->annotationReader->getMethodAnnotation($standardPhpMethod, Query::class);
+            $queryAnnotation = $this->annotationReader->getMethodAnnotation($standardPhpMethod, $annotationName);
             if ($queryAnnotation !== null) {
                 $methodName = $refMethod->getName();
 

tests/ControllerQueryProviderTest.php

@@ -16,35 +16,72 @@
 
 class ControllerQueryProviderTest extends TestCase
 {
-    public function testQueryProvider()
+
+    private $testObjectType;
+    private $typeMapper;
+    private $hydrator;
+
+    private function getTestObjectType()
     {
-        $controller = new TestController();
-        $reader = new AnnotationReader();
+        if ($this->testObjectType === null) {
+            $this->testObjectType = new ObjectType([
+                'name'    => 'TestObject',
+                'fields'  => [
+                    'test'   => new StringType(),
+                ],
+            ]);
+        }
+        return $this->testObjectType;
+    }
 
-        $typeMapper = new class implements TypeMapperInterface {
-            public function mapClassToType(string $className): TypeInterface
-            {
-                if ($className === TestObject::class) {
-                    return new ObjectType([
-                        'name'    => 'TestObject',
-                        'fields'  => [
-                            'test'   => new StringType(),
-                        ],
-                    ]);
-                } else {
-                    throw new \RuntimeException('Unexpected type');
+    private function getTypeMapper()
+    {
+        if ($this->typeMapper === null) {
+            $this->typeMapper = new class($this->getTestObjectType()) implements TypeMapperInterface {
+                /**
+                 * @var ObjectType
+                 */
+                private $testObjectType;
+
+                public function __construct(ObjectType $testObjectType)
+                {
+
+                    $this->testObjectType = $testObjectType;
+                }
+
+                public function mapClassToType(string $className): TypeInterface
+                {
+                    if ($className === TestObject::class) {
+                        return $this->testObjectType;
+                    } else {
+                        throw new \RuntimeException('Unexpected type');
+                    }
                 }
-            }
-        };
+            };
+        }
+        return $this->typeMapper;
+    }
 
-        $hydrator = new class implements HydratorInterface {
-            public function hydrate(array $data, TypeInterface $type)
+    private function getHydrator()
+    {
+        if ($this->hydrator === null) {
+            $this->hydrator = new class implements HydratorInterface
             {
-                return new TestObject($data['test']);
-            }
-        };
+                public function hydrate(array $data, TypeInterface $type)
+                {
+                    return new TestObject($data['test']);
+                }
+            };
+        }
+        return $this->hydrator;
+    }
+
+    public function testQueryProvider()
+    {
+        $controller = new TestController();
+        $reader = new AnnotationReader();
 
-        $queryProvider = new ControllerQueryProvider($controller, $reader, $typeMapper, $hydrator);
+        $queryProvider = new ControllerQueryProvider($controller, $reader, $this->getTypeMapper(), $this->getHydrator());
 
         $queries = $queryProvider->getQueries();
 
@@ -62,12 +99,7 @@ public function hydrate(array $data, TypeInterface $type)
         $this->assertInstanceOf(ObjectType::class, $usersQuery->getArgument('list')->getType()->getTypeOf()->getItemType()->getTypeOf());
         $this->assertSame('TestObject', $usersQuery->getArgument('list')->getType()->getTypeOf()->getItemType()->getTypeOf()->getName());
 
-        $mockResolveInfo = $this->getMockBuilder(ResolveInfo::class)
-            ->disableOriginalConstructor()
-            ->disableOriginalClone()
-            ->disableArgumentCloning()
-            ->disallowMockingUnknownTypes()
-            ->getMock();
+        $mockResolveInfo = $this->createMock(ResolveInfo::class);
 
         $result = $usersQuery->resolve('foo', ['int'=>42, 'string'=>'foo', 'list'=>[
             ['test'=>42],
@@ -77,4 +109,26 @@ public function hydrate(array $data, TypeInterface $type)
         $this->assertInstanceOf(TestObject::class, $result);
         $this->assertSame('foo424212', $result->getTest());
     }
+
+    public function testMutations()
+    {
+        $controller = new TestController();
+        $reader = new AnnotationReader();
+
+        $queryProvider = new ControllerQueryProvider($controller, $reader, $this->getTypeMapper(), $this->getHydrator());
+
+        $mutations = $queryProvider->getMutations();
+
+        $this->assertCount(1, $mutations);
+        $mutation = $mutations[0];
+        $this->assertSame('mutation', $mutation->getName());
+
+        $mockResolveInfo = $this->createMock(ResolveInfo::class);
+
+        $result = $mutation->resolve('foo', ['testObject'=>['test'=>42]], $mockResolveInfo);
+
+        $this->assertInstanceOf(TestObject::class, $result);
+        $this->assertEquals('42', $result->getTest());
+
+    }
 }

tests/Fixtures/TestController.php

@@ -4,6 +4,7 @@
 namespace TheCodingMachine\GraphQL\Controllers\Fixtures;
 
 
+use TheCodingMachine\GraphQL\Controllers\Annotations\Mutation;
 use TheCodingMachine\GraphQL\Controllers\Annotations\Query;
 
 class TestController
@@ -26,4 +27,14 @@ public function test(int $int, ?string $string, array $list): TestObject
         }
         return new TestObject($string.$int.$str);
     }
+
+    /**
+     * @Mutation()
+     * @param TestObject $testObject
+     * @return TestObject
+     */
+    public function mutation(TestObject $testObject): TestObject
+    {
+        return $testObject;
+    }
 }