Refactor error handling

digiaonline · Nov 9, 2018 · 13adcc8 · 13adcc8
1 parent 9ee27bd
commit 13adcc8
Show file tree

Hide file tree

Showing 10 changed files with 196 additions and 66 deletions.
diff --git a/src/Error/Handler/AbstractErrorMiddleware.php b/src/Error/Handler/AbstractErrorMiddleware.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Digia\GraphQL\Error\Handler;
+
+use Digia\GraphQL\Execution\ExecutionContext;
+use Digia\GraphQL\Execution\ExecutionException;
+
+abstract class AbstractErrorMiddleware implements ErrorMiddlewareInterface
+{
+    /**
+     * @param \Throwable $exception
+     * @param callable   $next
+     * @return mixed
+     */
+    public function handleError(\Throwable $exception, callable $next)
+    {
+    }
+
+    /**
+     * @param ExecutionException $exception
+     * @param ExecutionContext   $context
+     * @return mixed
+     */
+    public function handleExecutionError(ExecutionException $exception, ExecutionContext $context, callable $next)
+    {
+    }
+}
diff --git a/src/Error/Handler/AddErrorMiddleware.php b/src/Error/Handler/AddErrorMiddleware.php
diff --git a/src/Error/Handler/CallableMiddleware.php b/src/Error/Handler/CallableMiddleware.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Digia\GraphQL\Error\Handler;
+
+use Digia\GraphQL\Execution\ExecutionContext;
+use Digia\GraphQL\Execution\ExecutionException;
+
+class CallableMiddleware extends AbstractErrorMiddleware
+{
+    /**
+     * @var callable
+     */
+    protected $handleCallback;
+
+    /**
+     * CallableMiddleware constructor.
+     * @param callable $handleCallback
+     */
+    public function __construct(callable $handleCallback)
+    {
+        $this->handleCallback = $handleCallback;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function handleExecutionError(ExecutionException $exception, ExecutionContext $context, callable $next)
+    {
+        return \call_user_func($this->handleCallback, $exception, $context, $next);
+    }
+}
diff --git a/src/Error/Handler/ErrorHandler.php b/src/Error/Handler/ErrorHandler.php
@@ -10,7 +10,7 @@ class ErrorHandler implements ErrorHandlerInterface
     /**
      * @var ErrorMiddlewareInterface[]
      */
-    protected $middleware;
+    protected $middleware = [];
 
     /**
      * ErrorHandler constructor.
@@ -23,19 +23,36 @@ public function __construct(array $middleware)
         }
     }
 
+    /**
+     * @param \Throwable $exception
+     */
+    public function handleError(\Throwable $exception)
+    {
+        $next = function () {
+            // NO-OP
+        };
+
+        foreach ($this->middleware as $middleware) {
+            $next = function (\Throwable $exception) use ($middleware, $next) {
+                return $middleware->handleError($exception, $next);
+            };
+        }
+
+        \call_user_func($next, $exception);
+    }
+
     /**
      * @inheritdoc
      */
-    public function handle(ExecutionException $exception, ExecutionContext $context)
+    public function handleExecutionError(ExecutionException $exception, ExecutionContext $context)
     {
         $next = function () {
             // NO-OP
         };
 
-        foreach (\array_reverse($this->middleware) as $mw) {
-            /** @var ErrorMiddlewareInterface $mw */
-            $next = function (ExecutionException $exception, ExecutionContext $context) use ($mw, $next) {
-                return $mw->handle($exception, $context, $next);
+        foreach ($this->middleware as $middleware) {
+            $next = function (ExecutionException $exception, ?ExecutionContext $context) use ($middleware, $next) {
+                return $middleware->handleExecutionError($exception, $context, $next);
             };
         }
 
@@ -47,6 +64,6 @@ public function handle(ExecutionException $exception, ExecutionContext $context)
      */
     protected function addMiddleware(ErrorMiddlewareInterface $middleware)
     {
-        $this->middleware[] = $middleware;
+        \array_unshift($this->middleware, $middleware);
     }
 }
diff --git a/src/Error/Handler/ErrorHandlerInterface.php b/src/Error/Handler/ErrorHandlerInterface.php
@@ -8,8 +8,13 @@
 interface ErrorHandlerInterface
 {
     /**
-     * @param ExecutionException $exception
-     * @param ExecutionContext   $context
+     * @param \Throwable $exception
      */
-    public function handle(ExecutionException $exception, ExecutionContext $context);
+    public function handleError(\Throwable $exception);
+
+    /**
+     * @param ExecutionException    $exception
+     * @param ExecutionContext $context
+     */
+    public function handleExecutionError(ExecutionException $exception, ExecutionContext $context);
 }
diff --git a/src/Error/Handler/ErrorMiddlewareInterface.php b/src/Error/Handler/ErrorMiddlewareInterface.php
@@ -7,10 +7,17 @@
 
 interface ErrorMiddlewareInterface
 {
+    /**
+     * @param \Throwable $exception
+     * @param callable   $next
+     * @return mixed
+     */
+    public function handleError(\Throwable $exception, callable $next);
+
     /**
      * @param ExecutionException $exception
      * @param ExecutionContext   $context
      * @return mixed
      */
-    public function handle(ExecutionException $exception, ExecutionContext $context, callable $next);
+    public function handleExecutionError(ExecutionException $exception, ExecutionContext $context, callable $next);
 }
diff --git a/src/Execution/Execution.php b/src/Execution/Execution.php
@@ -58,9 +58,9 @@ public function execute(
             });
         }
 
-        if (null !== $errorHandler) {
+        if ($errorHandler instanceof ErrorHandlerInterface) {
             foreach ($context->getErrors() as $error) {
-                $errorHandler->handleError($error);
+                $errorHandler->handleExecutionError($error, $context);
             }
         }
 
@@ -72,15 +72,13 @@ public function execute(
      * @param ExecutionContext           $context
      * @param FieldCollector             $fieldCollector
      * @param ValuesResolver             $valuesResolver
-     * @param ErrorHandlerInterface|null $errorHandler
      * @return array|mixed|null|PromiseInterface
      */
     protected function executeOperation(
         ?string $operationName,
         ExecutionContext $context,
         FieldCollector $fieldCollector,
-        ValuesResolver $valuesResolver,
-        ?ErrorHandlerInterface $errorHandler = null
+        ValuesResolver $valuesResolver
     ) {
         $strategy = $operationName === 'mutation'
             ? new SerialExecutionStrategy($context, $fieldCollector, $valuesResolver)

diff --git a/src/GraphQL.php b/src/GraphQL.php
@@ -2,7 +2,10 @@
 
 namespace Digia\GraphQL;
 
+use Digia\GraphQL\Error\Handler\CallableMiddleware;
+use Digia\GraphQL\Error\Handler\ErrorHandler;
 use Digia\GraphQL\Error\Handler\ErrorHandlerInterface;
+use Digia\GraphQL\Error\InvariantException;
 use Digia\GraphQL\Execution\ExecutionInterface;
 use Digia\GraphQL\Execution\ExecutionProvider;
 use Digia\GraphQL\Execution\ExecutionResult;
@@ -14,6 +17,7 @@
 use Digia\GraphQL\Language\NodePrinterInterface;
 use Digia\GraphQL\Language\ParserInterface;
 use Digia\GraphQL\Language\Source;
+use Digia\GraphQL\Language\SyntaxErrorException;
 use Digia\GraphQL\Schema\Building\SchemaBuilderInterface;
 use Digia\GraphQL\Schema\Building\SchemaBuildingProvider;
 use Digia\GraphQL\Schema\Extension\SchemaExtenderInterface;
@@ -248,7 +252,7 @@ public static function execute(
         array $variableValues = [],
         $operationName = null,
         callable $fieldResolver = null,
-        $errorHandler = null
+        ?ErrorHandlerInterface $errorHandler = null
     ): ExecutionResult {
         /** @var ExecutionInterface $execution */
         $execution = static::make(ExecutionInterface::class);
@@ -265,6 +269,78 @@ public static function execute(
         );
     }
 
+    /**
+     * @param Schema                     $schema
+     * @param string                     $source
+     * @param null                       $rootValue
+     * @param null                       $contextValue
+     * @param array                      $variableValues
+     * @param null|string                $operationName
+     * @param callable|null              $fieldResolver
+     * @param ErrorHandlerInterface|null $errorHandler
+     * @return ExecutionResult
+     * @throws InvariantException
+     * @throws SyntaxErrorException
+     */
+    public static function process(
+        Schema $schema,
+        string $source,
+        $rootValue = null,
+        $contextValue = null,
+        array $variableValues = [],
+        ?string $operationName = null,
+        ?callable $fieldResolver = null,
+        ?ErrorHandlerInterface $errorHandler = null
+    ): ExecutionResult
+    {
+        $schemaValidationErrors = validateSchema($schema);
+
+        if (!empty($schemaValidationErrors)) {
+            if (null !== $errorHandler) {
+                foreach ($schemaValidationErrors as $schemaValidationError) {
+                    $errorHandler->handleError($schemaValidationError);
+                }
+            }
+
+            return (new ExecutionResult(null, $schemaValidationErrors));
+        }
+
+        try {
+            $document = parse($source);
+        } catch (SyntaxErrorException $error) {
+            if (null !== $errorHandler) {
+                $errorHandler->handleError($error);
+            }
+
+            return (new ExecutionResult(null, [$error]));
+        }
+
+        $validationErrors = validate($schema, $document);
+
+        if (!empty($validationErrors)) {
+            if (null !== $errorHandler) {
+                foreach ($validationErrors as $validationError) {
+                    $errorHandler->handleError($validationError);
+                }
+            }
+
+            return (new ExecutionResult(null, $validationErrors));
+        }
+
+        $result = execute(
+            $schema,
+            $document,
+            $rootValue,
+            $contextValue,
+            $variableValues,
+            $operationName,
+            $fieldResolver,
+            $errorHandler
+        );
+
+        return $result;
+    }
+
     /**
      * @param NodeInterface $node
      * @return string

diff --git a/src/api.php b/src/api.php
@@ -2,6 +2,8 @@
 
 namespace Digia\GraphQL;
 
+use Digia\GraphQL\Error\Handler\CallableMiddleware;
+use Digia\GraphQL\Error\Handler\ErrorHandler;
 use Digia\GraphQL\Error\Handler\ErrorHandlerInterface;
 use Digia\GraphQL\Error\InvariantException;
 use Digia\GraphQL\Execution\ExecutionResult;
@@ -165,41 +167,30 @@ function printNode(NodeInterface $node): string
  * @param mixed|null                          $rootValue
  * @param mixed|null                          $contextValue
  * @param array                               $variableValues
- * @param mixed|null                          $operationName
+ * @param string|null                         $operationName
  * @param callable|null                       $fieldResolver
  * @param ErrorHandlerInterface|callable|null $errorHandler
  * @return array
  * @throws InvariantException
+ * @throws SyntaxErrorException
  */
 function graphql(
     Schema $schema,
     string $source,
     $rootValue = null,
     $contextValue = null,
     array $variableValues = [],
-    $operationName = null,
-    callable $fieldResolver = null,
+    ?string $operationName = null,
+    ?callable $fieldResolver = null,
     $errorHandler = null
 ): array {
-    $schemaValidationErrors = validateSchema($schema);
-    if (!empty($schemaValidationErrors)) {
-        return (new ExecutionResult([], $schemaValidationErrors))->toArray();
+    if (\is_callable($errorHandler)) {
+        $errorHandler = new ErrorHandler([new CallableMiddleware($errorHandler)]);
     }
 
-    try {
-        $document = parse($source);
-    } catch (SyntaxErrorException $error) {
-        return (new ExecutionResult([], [$error]))->toArray();
-    }
-
-    $validationErrors = validate($schema, $document);
-    if (!empty($validationErrors)) {
-        return (new ExecutionResult([], $validationErrors))->toArray();
-    }
-
-    $result = execute(
+    $result = GraphQL::process(
         $schema,
-        $document,
+        $source,
         $rootValue,
         $contextValue,
         $variableValues,