Merge e8123a4 into 96b9518

digiaonline · Nov 9, 2018 · 9258578 · 9258578
2 parents 96b9518 + e8123a4
commit 9258578
Show file tree

Hide file tree

Showing 13 changed files with 366 additions and 113 deletions.
diff --git a/src/Error/ErrorHandler.php b/src/Error/ErrorHandler.php
diff --git a/src/Error/ErrorHandlerInterface.php b/src/Error/ErrorHandlerInterface.php
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/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
@@ -0,0 +1,69 @@
+<?php
+
+namespace Digia\GraphQL\Error\Handler;
+
+use Digia\GraphQL\Execution\ExecutionContext;
+use Digia\GraphQL\Execution\ExecutionException;
+
+class ErrorHandler implements ErrorHandlerInterface
+{
+    /**
+     * @var ErrorMiddlewareInterface[]
+     */
+    protected $middleware = [];
+
+    /**
+     * ErrorHandler constructor.
+     * @param ErrorMiddlewareInterface[] $middleware
+     */
+    public function __construct(array $middleware)
+    {
+        foreach ($middleware as $mw) {
+            $this->addMiddleware($mw);
+        }
+    }
+
+    /**
+     * @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 handleExecutionError(ExecutionException $exception, ExecutionContext $context)
+    {
+        $next = function () {
+            // NO-OP
+        };
+
+        foreach ($this->middleware as $middleware) {
+            $next = function (ExecutionException $exception, ExecutionContext $context) use ($middleware, $next) {
+                return $middleware->handleExecutionError($exception, $context, $next);
+            };
+        }
+
+        \call_user_func($next, $exception, $context);
+    }
+
+    /**
+     * @param ErrorMiddlewareInterface $middleware
+     */
+    protected function addMiddleware(ErrorMiddlewareInterface $middleware)
+    {
+        \array_unshift($this->middleware, $middleware);
+    }
+}
diff --git a/src/Error/Handler/ErrorHandlerInterface.php b/src/Error/Handler/ErrorHandlerInterface.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Digia\GraphQL\Error\Handler;
+
+use Digia\GraphQL\Execution\ExecutionContext;
+use Digia\GraphQL\Execution\ExecutionException;
+
+interface ErrorHandlerInterface
+{
+    /**
+     * @param \Throwable $exception
+     */
+    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
@@ -0,0 +1,23 @@
+<?php
+
+namespace Digia\GraphQL\Error\Handler;
+
+use Digia\GraphQL\Execution\ExecutionContext;
+use Digia\GraphQL\Execution\ExecutionException;
+
+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 handleExecutionError(ExecutionException $exception, ExecutionContext $context, callable $next);
+}
diff --git a/src/Execution/Execution.php b/src/Execution/Execution.php
@@ -2,10 +2,10 @@
 
 namespace Digia\GraphQL\Execution;
 
-use Digia\GraphQL\Error\ErrorHandlerInterface;
 use Digia\GraphQL\Execution\Strategy\FieldCollector;
 use Digia\GraphQL\Execution\Strategy\ParallelExecutionStrategy;
 use Digia\GraphQL\Execution\Strategy\SerialExecutionStrategy;
+use Digia\GraphQL\Error\Handler\ErrorHandlerInterface;
 use Digia\GraphQL\Language\Node\DocumentNode;
 use Digia\GraphQL\Language\Node\FragmentDefinitionNode;
 use Digia\GraphQL\Language\Node\FragmentSpreadNode;
@@ -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/Execution/ExecutionInterface.php b/src/Execution/ExecutionInterface.php
@@ -2,7 +2,7 @@
 
 namespace Digia\GraphQL\Execution;
 
-use Digia\GraphQL\Error\ErrorHandlerInterface;
+use Digia\GraphQL\Error\Handler\ErrorHandlerInterface;
 use Digia\GraphQL\Language\Node\DocumentNode;
 use Digia\GraphQL\Schema\Schema;
 

diff --git a/src/GraphQL.php b/src/GraphQL.php
@@ -2,8 +2,8 @@
 
 namespace Digia\GraphQL;
 
-use Digia\GraphQL\Error\ErrorHandler;
-use Digia\GraphQL\Error\ErrorHandlerInterface;
+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;
@@ -15,6 +15,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;
@@ -231,14 +232,14 @@ public static function validate(Schema $schema, DocumentNode $document): array
     }
 
     /**
-     * @param Schema                              $schema
-     * @param DocumentNode                        $document
-     * @param mixed                               $rootValue
-     * @param mixed                               $contextValue
-     * @param array                               $variableValues
-     * @param string|null                         $operationName
-     * @param callable|null                       $fieldResolver
-     * @param ErrorHandlerInterface|callable|null $errorHandler
+     * @param Schema                     $schema
+     * @param DocumentNode               $document
+     * @param mixed                      $rootValue
+     * @param mixed                      $contextValue
+     * @param array                      $variableValues
+     * @param string|null                $operationName
+     * @param callable|null              $fieldResolver
+     * @param ErrorHandlerInterface|null $errorHandler
      * @return ExecutionResult
      */
     public static function execute(
@@ -249,18 +250,81 @@ 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);
 
-        if (null !== $errorHandler) {
-            $errorHandler = $errorHandler instanceof ErrorHandlerInterface
-                ? $errorHandler
-                : new ErrorHandler($errorHandler);
+        return $execution->execute(
+            $schema,
+            $document,
+            $rootValue,
+            $contextValue,
+            $variableValues,
+            $operationName,
+            $fieldResolver,
+            $errorHandler
+        );
+    }
+
+    /**
+     * @param Schema                     $schema
+     * @param string                     $source
+     * @param mixed                      $rootValue
+     * @param mixed                      $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);
         }
 
-        return $execution->execute(
+        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);
+        }
+
+        return execute(
             $schema,
             $document,
             $rootValue,