Version 4.6.0

system/3rd_party/graphql-php/Server/StandardServer.php

@@ -1,14 +1,20 @@
 <?php
+
+declare(strict_types=1);
+
 namespace GraphQL\Server;
 
+use GraphQL\Error\DebugFlag;
 use GraphQL\Error\FormattedError;
 use GraphQL\Error\InvariantViolation;
 use GraphQL\Executor\ExecutionResult;
 use GraphQL\Executor\Promise\Promise;
-use GraphQL\Utils;
+use GraphQL\Utils\Utils;
+use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamInterface;
+use Throwable;
+use function is_array;
 
 /**
  * GraphQL server compatible with both: [express-graphql](https://github.com/graphql/express-graphql)
@@ -30,18 +36,13 @@ use Psr\Http\Message\StreamInterface;
  *     $server->handleRequest();
  *
  * See [dedicated section in docs](executing-queries.md#using-server) for details.
- *
  */
 class StandardServer
 {
-    /**
-     * @var ServerConfig
-     */
+    /** @var ServerConfig */
     private $config;
 
-    /**
-     * @var Helper
-     */
+    /** @var Helper */
     private $helper;
 
     /**
@@ -49,35 +50,35 @@ class StandardServer
      * Useful when an exception is thrown somewhere outside of server execution context
      * (e.g. during schema instantiation).
      *
+     * @param Throwable $error
+     * @param int       $debug
+     * @param bool      $exitWhenDone
+     *
      * @api
-     * @param \Throwable $error
-     * @param bool $debug
-     * @param bool $exitWhenDone
      */
-    public static function send500Error($error, $debug = false, $exitWhenDone = false)
+    public static function send500Error($error, $debug = DebugFlag::NONE, $exitWhenDone = false)
     {
         $response = [
-            'errors' => [
-                FormattedError::createFromException($error, $debug)
-            ]
+            'errors' => [FormattedError::createFromException($error, $debug)],
         ];
-        $helper = new Helper();
+        $helper   = new Helper();
         $helper->emitResponse($response, 500, $exitWhenDone);
     }
 
     /**
      * Creates new instance of a standard GraphQL HTTP server
      *
+     * @param ServerConfig|mixed[] $config
+     *
      * @api
-     * @param ServerConfig|array $config
      */
     public function __construct($config)
     {
         if (is_array($config)) {
             $config = ServerConfig::create($config);
         }
-        if (!$config instanceof ServerConfig) {
-            throw new InvariantViolation("Expecting valid server config, but got " . Utils::printSafe($config));
+        if (! $config instanceof ServerConfig) {
+            throw new InvariantViolation('Expecting valid server config, but got ' . Utils::printSafe($config));
         }
         $this->config = $config;
         $this->helper = new Helper();
@@ -93,9 +94,10 @@ class StandardServer
      * See `executeRequest()` if you prefer to emit response yourself
      * (e.g. using Response object of some framework)
      *
-     * @api
      * @param OperationParams|OperationParams[] $parsedBody
-     * @param bool $exitWhenDone
+     * @param bool                              $exitWhenDone
+     *
+     * @api
      */
     public function handleRequest($parsedBody = null, $exitWhenDone = false)
     {
@@ -113,22 +115,25 @@ class StandardServer
      *
      * PSR-7 compatible method executePsrRequest() does exactly this.
      *
-     * @api
      * @param OperationParams|OperationParams[] $parsedBody
+     *
      * @return ExecutionResult|ExecutionResult[]|Promise
+     *
      * @throws InvariantViolation
+     *
+     * @api
      */
     public function executeRequest($parsedBody = null)
     {
-        if (null === $parsedBody) {
+        if ($parsedBody === null) {
             $parsedBody = $this->helper->parseHttpRequest();
         }
 
         if (is_array($parsedBody)) {
             return $this->helper->executeBatch($this->config, $parsedBody);
-        } else {
-            return $this->helper->executeOperation($this->config, $parsedBody);
         }
+
+        return $this->helper->executeOperation($this->config, $parsedBody);
     }
 
     /**
@@ -137,19 +142,17 @@ class StandardServer
      * See `executePsrRequest()` if you prefer to create response yourself
      * (e.g. using specific JsonResponse instance of some framework).
      *
-     * @api
-     * @param ServerRequestInterface $request
-     * @param ResponseInterface $response
-     * @param StreamInterface $writableBodyStream
      * @return ResponseInterface|Promise
+     *
+     * @api
      */
     public function processPsrRequest(
-        ServerRequestInterface $request,
+        RequestInterface $request,
         ResponseInterface $response,
         StreamInterface $writableBodyStream
-    )
-    {
+    ) {
         $result = $this->executePsrRequest($request);
+
         return $this->helper->toPsrResponse($result, $response, $writableBodyStream);
     }
 
@@ -157,13 +160,14 @@ class StandardServer
      * Executes GraphQL operation and returns execution result
      * (or promise when promise adapter is different from SyncPromiseAdapter)
      *
-     * @api
-     * @param ServerRequestInterface $request
      * @return ExecutionResult|ExecutionResult[]|Promise
+     *
+     * @api
      */
-    public function executePsrRequest(ServerRequestInterface $request)
+    public function executePsrRequest(RequestInterface $request)
     {
         $parsedBody = $this->helper->parsePsrRequest($request);
+
         return $this->executeRequest($parsedBody);
     }
 
@@ -171,8 +175,9 @@ class StandardServer
      * Returns an instance of Server helper, which contains most of the actual logic for
      * parsing / validating / executing request (which could be re-used by other server implementations)
      *
-     * @api
      * @return Helper
+     *
+     * @api
      */
     public function getHelper()
     {