feat: add support lazy operation type

Author: vuongxuongminh

src/Execution.php

@@ -47,18 +47,29 @@ public static function delegate(
         Schema $schema,
         DelegatorInterface $delegator,
         ErrorsReporterInterface $errorsReporter = null,
-    ): void {
+    ): Schema {
         $execution = new Execution($delegator, $errorsReporter);
+        $schemaConfig = $schema->getConfig();
 
         foreach (['query', 'mutation', 'subscription'] as $operation) {
-            $operationType = $schema->getOperationType($operation);
+            $operationConfig = $schemaConfig->{$operation};
 
-            if (null === $operationType) {
-                continue;
+            if ($operationConfig instanceof ObjectType) {
+                $execution->prepareType($operationConfig);
             }
 
-            $execution->prepareType($operationType);
+            if (is_callable($operationConfig)) {
+                $schemaConfig->{$operation} = function () use ($operationConfig, $execution) {
+                    $type = $operationConfig();
+
+                    $execution->prepareType($type);
+
+                    return $type;
+                };
+            }
         }
+
+        return $schema;
     }
 
     private function prepareType(Type $type): void
@@ -81,7 +92,7 @@ private function prepareType(Type $type): void
         }
 
         if ($type instanceof AbstractType) {
-            $resolveType = fn(array $value, mixed $context, ResolveInfo $info) => $this->resolveAbstractType(
+            $resolveType = fn (array $value, mixed $context, ResolveInfo $info) => $this->resolveAbstractType(
                 $type,
                 $value,
                 $context,
@@ -94,8 +105,12 @@ private function prepareType(Type $type): void
         $this->preparedTypes[$type] = true;
     }
 
-    private function resolveAbstractType(AbstractType $abstractType, array $value, mixed $context, ResolveInfo $info): Type
-    {
+    private function resolveAbstractType(
+        AbstractType $abstractType,
+        array $value,
+        mixed $context,
+        ResolveInfo $info
+    ): Type {
         /// __typename field should be existed in $value
         ///  because we have added it to delegated query
         $typename = $value[Introspection::TYPE_NAME_FIELD_NAME];
@@ -140,12 +155,16 @@ function (ExecutionResult $result) use ($info): mixed {
      * @param array<string, mixed> $variables
      * @return Promise
      */
-    private function delegateToExecute(Schema $schema, OperationDefinitionNode $operation, array $fragments, array $variables): Promise
-    {
+    private function delegateToExecute(
+        Schema $schema,
+        OperationDefinitionNode $operation,
+        array $fragments,
+        array $variables
+    ): Promise {
         try {
             /// We need to clone all fragments and operation to make sure it can not be mutated by delegator.
             $delegateOperation = $operation->cloneDeep();
-            $delegateFragments = array_map(fn(FragmentDefinitionNode $fragment) => $fragment->cloneDeep(), $fragments);
+            $delegateFragments = array_map(fn (FragmentDefinitionNode $fragment) => $fragment->cloneDeep(), $fragments);
 
             /// Add typename for detecting object type of interface or union
             SelectionSet::addTypename($delegateOperation->getSelectionSet());

tests/DummySchemaTrait.php

@@ -19,7 +19,7 @@ private function createDummySchema(): Schema
             'fields' => [
                 'dummy' => Type::nonNull(Type::string()),
             ],
-            'resolveType' => fn() => 'DummyObject'
+            'resolveType' => fn () => 'DummyObject'
         ]);
 
         return new Schema([
@@ -28,15 +28,15 @@ private function createDummySchema(): Schema
                 'fields' => [
                     'dummy' => [
                         'type' => Type::string(),
-                        'resolve' => fn() => 'dummy'
+                        'resolve' => fn () => 'dummy'
                     ],
                     'dummy_error' => [
                         'type' => Type::string(),
-                        'resolve' => fn() => throw new Error('Dummy error')
+                        'resolve' => fn () => throw new Error('Dummy error')
                     ],
                     'dummy_object' => [
                         'type' => $dummyInterface,
-                        'resolve' => fn() => [
+                        'resolve' => fn () => [
                             'dummy' => 'dummy object field'
                         ]
                     ]
@@ -47,7 +47,7 @@ private function createDummySchema(): Schema
                 'fields' => [
                     'dummy' => [
                         'type' => Type::string(),
-                        'resolve' => fn() => 'dummy'
+                        'resolve' => fn () => 'dummy'
                     ]
                 ]
             ]),

tests/ExecutionTest.php

@@ -91,6 +91,39 @@ interface CustomInterface {
         $this->assertEquals('Dummy error', $result->errors[0]->getMessage());
     }
 
+    public function testLazyOperationTypeExecution(): void
+    {
+        $delegateSchema = $this->createDummySchema();
+        $delegator = new SchemaDelegator($delegateSchema);
+        $schema = BuildSchema::build(
+            <<<'SDL'
+type Query {
+    dummy: String!
+}
+SDL
+        );
+        $queryType = $schema->getConfig()->query;
+        $schema->getConfig()->query = fn () => $queryType;
+
+        Execution::delegate($schema, $delegator);
+
+        $result = GraphQL::executeQuery(
+            $schema,
+            <<<'GQL'
+query {
+  dummy
+}
+GQL
+        );
+
+        $this->assertEquals(
+            [
+                'dummy' => 'dummy'
+            ],
+            $result->data
+        );
+    }
+
     public function testLimitAccessFieldOfDelegateSchema(): void
     {
         $delegateSchema = $this->createDummySchema();
@@ -141,7 +174,10 @@ public function testSchemaConflictFieldDefinitionWithDelegateSchema(): void
 GQL
         );
 
-        $this->assertEquals('Delegated execution result is missing field value at path: `conflict_field`', $result->errors[0]->getMessage());
+        $this->assertEquals(
+            'Delegated execution result is missing field value at path: `conflict_field`',
+            $result->errors[0]->getMessage()
+        );
     }
 
     public function testSchemaConflictAbstractTypeWithDelegateSchema(): void
@@ -176,7 +212,10 @@ interface Unknown {
 GQL
         );
 
-        $this->assertEquals('Expect type: `DummyObject` implementing `Unknown` should be exist in schema', $result->errors[0]->getMessage());
+        $this->assertEquals(
+            'Expect type: `DummyObject` implementing `Unknown` should be exist in schema',
+            $result->errors[0]->getMessage()
+        );
     }
 
     public function testErrorDuringDelegateExecution(): void
@@ -214,6 +253,9 @@ function (array $errors) use (&$delegatedErrors): void {
         $this->assertEquals('Error during delegate execution', $delegatedErrors[0]->getMessage());
         $this->assertNotNull($delegatedErrors[0]->getPrevious());
         $this->assertEquals('Bad execution delegator', $delegatedErrors[0]->getPrevious()->getMessage());
-        $this->assertEquals('Delegated execution result is missing field value at path: `dummy`', $result->errors[0]->getMessage());
+        $this->assertEquals(
+            'Delegated execution result is missing field value at path: `dummy`',
+            $result->errors[0]->getMessage()
+        );
     }
 }