Server: send result for regular responses + prepare response for PSR7 request

Author: vladar

src/Server/Helper.php

@@ -14,7 +14,9 @@
 use GraphQL\Utils\AST;
 use GraphQL\Utils\Utils;
 use GraphQL\Validator\DocumentValidator;
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamInterface;
 
 /**
  * Class Helper
@@ -131,7 +133,9 @@ private function promiseToExecuteOperation(PromiseAdapter $promiseAdapter, Serve
                     return FormattedError::createFromException($e, true);
                 };
             } else {
-                $errorFormatter = $config->getErrorFormatter();
+                $errorFormatter = $config->getErrorFormatter() ?: function($e) {
+                    return FormattedError::createFromException($e, false);
+                };
             }
             $result->setErrorFormatter($errorFormatter);
             return $result;
@@ -264,6 +268,66 @@ public function parsePsrRequest(ServerRequestInterface $request)
         );
     }
 
+    /**
+     * Converts query execution result to PSR response
+     *
+     * @param Promise|ExecutionResult|ExecutionResult[] $result
+     * @param ResponseInterface $response
+     * @param StreamInterface $writableBodyStream
+     * @return Promise|ResponseInterface
+     */
+    public function toPsrResponse($result, ResponseInterface $response, StreamInterface $writableBodyStream)
+    {
+        if ($result instanceof Promise) {
+            return $result->then(function($actualResult) use ($response, $writableBodyStream) {
+                return $this->doConvertToPsrResponse($actualResult, $response, $writableBodyStream);
+            });
+        } else {
+            return $this->doConvertToPsrResponse($result, $response, $writableBodyStream);
+        }
+    }
+
+    private function doConvertToPsrResponse($result, ResponseInterface $response, StreamInterface $writableBodyStream)
+    {
+        $httpStatus = $this->resolveHttpStatus($result);
+
+        $result = json_encode($result);
+        $writableBodyStream->write($result);
+
+        return $response
+            ->withStatus($httpStatus)
+            ->withHeader('Content-Type', 'application/json')
+            ->withBody($writableBodyStream);
+    }
+
+    /**
+     * @param Promise|ExecutionResult|ExecutionResult[] $result
+     * @param bool $exitWhenDone
+     */
+    public function sendResponse($result, $exitWhenDone = false)
+    {
+        if ($result instanceof Promise) {
+            $result->then(function($actualResult) use ($exitWhenDone) {
+                $this->doSendResponse($actualResult, $exitWhenDone);
+            });
+        } else {
+            $this->doSendResponse($result, $exitWhenDone);
+        }
+    }
+
+    private function doSendResponse($result, $exitWhenDone)
+    {
+        $httpStatus = $this->resolveHttpStatus($result);
+        $body = json_encode($result);
+
+        header('Content-Type: application/json', true, $httpStatus);
+        echo $body;
+
+        if ($exitWhenDone) {
+            exit;
+        }
+    }
+
     /**
      * Parses normalized request params and returns instance of OperationParams or array of OperationParams in
      * case of batch operation.
@@ -347,4 +411,39 @@ public function validateOperationParams(OperationParams $params)
         }
         return $errors;
     }
+
+    /**
+     * @param $result
+     * @return int
+     */
+    private function resolveHttpStatus($result)
+    {
+        if (is_array($result)) {
+            Utils::each($tmp, function ($executionResult, $index) {
+                if (!$executionResult instanceof ExecutionResult) {
+                    throw new InvariantViolation(sprintf(
+                        "Expecting every entry of batched query result to be instance of %s but entry at position %d is %s",
+                        ExecutionResult::class,
+                        $index,
+                        Utils::printSafe($executionResult)
+                    ));
+                }
+            });
+            $httpStatus = 200;
+        } else {
+            if (!$result instanceof ExecutionResult) {
+                throw new InvariantViolation(sprintf(
+                    "Expecting query result to be instance of %s but got %s",
+                    ExecutionResult::class,
+                    Utils::printSafe($result)
+                ));
+            }
+            if ($result->data === null && !empty($result->errors)) {
+                $httpStatus = 400;
+            } else {
+                $httpStatus = 200;
+            }
+        }
+        return $httpStatus;
+    }
 }

src/Server/ServerConfig.php

@@ -35,7 +35,7 @@ public static function create()
     /**
      * @var callable
      */
-    private $errorFormatter = [FormattedError::class, 'createFromException'];
+    private $errorFormatter;
 
     /**
      * @var bool

src/Server/StandardServer.php

@@ -4,7 +4,9 @@
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Executor\ExecutionResult;
 use GraphQL\Executor\Promise\Promise;
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamInterface;
 
 /**
  * Class StandardServer
@@ -80,4 +82,30 @@ public function executeRequest($parsedBody = null)
             return $this->helper->executeOperation($this->config, $parsedBody);
         }
     }
+
+   /**
+     * @param ServerRequestInterface $request
+     * @param ResponseInterface $response
+     * @param StreamInterface $writableBodyStream
+     * @return ResponseInterface|Promise
+     */
+    public function processPsrRequest(
+        ServerRequestInterface $request,
+        ResponseInterface $response,
+        StreamInterface $writableBodyStream
+    )
+    {
+        $result = $this->executePsrRequest($request);
+        return $this->helper->toPsrResponse($result, $response, $writableBodyStream);
+    }
+
+    /**
+     * @param OperationParams|OperationParams[] $parsedBody
+     * @param bool $exitWhenDone
+     */
+    public function processRequest($parsedBody = null, $exitWhenDone = false)
+    {
+        $result = $this->executeRequest($parsedBody);
+        $this->helper->sendResponse($result, $exitWhenDone);
+    }
 }

tests/Server/QueryExecutionTest.php

@@ -543,7 +543,7 @@ private function executeBatchedQuery(array $qs)
     {
         $batch = [];
         foreach ($qs as $params) {
-            $batch[] = OperationParams::create($params, true);
+            $batch[] = OperationParams::create($params);
         }
         $helper = new Helper();
         $result = $helper->executeBatch($this->config, $batch);

tests/Server/ServerConfigTest.php

@@ -15,7 +15,7 @@ public function testDefaults()
         $this->assertEquals(null, $config->getSchema());
         $this->assertEquals(null, $config->getContext());
         $this->assertEquals(null, $config->getRootValue());
-        $this->assertEquals([FormattedError::class, 'createFromException'], $config->getErrorFormatter());
+        $this->assertEquals(null, $config->getErrorFormatter());
         $this->assertEquals(null, $config->getPromiseAdapter());
         $this->assertEquals(null, $config->getValidationRules());
         $this->assertEquals(null, $config->getDefaultFieldResolver());