webonyx / graphql-php / 390

pending completion

Build # 390

Build Type

Pull #245

travis-ci

Committed by

web-flow

Commit Message

Fix parsing of default values in build-schema

 * Generalizes building a value from an AST, since "scalar" could be misleading, and supporting variable values within custom scalar literals can be valuable.
* Replaces isNullish with isInvalid since `null` is a meaningful value as a result of literal parsing.
* Provide reasonable default version of 'parseLiteral'

ref: https://github.com/graphql/graphql-js/commit/714ee980a
ref: https://github.com/graphql/graphql-js/pull/903

Pull Request Pull Request #245: [0.12] Fix parsing of default values in build-schema

Run Details

92 of 92 new or added lines in 13 files covered. (100.0%)

6916 of 7445 relevant lines covered (92.89%)

104.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.39

/src/Server/Helper.php

<?php
namespace GraphQL\Server;

use GraphQL\Error\Error;
use GraphQL\Error\FormattedError;
use GraphQL\Error\InvariantViolation;
use GraphQL\Executor\ExecutionResult;
use GraphQL\Executor\Executor;
use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
use GraphQL\Executor\Promise\Promise;
use GraphQL\Executor\Promise\PromiseAdapter;
use GraphQL\GraphQL;
use GraphQL\Language\AST\DocumentNode;
use GraphQL\Language\Parser;
use GraphQL\Utils\AST;
use GraphQL\Utils\Utils;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;

/**
 * Contains functionality that could be re-used by various server implementations
 */
class Helper
{

    /**
     * Parses HTTP request using PHP globals and returns GraphQL OperationParams
     * contained in this request. For batched requests it returns an array of OperationParams.
     *
     * This function does not check validity of these params
     * (validation is performed separately in validateOperationParams() method).
     *
     * If $readRawBodyFn argument is not provided - will attempt to read raw request body
     * from `php://input` stream.
     *
     * Internally it normalizes input to $method, $bodyParams and $queryParams and
     * calls `parseRequestParams()` to produce actual return value.
     *
     * For PSR-7 request parsing use `parsePsrRequest()` instead.
     *
     * @api
     * @param callable|null $readRawBodyFn
     * @return OperationParams|OperationParams[]
     * @throws RequestError
     */
    public function parseHttpRequest(callable $readRawBodyFn = null)
    {
        $method = isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : null;
        $bodyParams = [];
        $urlParams = $_GET;

        if ($method === 'POST') {
            $contentType = isset($_SERVER['CONTENT_TYPE']) ? $_SERVER['CONTENT_TYPE'] : null;

            if (stripos($contentType, 'application/graphql') !== false) {
                $rawBody =  $readRawBodyFn ? $readRawBodyFn() : $this->readRawBody();
                $bodyParams = ['query' => $rawBody ?: ''];
            } else if (stripos($contentType, 'application/json') !== false) {
                $rawBody = $readRawBodyFn ? $readRawBodyFn() : $this->readRawBody();
                $bodyParams = json_decode($rawBody ?: '', true);

                if (json_last_error()) {
                    throw new RequestError("Could not parse JSON: " . json_last_error_msg());
                }
                if (!is_array($bodyParams)) {
                    throw new RequestError(
                        "GraphQL Server expects JSON object or array, but got " .
                        Utils::printSafeJson($bodyParams)
                    );
                }
            } else if (stripos($contentType, 'application/x-www-form-urlencoded') !== false) {
                $bodyParams = $_POST;
            } else if (null === $contentType) {
                throw new RequestError('Missing "Content-Type" header');
            } else {
                throw new RequestError("Unexpected content type: " . Utils::printSafeJson($contentType));
            }
        }

        return $this->parseRequestParams($method, $bodyParams, $urlParams);
    }

    /**
     * Parses normalized request params and returns instance of OperationParams
     * or array of OperationParams in case of batch operation.
     *
     * Returned value is a suitable input for `executeOperation` or `executeBatch` (if array)
     *
     * @api
     * @param string $method
     * @param array $bodyParams
     * @param array $queryParams
     * @return OperationParams|OperationParams[]
     * @throws RequestError
     */
    public function parseRequestParams($method, array $bodyParams, array $queryParams)
    {
        if ($method === 'GET') {
            $result = OperationParams::create($queryParams, true);
        } else if ($method === 'POST') {
            if (isset($bodyParams[0])) {
                $result = [];
                foreach ($bodyParams as $index => $entry) {
                    $op = OperationParams::create($entry);
                    $result[] = $op;
                }
            } else {
                $result = OperationParams::create($bodyParams);
            }
        } else {
            throw new RequestError('HTTP Method "' . $method . '" is not supported');
        }
        return $result;
    }

    /**
     * Checks validity of OperationParams extracted from HTTP request and returns an array of errors
     * if params are invalid (or empty array when params are valid)
     *
     * @api
     * @param OperationParams $params
     * @return Error[]
     */
    public function validateOperationParams(OperationParams $params)
    {
        $errors = [];
        if (!$params->query && !$params->queryId) {
            $errors[] = new RequestError('GraphQL Request must include at least one of those two parameters: "query" or "queryId"');
        }
        if ($params->query && $params->queryId) {
            $errors[] = new RequestError('GraphQL Request parameters "query" and "queryId" are mutually exclusive');
        }

        if ($params->query !== null && (!is_string($params->query) || empty($params->query))) {
            $errors[] = new RequestError(
                'GraphQL Request parameter "query" must be string, but got ' .
                Utils::printSafeJson($params->query)
            );
        }
        if ($params->queryId !== null && (!is_string($params->queryId) || empty($params->queryId))) {
            $errors[] = new RequestError(
                'GraphQL Request parameter "queryId" must be string, but got ' .
                Utils::printSafeJson($params->queryId)
            );
        }

        if ($params->operation !== null && (!is_string($params->operation) || empty($params->operation))) {
            $errors[] = new RequestError(
                'GraphQL Request parameter "operation" must be string, but got ' .
                Utils::printSafeJson($params->operation)
            );
        }
        if ($params->variables !== null && (!is_array($params->variables) || isset($params->variables[0]))) {
            $errors[] = new RequestError(
                'GraphQL Request parameter "variables" must be object or JSON string parsed to object, but got ' .
                Utils::printSafeJson($params->getOriginalInput('variables'))
            );
        }
        return $errors;
    }

    /**
     * Executes GraphQL operation with given server configuration and returns execution result
     * (or promise when promise adapter is different from SyncPromiseAdapter)
     *
     * @api
     * @param ServerConfig $config
     * @param OperationParams $op
     *
     * @return ExecutionResult|Promise
     */
    public function executeOperation(ServerConfig $config, OperationParams $op)
    {
        $promiseAdapter = $config->getPromiseAdapter() ?: Executor::getPromiseAdapter();
        $result = $this->promiseToExecuteOperation($promiseAdapter, $config, $op);

        if ($promiseAdapter instanceof SyncPromiseAdapter) {
            $result = $promiseAdapter->wait($result);
        }

        return $result;
    }

    /**
     * Executes batched GraphQL operations with shared promise queue
     * (thus, effectively batching deferreds|promises of all queries at once)
     *
     * @api
     * @param ServerConfig $config
     * @param OperationParams[] $operations
     * @return ExecutionResult[]|Promise
     */
    public function executeBatch(ServerConfig $config, array $operations)
    {
        $promiseAdapter = $config->getPromiseAdapter() ?: Executor::getPromiseAdapter();
        $result = [];

        foreach ($operations as $operation) {
            $result[] = $this->promiseToExecuteOperation($promiseAdapter, $config, $operation, true);
        }

        $result = $promiseAdapter->all($result);

        // Wait for promised results when using sync promises
        if ($promiseAdapter instanceof SyncPromiseAdapter) {
            $result = $promiseAdapter->wait($result);
        }
        return $result;
    }

    /**
     * @param PromiseAdapter $promiseAdapter
     * @param ServerConfig $config
     * @param OperationParams $op
     * @param bool $isBatch
     * @return Promise
     */
    private function promiseToExecuteOperation(PromiseAdapter $promiseAdapter, ServerConfig $config, OperationParams $op, $isBatch = false)
    {
        try {
            if (!$config->getSchema()) {
                throw new InvariantViolation("Schema is required for the server");
            }
            if ($isBatch && !$config->getQueryBatching()) {
                throw new RequestError("Batched queries are not supported by this server");
            }

            $errors = $this->validateOperationParams($op);

            if (!empty($errors)) {
                $errors = Utils::map($errors, function(RequestError $err) {
                    return Error::createLocatedError($err, null, null);
                });
                return $promiseAdapter->createFulfilled(
                    new ExecutionResult(null, $errors)
                );
            }

            $doc = $op->queryId ? $this->loadPersistedQuery($config, $op) : $op->query;

            if (!$doc instanceof DocumentNode) {
                $doc = Parser::parse($doc);
            }

            $operationType = AST::getOperation($doc, $op->operation);
            if ($op->isReadOnly() && $operationType !== 'query') {
                throw new RequestError("GET supports only query operation");
            }

            $result = GraphQL::promiseToExecute(
                $promiseAdapter,
                $config->getSchema(),
                $doc,
                $this->resolveRootValue($config, $op, $doc, $operationType),
                $this->resolveContextValue($config, $op, $doc, $operationType),
                $op->variables,
                $op->operation,
                $config->getFieldResolver(),
                $this->resolveValidationRules($config, $op, $doc, $operationType)
            );

        } catch (RequestError $e) {
            $result = $promiseAdapter->createFulfilled(
                new ExecutionResult(null, [Error::createLocatedError($e)])
            );
        } catch (Error $e) {
            $result = $promiseAdapter->createFulfilled(
                new ExecutionResult(null, [$e])
            );
        }

        $applyErrorHandling = function (ExecutionResult $result) use ($config) {
            if ($config->getErrorsHandler()) {
                $result->setErrorsHandler($config->getErrorsHandler());
            }
            if ($config->getErrorFormatter() || $config->getDebug()) {
                $result->setErrorFormatter(
                    FormattedError::prepareFormatter($config->getErrorFormatter(),
                    $config->getDebug())
                );
            }
            return $result;
        };

        return $result->then($applyErrorHandling);
    }

    /**
     * @param ServerConfig $config
     * @param OperationParams $op
     * @return mixed
     * @throws RequestError
     */
    private function loadPersistedQuery(ServerConfig $config, OperationParams $op)
    {
        // Load query if we got persisted query id:
        $loader = $config->getPersistentQueryLoader();

        if (!$loader) {
            throw new RequestError("Persisted queries are not supported by this server");
        }

        $source = $loader($op->queryId, $op);

        if (!is_string($source) && !$source instanceof DocumentNode) {
            throw new InvariantViolation(sprintf(
                "Persistent query loader must return query string or instance of %s but got: %s",
                DocumentNode::class,
                Utils::printSafe($source)
            ));
        }

        return $source;
    }

    /**
     * @param ServerConfig $config
     * @param OperationParams $params
     * @param DocumentNode $doc
     * @param $operationType
     * @return array
     */
    private function resolveValidationRules(ServerConfig $config, OperationParams $params, DocumentNode $doc, $operationType)
    {
        // Allow customizing validation rules per operation:
        $validationRules = $config->getValidationRules();

        if (is_callable($validationRules)) {
            $validationRules = $validationRules($params, $doc, $operationType);

            if (!is_array($validationRules)) {
                throw new InvariantViolation(sprintf(
                    "Expecting validation rules to be array or callable returning array, but got: %s",
                    Utils::printSafe($validationRules)
                ));
            }
        }

        return $validationRules;
    }

    /**
     * @param ServerConfig $config
     * @param OperationParams $params
     * @param DocumentNode $doc
     * @param $operationType
     * @return mixed
     */
    private function resolveRootValue(ServerConfig $config, OperationParams $params, DocumentNode $doc, $operationType)
    {
        $root = $config->getRootValue();

        if ($root instanceof \Closure) {
            $root = $root($params, $doc, $operationType);
        }

        return $root;
    }

    /**
     * @param ServerConfig $config
     * @param OperationParams $params
     * @param DocumentNode $doc
     * @param $operationType
     * @return mixed
     */
    private function resolveContextValue(ServerConfig $config, OperationParams $params, DocumentNode $doc, $operationType)
    {
        $context = $config->getContext();

        if ($context instanceof \Closure) {
            $context = $context($params, $doc, $operationType);
        }

        return $context;
    }

    /**
     * Send response using standard PHP `header()` and `echo`.
     *
     * @api
     * @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);
        }
    }

    /**
     * @param $result
     * @param $exitWhenDone
     */
    private function doSendResponse($result, $exitWhenDone)
    {
        $httpStatus = $this->resolveHttpStatus($result);
        $this->emitResponse($result, $httpStatus, $exitWhenDone);
    }

    /**
     * @param array|\JsonSerializable $jsonSerializable
     * @param int $httpStatus
     * @param bool $exitWhenDone
     */
    public function emitResponse($jsonSerializable, $httpStatus, $exitWhenDone)
    {
        $body = json_encode($jsonSerializable);
        header('Content-Type: application/json', true, $httpStatus);
        echo $body;

        if ($exitWhenDone) {
            exit;
        }
    }

    /**
     * @return bool|string
     */
    private function readRawBody()
    {
        return file_get_contents('php://input');
    }

    /**
     * @param $result
     * @return int
     */
    private function resolveHttpStatus($result)
    {
        if (is_array($result) && isset($result[0])) {
            Utils::each($result, 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;
    }

    /**
     * Converts PSR-7 request to OperationParams[]
     *
     * @api
     * @param ServerRequestInterface $request
     * @return array|Helper
     * @throws RequestError
     */
    public function parsePsrRequest(ServerRequestInterface $request)
    {
        if ($request->getMethod() === 'GET') {
            $bodyParams = [];
        } else {
            $contentType = $request->getHeader('content-type');

            if (!isset($contentType[0])) {
                throw new RequestError('Missing "Content-Type" header');
            }

            if (stripos($contentType[0], 'application/graphql') !== false) {
                $bodyParams = ['query' => $request->getBody()->getContents()];
            } else if (stripos($contentType[0], 'application/json') !== false) {
                $bodyParams = $request->getParsedBody();

                if (null === $bodyParams) {
                    throw new InvariantViolation(
                        "PSR-7 request is expected to provide parsed body for \"application/json\" requests but got null"
                    );
                }

                if (!is_array($bodyParams)) {
                    throw new RequestError(
                        "GraphQL Server expects JSON object or array, but got " .
                        Utils::printSafeJson($bodyParams)
                    );
                }
            } else {
                $bodyParams = $request->getParsedBody();

                if (!is_array($bodyParams)) {
                    throw new RequestError("Unexpected content type: " . Utils::printSafeJson($contentType[0]));
                }
            }
        }

        return $this->parseRequestParams(
            $request->getMethod(),
            $bodyParams,
            $request->getQueryParams()
        );
    }

    /**
     * Converts query execution result to PSR-7 response
     *
     * @api
     * @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);
    }
}

1	<?php
2	namespace GraphQL\Server;
3
4	use GraphQL\Error\Error;
5	use GraphQL\Error\FormattedError;
6	use GraphQL\Error\InvariantViolation;
7	use GraphQL\Executor\ExecutionResult;
8	use GraphQL\Executor\Executor;
9	use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
10	use GraphQL\Executor\Promise\Promise;
11	use GraphQL\Executor\Promise\PromiseAdapter;
12	use GraphQL\GraphQL;
13	use GraphQL\Language\AST\DocumentNode;
14	use GraphQL\Language\Parser;
15	use GraphQL\Utils\AST;
16	use GraphQL\Utils\Utils;
17	use Psr\Http\Message\ResponseInterface;
18	use Psr\Http\Message\ServerRequestInterface;
19	use Psr\Http\Message\StreamInterface;
20
21	/**
22	* Contains functionality that could be re-used by various server implementations
23	*/
24	class Helper
25	{
26
27	/**
28	* Parses HTTP request using PHP globals and returns GraphQL OperationParams
29	* contained in this request. For batched requests it returns an array of OperationParams.
30	*
31	* This function does not check validity of these params
32	* (validation is performed separately in validateOperationParams() method).
33	*
34	* If $readRawBodyFn argument is not provided - will attempt to read raw request body
35	* from `php://input` stream.
36	*
37	* Internally it normalizes input to $method, $bodyParams and $queryParams and
38	* calls `parseRequestParams()` to produce actual return value.
39	*
40	* For PSR-7 request parsing use `parsePsrRequest()` instead.
41	*
42	* @api
43	* @param callable\|null $readRawBodyFn
44	* @return OperationParams\|OperationParams[]
45	* @throws RequestError
46	*/
47	public function parseHttpRequest(callable $readRawBodyFn = null)
48	{
49	$method = isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : null;	14✔
50	$bodyParams = [];	14✔
51	$urlParams = $_GET;	14✔
52
53	if ($method === 'POST') {	14✔
54	$contentType = isset($_SERVER['CONTENT_TYPE']) ? $_SERVER['CONTENT_TYPE'] : null;	12✔
55
56	if (stripos($contentType, 'application/graphql') !== false) {	12✔
57	$rawBody = $readRawBodyFn ? $readRawBodyFn() : $this->readRawBody();	1✔
58	$bodyParams = ['query' => $rawBody ?: ''];	1✔
59	} else if (stripos($contentType, 'application/json') !== false) {	12✔
60	$rawBody = $readRawBodyFn ? $readRawBodyFn() : $this->readRawBody();	7✔
61	$bodyParams = json_decode($rawBody ?: '', true);	7✔
62
63	if (json_last_error()) {	7✔
64	throw new RequestError("Could not parse JSON: " . json_last_error_msg());	1✔
65	}
66	if (!is_array($bodyParams)) {	6✔
67	throw new RequestError(	1✔
68	"GraphQL Server expects JSON object or array, but got " .
69	Utils::printSafeJson($bodyParams)	1✔
70	);	1✔
71	}
72	} else if (stripos($contentType, 'application/x-www-form-urlencoded') !== false) {	9✔
73	$bodyParams = $_POST;	1✔
74	} else if (null === $contentType) {	4✔
75	throw new RequestError('Missing "Content-Type" header');	1✔
76	} else {
77	throw new RequestError("Unexpected content type: " . Utils::printSafeJson($contentType));	2✔
78	}
79	}	7✔
80
81	return $this->parseRequestParams($method, $bodyParams, $urlParams);	9✔
82	}
83
84	/**
85	* Parses normalized request params and returns instance of OperationParams
86	* or array of OperationParams in case of batch operation.
87	*
88	* Returned value is a suitable input for `executeOperation` or `executeBatch` (if array)
89	*
90	* @api
91	* @param string $method
92	* @param array $bodyParams
93	* @param array $queryParams
94	* @return OperationParams\|OperationParams[]
95	* @throws RequestError
96	*/
97	public function parseRequestParams($method, array $bodyParams, array $queryParams)
98	{
99	if ($method === 'GET') {	11✔
100	$result = OperationParams::create($queryParams, true);	1✔
101	} else if ($method === 'POST') {	11✔
102	if (isset($bodyParams[0])) {	8✔
103	$result = [];	1✔
104	foreach ($bodyParams as $index => $entry) {	1✔
105	$op = OperationParams::create($entry);	1✔
106	$result[] = $op;	1✔
107	}	1✔
108	} else {	1✔
109	$result = OperationParams::create($bodyParams);	7✔
110	}
111	} else {	8✔
112	throw new RequestError('HTTP Method "' . $method . '" is not supported');	2✔
113	}
114	return $result;	9✔
115	}
116
117	/**
118	* Checks validity of OperationParams extracted from HTTP request and returns an array of errors
119	* if params are invalid (or empty array when params are valid)
120	*
121	* @api
122	* @param OperationParams $params
123	* @return Error[]
124	*/
125	public function validateOperationParams(OperationParams $params)
126	{
127	$errors = [];	34✔
128	if (!$params->query && !$params->queryId) {	34✔
129	$errors[] = new RequestError('GraphQL Request must include at least one of those two parameters: "query" or "queryId"');	2✔
130	}	2✔
131	if ($params->query && $params->queryId) {	34✔
132	$errors[] = new RequestError('GraphQL Request parameters "query" and "queryId" are mutually exclusive');	1✔
133	}	1✔
134
135	if ($params->query !== null && (!is_string($params->query) \|\| empty($params->query))) {	34✔
136	$errors[] = new RequestError(	1✔
137	'GraphQL Request parameter "query" must be string, but got ' .
138	Utils::printSafeJson($params->query)	1✔
139	);	1✔
140	}	1✔
141	if ($params->queryId !== null && (!is_string($params->queryId) \|\| empty($params->queryId))) {	34✔
142	$errors[] = new RequestError(	1✔
143	'GraphQL Request parameter "queryId" must be string, but got ' .
144	Utils::printSafeJson($params->queryId)	1✔
145	);	1✔
146	}	1✔
147
148	if ($params->operation !== null && (!is_string($params->operation) \|\| empty($params->operation))) {	34✔
149	$errors[] = new RequestError(	1✔
150	'GraphQL Request parameter "operation" must be string, but got ' .
151	Utils::printSafeJson($params->operation)	1✔
152	);	1✔
153	}	1✔
154	if ($params->variables !== null && (!is_array($params->variables) \|\| isset($params->variables[0]))) {	34✔
155	$errors[] = new RequestError(	1✔
156	'GraphQL Request parameter "variables" must be object or JSON string parsed to object, but got ' .
157	Utils::printSafeJson($params->getOriginalInput('variables'))	1✔
158	);	1✔
159	}	1✔
160	return $errors;	34✔
161	}
162
163	/**
164	* Executes GraphQL operation with given server configuration and returns execution result
165	* (or promise when promise adapter is different from SyncPromiseAdapter)
166	*
167	* @api
168	* @param ServerConfig $config
169	* @param OperationParams $op
170	*
171	* @return ExecutionResult\|Promise
172	*/
173	public function executeOperation(ServerConfig $config, OperationParams $op)
174	{
175	$promiseAdapter = $config->getPromiseAdapter() ?: Executor::getPromiseAdapter();	23✔
176	$result = $this->promiseToExecuteOperation($promiseAdapter, $config, $op);	23✔
177
178	if ($promiseAdapter instanceof SyncPromiseAdapter) {	21✔
179	$result = $promiseAdapter->wait($result);	21✔
180	}	21✔
181
182	return $result;	21✔
183	}
184
185	/**
186	* Executes batched GraphQL operations with shared promise queue
187	* (thus, effectively batching deferreds\|promises of all queries at once)
188	*
189	* @api
190	* @param ServerConfig $config
191	* @param OperationParams[] $operations
192	* @return ExecutionResult[]\|Promise
193	*/
194	public function executeBatch(ServerConfig $config, array $operations)
195	{
196	$promiseAdapter = $config->getPromiseAdapter() ?: Executor::getPromiseAdapter();	3✔
197	$result = [];	3✔
198
199	foreach ($operations as $operation) {	3✔
200	$result[] = $this->promiseToExecuteOperation($promiseAdapter, $config, $operation, true);	3✔
201	}	3✔
202
203	$result = $promiseAdapter->all($result);	3✔
204
205	// Wait for promised results when using sync promises
206	if ($promiseAdapter instanceof SyncPromiseAdapter) {	3✔
207	$result = $promiseAdapter->wait($result);	3✔
208	}	3✔
209	return $result;	3✔
210	}
211
212	/**
213	* @param PromiseAdapter $promiseAdapter
214	* @param ServerConfig $config
215	* @param OperationParams $op
216	* @param bool $isBatch
217	* @return Promise
218	*/
219	private function promiseToExecuteOperation(PromiseAdapter $promiseAdapter, ServerConfig $config, OperationParams $op, $isBatch = false)
220	{
221	try {
222	if (!$config->getSchema()) {	26✔
223	throw new InvariantViolation("Schema is required for the server");	×
224	}
225	if ($isBatch && !$config->getQueryBatching()) {	26✔
226	throw new RequestError("Batched queries are not supported by this server");	1✔
227	}
228
229	$errors = $this->validateOperationParams($op);	25✔
230
231	if (!empty($errors)) {	25✔
232	$errors = Utils::map($errors, function(RequestError $err) {
233	return Error::createLocatedError($err, null, null);	1✔
234	});	1✔
235	return $promiseAdapter->createFulfilled(	1✔
236	new ExecutionResult(null, $errors)	1✔
237	);	1✔
238	}
239
240	$doc = $op->queryId ? $this->loadPersistedQuery($config, $op) : $op->query;	24✔
241
242	if (!$doc instanceof DocumentNode) {	22✔
243	$doc = Parser::parse($doc);	22✔
244	}	21✔
245
246	$operationType = AST::getOperation($doc, $op->operation);	21✔
247	if ($op->isReadOnly() && $operationType !== 'query') {	21✔
248	throw new RequestError("GET supports only query operation");	1✔
249	}
250
251	$result = GraphQL::promiseToExecute(	20✔
252	$promiseAdapter,	20✔
253	$config->getSchema(),	20✔
254	$doc,	20✔
255	$this->resolveRootValue($config, $op, $doc, $operationType),	20✔
256	$this->resolveContextValue($config, $op, $doc, $operationType),	20✔
257	$op->variables,	20✔
258	$op->operation,	20✔
259	$config->getFieldResolver(),	20✔
260	$this->resolveValidationRules($config, $op, $doc, $operationType)	20✔
261	);	19✔
262
263	} catch (RequestError $e) {	25✔
264	$result = $promiseAdapter->createFulfilled(	3✔
265	new ExecutionResult(null, [Error::createLocatedError($e)])	3✔
266	);	3✔
267	} catch (Error $e) {	6✔
268	$result = $promiseAdapter->createFulfilled(	1✔
269	new ExecutionResult(null, [$e])	1✔
270	);	1✔
271	}
272
273	$applyErrorHandling = function (ExecutionResult $result) use ($config) {
274	if ($config->getErrorsHandler()) {	23✔
275	$result->setErrorsHandler($config->getErrorsHandler());	1✔
276	}	1✔
277	if ($config->getErrorFormatter() \|\| $config->getDebug()) {	23✔
278	$result->setErrorFormatter(	2✔
279	FormattedError::prepareFormatter($config->getErrorFormatter(),	2✔
280	$config->getDebug())	2✔
281	);	2✔
282	}	2✔
283	return $result;	23✔
284	};	23✔
285
286	return $result->then($applyErrorHandling);	23✔
287	}
288
289	/**
290	* @param ServerConfig $config
291	* @param OperationParams $op
292	* @return mixed
293	* @throws RequestError
294	*/
295	private function loadPersistedQuery(ServerConfig $config, OperationParams $op)
296	{
297	// Load query if we got persisted query id:
298	$loader = $config->getPersistentQueryLoader();	5✔
299
300	if (!$loader) {	5✔
301	throw new RequestError("Persisted queries are not supported by this server");	1✔
302	}
303
304	$source = $loader($op->queryId, $op);	4✔
305
306	if (!is_string($source) && !$source instanceof DocumentNode) {	4✔
307	throw new InvariantViolation(sprintf(	1✔
308	"Persistent query loader must return query string or instance of %s but got: %s",	1✔
309	DocumentNode::class,	1✔
310	Utils::printSafe($source)	1✔
311	));	1✔
312	}
313
314	return $source;	3✔
315	}
316
317	/**
318	* @param ServerConfig $config
319	* @param OperationParams $params
320	* @param DocumentNode $doc
321	* @param $operationType
322	* @return array
323	*/
324	private function resolveValidationRules(ServerConfig $config, OperationParams $params, DocumentNode $doc, $operationType)
325	{
326	// Allow customizing validation rules per operation:
327	$validationRules = $config->getValidationRules();	20✔
328
329	if (is_callable($validationRules)) {	20✔
330	$validationRules = $validationRules($params, $doc, $operationType);	4✔
331
332	if (!is_array($validationRules)) {	4✔
333	throw new InvariantViolation(sprintf(	1✔
334	"Expecting validation rules to be array or callable returning array, but got: %s",	1✔
335	Utils::printSafe($validationRules)	1✔
336	));	1✔
337	}
338	}	3✔
339
340	return $validationRules;	19✔
341	}
342
343	/**
344	* @param ServerConfig $config
345	* @param OperationParams $params
346	* @param DocumentNode $doc
347	* @param $operationType
348	* @return mixed
349	*/
350	private function resolveRootValue(ServerConfig $config, OperationParams $params, DocumentNode $doc, $operationType)
351	{
352	$root = $config->getRootValue();	20✔
353
354	if ($root instanceof \Closure) {	20✔
355	$root = $root($params, $doc, $operationType);	1✔
356	}	1✔
357
358	return $root;	20✔
359	}
360
361	/**
362	* @param ServerConfig $config
363	* @param OperationParams $params
364	* @param DocumentNode $doc
365	* @param $operationType
366	* @return mixed
367	*/
368	private function resolveContextValue(ServerConfig $config, OperationParams $params, DocumentNode $doc, $operationType)
369	{
370	$context = $config->getContext();	20✔
371
372	if ($context instanceof \Closure) {	20✔
373	$context = $context($params, $doc, $operationType);	1✔
374	}	1✔
375
376	return $context;	20✔
377	}
378
379	/**
380	* Send response using standard PHP `header()` and `echo`.
381	*
382	* @api
383	* @param Promise\|ExecutionResult\|ExecutionResult[] $result
384	* @param bool $exitWhenDone
385	*/
386	public function sendResponse($result, $exitWhenDone = false)
387	{
388	if ($result instanceof Promise) {	×
389	$result->then(function($actualResult) use ($exitWhenDone) {
390	$this->doSendResponse($actualResult, $exitWhenDone);	×
391	});	×
392	} else {	×
393	$this->doSendResponse($result, $exitWhenDone);	×
394	}
395	}	×
396
397	/**
398	* @param $result
399	* @param $exitWhenDone
400	*/
401	private function doSendResponse($result, $exitWhenDone)
402	{
403	$httpStatus = $this->resolveHttpStatus($result);	×
404	$this->emitResponse($result, $httpStatus, $exitWhenDone);	×
405	}	×
406
407	/**
408	* @param array\|\JsonSerializable $jsonSerializable
409	* @param int $httpStatus
410	* @param bool $exitWhenDone
411	*/
412	public function emitResponse($jsonSerializable, $httpStatus, $exitWhenDone)
413	{
414	$body = json_encode($jsonSerializable);	×
415	header('Content-Type: application/json', true, $httpStatus);	×
416	echo $body;	×
417
418	if ($exitWhenDone) {	×
419	exit;	×
420	}
421	}	×
422
423	/**
424	* @return bool\|string
425	*/
426	private function readRawBody()
427	{
428	return file_get_contents('php://input');	×
429	}
430
431	/**
432	* @param $result
433	* @return int
434	*/
435	private function resolveHttpStatus($result)
436	{
437	if (is_array($result) && isset($result[0])) {	1✔
438	Utils::each($result, function ($executionResult, $index) {
439	if (!$executionResult instanceof ExecutionResult) {	×
440	throw new InvariantViolation(sprintf(	×
441	"Expecting every entry of batched query result to be instance of %s but entry at position %d is %s",	×
442	ExecutionResult::class,	×
443	$index,	×
444	Utils::printSafe($executionResult)	×
445	));	×
446	}
447	});	×
448	$httpStatus = 200;	×
449	} else {	×
450	if (!$result instanceof ExecutionResult) {	1✔
451	throw new InvariantViolation(sprintf(	×
452	"Expecting query result to be instance of %s but got %s",	×
453	ExecutionResult::class,	×
454	Utils::printSafe($result)	×
455	));	×
456	}
457	if ($result->data === null && !empty($result->errors)) {	1✔
458	$httpStatus = 400;	×
459	} else {	×
460	$httpStatus = 200;	1✔
461	}
462	}
463	return $httpStatus;	1✔
464	}
465
466	/**
467	* Converts PSR-7 request to OperationParams[]
468	*
469	* @api
470	* @param ServerRequestInterface $request
471	* @return array\|Helper
472	* @throws RequestError
473	*/
474	public function parsePsrRequest(ServerRequestInterface $request)
475	{
476	if ($request->getMethod() === 'GET') {	13✔
477	$bodyParams = [];	1✔
478	} else {	1✔
479	$contentType = $request->getHeader('content-type');	12✔
480
481	if (!isset($contentType[0])) {	12✔
482	throw new RequestError('Missing "Content-Type" header');	1✔
483	}
484
485	if (stripos($contentType[0], 'application/graphql') !== false) {	11✔
486	$bodyParams = ['query' => $request->getBody()->getContents()];	1✔
487	} else if (stripos($contentType[0], 'application/json') !== false) {	11✔
488	$bodyParams = $request->getParsedBody();	9✔
489
490	if (null === $bodyParams) {	9✔
491	throw new InvariantViolation(	2✔
492	"PSR-7 request is expected to provide parsed body for \"application/json\" requests but got null"
493	);	2✔
494	}
495
496	if (!is_array($bodyParams)) {	7✔
497	throw new RequestError(	1✔
498	"GraphQL Server expects JSON object or array, but got " .
499	Utils::printSafeJson($bodyParams)	1✔
500	);	1✔
501	}
502	} else {	6✔
503	$bodyParams = $request->getParsedBody();	1✔
504
505	if (!is_array($bodyParams)) {	1✔
506	throw new RequestError("Unexpected content type: " . Utils::printSafeJson($contentType[0]));	×
507	}	21✔
508	}
509	}
510
511	return $this->parseRequestParams(	9✔
512	$request->getMethod(),	9✔
513	$bodyParams,	9✔
514	$request->getQueryParams()	9✔
515	);	9✔
516	}
517
518	/**
519	* Converts query execution result to PSR-7 response
520	*
521	* @api
522	* @param Promise\|ExecutionResult\|ExecutionResult[] $result
523	* @param ResponseInterface $response
524	* @param StreamInterface $writableBodyStream
525	* @return Promise\|ResponseInterface
526	*/
527	public function toPsrResponse($result, ResponseInterface $response, StreamInterface $writableBodyStream)
528	{
529	if ($result instanceof Promise) {	1✔
530	return $result->then(function($actualResult) use ($response, $writableBodyStream) {
531	return $this->doConvertToPsrResponse($actualResult, $response, $writableBodyStream);	×
532	});	×
533	} else {
534	return $this->doConvertToPsrResponse($result, $response, $writableBodyStream);	1✔
535	}
536	}
537
538	private function doConvertToPsrResponse($result, ResponseInterface $response, StreamInterface $writableBodyStream)
539	{
540	$httpStatus = $this->resolveHttpStatus($result);	1✔
541
542	$result = json_encode($result);	1✔
543	$writableBodyStream->write($result);	1✔
544
545	return $response
546	->withStatus($httpStatus)	1✔
547	->withHeader('Content-Type', 'application/json')	1✔
548	->withBody($writableBodyStream);	1✔
549	}
550	}

webonyx / graphql-php / 390

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous