feat: catch error during delegate execution

Author: vuongxuongminh

src/RootFieldsResolver.php

@@ -15,6 +15,7 @@
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\Definition\WrappingType;
 use GraphQL\Type\Introspection;
+use GraphQL\Type\Schema;
 use XGraphQL\DelegateExecution\Exception\LogicException;
 use XGraphQL\Utils\SelectionSet;
 
@@ -35,33 +36,57 @@ public function __construct(
     public function __invoke(mixed $value, array $arguments, mixed $context, ResolveInfo $info): Promise
     {
         if (!isset($this->delegatedPromises[$info->operation])) {
+            $this->delegatedPromises[$info->operation] = $this->delegateToExecute(
+                $info->schema,
+                $info->operation,
+                $info->fragments,
+                $info->variableValues
+            );
+        }
+
+        return $this->resolve($info);
+    }
+
+
+    /**
+     * @param Schema $schema
+     * @param OperationDefinitionNode $operation
+     * @param array<string, FragmentDefinitionNode> $fragments
+     * @param array<string, mixed> $variables
+     * @return 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.
-            $operation = $info->operation->cloneDeep();
-            $fragments = array_map(fn (FragmentDefinitionNode $fragment) => $fragment->cloneDeep(), $info->fragments);
+            $delegateOperation = $operation->cloneDeep();
+            $delegateFragments = array_map(fn(FragmentDefinitionNode $fragment) => $fragment->cloneDeep(), $fragments);
 
             /// Add typename for detecting object type of interface or union
-            SelectionSet::addTypename($operation->getSelectionSet());
-            SelectionSet::addTypenameToFragments($fragments);
-
-            $this->delegatedPromises[$info->operation] = $this
-                ->delegator
-                ->delegate(
-                    $info->schema,
-                    $operation,
-                    $fragments,
-                    $info->variableValues
-                )->then(
-                    function (ExecutionResult $result): ExecutionResult {
-                        if ([] !== $result->errors) {
-                            $this->delegatedErrorsReporter?->reportErrors($result->errors);
-                        }
-
-                        return $result;
-                    }
-                );
+            SelectionSet::addTypename($delegateOperation->getSelectionSet());
+            SelectionSet::addTypenameToFragments($delegateFragments);
+
+            $promise = $this->delegator->delegate($schema, $delegateOperation, $delegateFragments, $variables);
+        } catch (\Throwable $exception) {
+            $result = new ExecutionResult(
+                null,
+                [
+                    new Error('Error during delegate execution', [$operation], previous: $exception)
+                ],
+            );
+
+            $promise = $this->delegator->getPromiseAdapter()->createFulfilled($result);
         }
 
-        return $this->resolve($info);
+        return $promise->then(
+            function (ExecutionResult $result): ExecutionResult {
+                if ([] !== $result->errors) {
+                    $this->delegatedErrorsReporter?->reportErrors($result->errors);
+                }
+
+                return $result;
+            }
+        );
     }
 
     private function resolve(ResolveInfo $info): Promise
@@ -72,7 +97,7 @@ private function resolve(ResolveInfo $info): Promise
 
         $promise = $this->delegatedPromises[$info->operation];
 
-        return $promise->then(fn (ExecutionResult $result) => $this->accessResultByPath($info->path, $result));
+        return $promise->then(fn(ExecutionResult $result) => $this->accessResultByPath($info->path, $result));
     }
 
     private function prepareTypeResolver(Type $type): void

tests/BadExecutionDelegator.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace XGraphQL\DelegateExecution\Test;
+
+use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
+use GraphQL\Executor\Promise\Promise;
+use GraphQL\Executor\Promise\PromiseAdapter;
+use GraphQL\Language\AST\OperationDefinitionNode;
+use GraphQL\Type\Schema;
+use XGraphQL\DelegateExecution\ExecutionDelegatorInterface;
+
+final readonly class BadExecutionDelegator implements ExecutionDelegatorInterface
+{
+
+    public function delegate(Schema $executionSchema, OperationDefinitionNode $operation, array $fragments = [], array $variables = []): Promise
+    {
+        throw new \RuntimeException('Bad execution delegator');
+    }
+
+    public function getPromiseAdapter(): PromiseAdapter
+    {
+        return new SyncPromiseAdapter();
+    }
+}

tests/ExecutionTest.php

@@ -4,10 +4,12 @@
 
 namespace XGraphQL\DelegateExecution\Test;
 
+use GraphQL\Error\Error;
 use GraphQL\GraphQL;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Utils\BuildSchema;
 use PHPUnit\Framework\TestCase;
+use XGraphQL\DelegateExecution\DelegatedErrorsReporterInterface;
 use XGraphQL\DelegateExecution\Execution;
 use XGraphQL\DelegateExecution\ExecutionDelegatorInterface;
 use XGraphQL\DelegateExecution\RootFieldsResolver;
@@ -172,4 +174,42 @@ interface Unknown {
 
         $this->assertEquals('Expect type: `DummyObject` implementing `Unknown` should be exist in schema', $result->errors[0]->getMessage());
     }
+
+    public function testErrorDuringDelegateExecution(): void
+    {
+        /** @var Error[] $delegatedErrors */
+        $delegatedErrors = null;
+        $reporter = $this->createMock(DelegatedErrorsReporterInterface::class);
+
+        $reporter->expects($this->once())->method('reportErrors')->willReturnCallback(
+            function (array $errors) use (&$delegatedErrors): void {
+                $delegatedErrors = $errors;
+            }
+        );
+
+        $delegator = new BadExecutionDelegator();
+        $schema = BuildSchema::build(
+            <<<'SDL'
+type Query {
+    dummy: String!
+}
+SDL
+        );
+        Execution::delegate($schema, $delegator, $reporter);
+
+        $result = GraphQL::executeQuery(
+            $schema,
+            <<<'GQL'
+query {
+  dummy
+}
+GQL
+        );
+
+        $this->assertNotNull($delegatedErrors);
+        $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());
+    }
 }