QueryProcessor::loadPersistedQuery() - Code Metrics - Inspection of "Refactoring towards webonyx/graphql-php." - drupal-graphql/graphql - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 8.x-3.x (#525)

by Sebastian

created 2018-02-25 10:25 UTC

QueryProcessor::loadPersistedQuery() A

↳ Parent: QueryProcessor

Complexity

Conditions	4
Paths	3

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	7
nc	3
nop	2
dl	0
loc	12
rs	9.2
c	0
b	0
f	0

<?php

namespace Drupal\graphql\GraphQL\Execution;

use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Session\AccountProxyInterface;
use Drupal\graphql\GraphQL\Visitors\CacheMetadataCalculator;
use Drupal\graphql\GraphQL\Visitors\ComplexityCalculator;
use Drupal\graphql\GraphQL\Visitors\QueryEdgeCollector;
use Drupal\graphql\Plugin\SchemaPluginManager;
use Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface;
use GraphQL\Error\Error;
use GraphQL\Error\FormattedError;
use GraphQL\Executor\ExecutionResult;
use GraphQL\Executor\Executor;
use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
use GraphQL\Executor\Promise\PromiseAdapter;
use GraphQL\Language\AST\DocumentNode;
use GraphQL\Language\Parser;
use GraphQL\Language\Visitor;
use GraphQL\Server\Helper;
use GraphQL\Server\OperationParams;
use GraphQL\Server\RequestError;
use GraphQL\Server\ServerConfig;
use GraphQL\Utils\AST;
use GraphQL\Utils\TypeInfo;
use GraphQL\Utils\Utils;
use GraphQL\Validator\DocumentValidator;
use GraphQL\Validator\Rules\AbstractValidationRule;
use GraphQL\Validator\ValidationContext;

class QueryProcessor {

  /**
   * The current user account.
   *
   * @var \Drupal\Core\Session\AccountProxyInterface
   */
  protected $currentUser;

  /**
   * The schema plugin manager.
   *
   * @var \Drupal\graphql\Plugin\SchemaPluginManager
   */
  protected $pluginManager;

  /**
   * The query provider service.
   *
   * @var \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface
   */
  protected $queryProvider;

  /**
   * Processor constructor.
   *
   * @param \Drupal\Core\Session\AccountProxyInterface $currentUser
   *   The current user.
   * @param \Drupal\graphql\Plugin\SchemaPluginManager $pluginManager
   *   The schema plugin manager.
   * @param \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface $queryProvider
   *   The query provider service.
   */
  public function __construct(
    AccountProxyInterface $currentUser,
    SchemaPluginManager $pluginManager,
    QueryProviderInterface $queryProvider
  ) {
    $this->currentUser = $currentUser;
    $this->pluginManager = $pluginManager;
    $this->queryProvider = $queryProvider;
  }

  /**
   * Processes one or multiple graphql operations.
   *
   * @param string $schema
   *   The plugin id of the schema to use.
   * @param \GraphQL\Server\OperationParams|\GraphQL\Server\OperationParams[] $params
   *   The graphql operation(s) to execute.
   * @param array $globals
   *   The query context.
   *
   * @return \Drupal\graphql\GraphQL\Execution\QueryResult|\Drupal\graphql\GraphQL\Execution\QueryResult[]
   *   The query result.
   *
   */
  public function processQuery($schema, $params, array $globals = []) {
    // Load the plugin from the schema manager.
    $plugin = $this->pluginManager->createInstance($schema);
    $schema = $plugin->getSchema();

    // If the current user has appropriate permissions, allow to bypass
    // the secure fields restriction.
    $globals['bypass field security'] = $this->currentUser->hasPermission('bypass graphql field security');

    // Create the server config.
    $config = ServerConfig::create();
    $config->setDebug(!empty($globals['development']));
    $config->setSchema($schema);
    $config->setQueryBatching(TRUE);
    $config->setContext(function () use ($globals) {
      // Each document (e.g. in a batch query) gets its own resolve context but
      // the global parameters are shared. This allows us to collect the cache
      // metadata and contextual values (e.g. inheritance for language) for each
      // query separately.
      return new ResolveContext($globals);
    });

    $config->setValidationRules(function (OperationParams $params, DocumentNode $document, $operation) {

      if (isset($params->queryId)) {
        // Assume that pre-parsed documents are already validated. This allows
        // us to store pre-validated query documents e.g. for persisted queries
        // effectively improving performance by skipping run-time validation.
        return [];
      }

      return array_values(DocumentValidator::allRules());
    });

    $config->setPersistentQueryLoader(function ($id, OperationParams $params) {
      if ($query = $this->queryProvider->getQuery($id, $params)) {
        return $query;
      }

      throw new RequestError(sprintf("Failed to load query map for id '%s'.", $id));
    });

    if (is_array($params)) {
      return $this->executeBatch($config, $params);
    }

    return $this->executeSingle($config, $params);
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   *
   * @return mixed
   */
  public function executeSingle(ServerConfig $config, OperationParams $params) {
    $adapter = new SyncPromiseAdapter();
    $result = $this->executeOperation($adapter, $config, $params, FALSE);
    return $adapter->wait($result);
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param array $params
   *
   * @return mixed
   */
  public function executeBatch(ServerConfig $config, array $params) {
    $adapter = new SyncPromiseAdapter();
    $result = array_map(function ($params) use ($adapter, $config) {
      return $this->executeOperation($adapter, $config, $params, TRUE);
    }, $params);

    $result = $adapter->all($result);
    return $adapter->wait($result);
  }

  /**
   * @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param bool $batching
   *
   * @return \GraphQL\Executor\Promise\Promise
   */
  protected function executeOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, $batching = FALSE) {
    try {
      if (!$config->getSchema()) {
        throw new \LogicException('Missing schema for query execution.');
      }

      if ($batching && !$config->getQueryBatching()) {
        throw new RequestError('Batched queries are not supported by this server.');
      }

      if ($errors = (new Helper())->validateOperationParams($params)) {
        $errors = Utils::map($errors, function (RequestError $err) {
          return Error::createLocatedError($err, NULL, NULL);
        });

        return $adapter->createFulfilled(new QueryResult(NULL, $errors));
      }

      $schema = $config->getSchema();
      $variables = $params->variables;
      $operation = $params->operation;
      $document = $params->queryId ? $this->loadPersistedQuery($config, $params) : $params->query;
      if (!$document instanceof DocumentNode) {
        $document = Parser::parse($document);
      }

      // Read the operation type from the document. Subscriptions and mutations
      // only work through POST requests. One cannot have mutations and queries
      // in the same document, hence this check is sufficient.
      $type = AST::getOperation($document, $operation);
      if ($params->isReadOnly() && $type !== 'query') {
        throw new RequestError('GET requests are only supported for query operations.');
      }

      /** @var \Drupal\graphql\GraphQL\Execution\ResolveContext $context */
      $context = $this->resolveContextValue($config, $params, $document, $operation);
      $complexity = $this->resolveAllowedComplexity($config, $params, $document, $operation);
      $rules = $this->resolveValidationRules($config, $params, $document, $operation);
      $info = new TypeInfo($schema);
      $validation = new ValidationContext($schema, $document, $info);

      // Add a special visitor to the set of validation rules which will collect
      // all nodes and fields (all possible edges) from the document to allow
      // for static query analysis (e.g. for calculating the query complexity or
      // for determining the cache metadata of a query so we can perform cache
      // lookups).
      $visitors = array_values(array_map(function (AbstractValidationRule $rule) use ($validation, $context) {
        return $rule->getVisitor($validation);
      }, array_merge($rules, [new QueryEdgeCollector(array_filter([
        // Query operations can be cached. Collect static cache metadata from
        // the document during the visitor phase.
        $type === 'query' ? new CacheMetadataCalculator($context) : NULL,
        $complexity !== NULL ? new ComplexityCalculator($complexity) : NULL,

      ]))])));

      // Run the query visitor with the prepared validation rules and the cache
      // metadata collector and query complexity calculator.
      Visitor::visit($document, Visitor::visitWithTypeInfo($info, Visitor::visitInParallel($visitors)));

      // If one of the validation rules found any problems, do not resolve the
      // query and bail out early instead.
      if ($errors = $validation->getErrors()) {
        return $adapter->createFulfilled(new QueryResult(NULL, $errors));
      }

      // TODO: Perform a cach lookup.
      if ($context->getCacheMaxAge() !== 0) {
        $hash = hash('sha256', $this->serializeDocument($document));
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
      }

      $resolver = $config->getFieldResolver();
      $root = $this->resolveRootValue($config, $params, $document, $operation);
      $promise = Executor::promiseToExecute(
        $adapter,
        $schema,
        $document,
        $root,
        $context,
        $variables,
        $operation,
        $resolver
      );

      return $promise->then(function (ExecutionResult $result) use ($context) {
        $metadata = (new CacheableMetadata())->addCacheableDependency($context);
        return new QueryResult($result->data, $result->errors, $result->extensions, $metadata);
      });
    }
    catch (RequestError $exception) {
      $result = $adapter->createFulfilled(new QueryResult(NULL, [Error::createLocatedError($exception)]));
    }
    catch (Error $exception) {
      $result = $adapter->createFulfilled(new QueryResult(NULL, [$exception]));
    }

    return $result->then(function(QueryResult $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;
    });
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   * @param $operation
   *
   * @return mixed
   */
  protected function resolveRootValue(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {

    $root = $config->getRootValue();
    if (is_callable($root)) {
      $root = $root($params, $document, $operation);
    }

    return $root;
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   * @param $operation
   *
   * @return mixed
   */
  protected function resolveContextValue(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {

    $context = $config->getContext();
    if (is_callable($context)) {
      $context = $context($params, $document, $operation);
    }

    return $context;
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   * @param $operation
   *
   * @return array
   */
  protected function resolveValidationRules(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {
    // Allow customizing validation rules per operation:
    $rules = $config->getValidationRules();
    if (is_callable($rules)) {
      $rules = $rules($params, $document, $operation);
      if (!is_array($rules)) {
        throw new \LogicException(sprintf("Expecting validation rules to be array or callable returning array, but got: %s", Utils::printSafe($rules)));
      }
    }

    return $rules;
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   * @param $operation
   *
   * @return int|null
   */
  protected function resolveAllowedComplexity(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {

    return NULL;
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   *
   * @return mixed
   * @throws \GraphQL\Server\RequestError
   */
  protected function loadPersistedQuery(ServerConfig $config, OperationParams $params) {
    if (!$loader = $config->getPersistentQueryLoader()) {
      throw new RequestError('Persisted queries are not supported by this server.');
    }

    $source = $loader($params->queryId, $params);
    if (!is_string($source) && !$source instanceof DocumentNode) {
      throw new \LogicException(sprintf('The persisted query loader must return query string or instance of %s but got: %s.', DocumentNode::class, Utils::printSafe($source)));
    }

    return $source;
  }

  /**
   * @param \GraphQL\Language\AST\DocumentNode $document
   *
   * @return array
   */
  protected function serializeDocument(DocumentNode $document) {
    return $this->sanitizeRecursive(AST::toArray($document));
  }

  /**
   * @param array $item
   *
   * @return array
   */
  protected function sanitizeRecursive(array $item) {
    unset($item['loc']);

    foreach ($item as &$value) {
      if (is_array($value)) {
        $value = $this->sanitizeRecursive($value);
      }
    }

    return $item;
  }

}


1		<?php
2
3		namespace Drupal\graphql\GraphQL\Execution;
4
5		use Drupal\Core\Cache\CacheableMetadata;
6		use Drupal\Core\Session\AccountProxyInterface;
7		use Drupal\graphql\GraphQL\Visitors\CacheMetadataCalculator;
8		use Drupal\graphql\GraphQL\Visitors\ComplexityCalculator;
9		use Drupal\graphql\GraphQL\Visitors\QueryEdgeCollector;
10		use Drupal\graphql\Plugin\SchemaPluginManager;
11		use Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface;
12		use GraphQL\Error\Error;
13		use GraphQL\Error\FormattedError;
14		use GraphQL\Executor\ExecutionResult;
15		use GraphQL\Executor\Executor;
16		use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
17		use GraphQL\Executor\Promise\PromiseAdapter;
18		use GraphQL\Language\AST\DocumentNode;
19		use GraphQL\Language\Parser;
20		use GraphQL\Language\Visitor;
21		use GraphQL\Server\Helper;
22		use GraphQL\Server\OperationParams;
23		use GraphQL\Server\RequestError;
24		use GraphQL\Server\ServerConfig;
25		use GraphQL\Utils\AST;
26		use GraphQL\Utils\TypeInfo;
27		use GraphQL\Utils\Utils;
28		use GraphQL\Validator\DocumentValidator;
29		use GraphQL\Validator\Rules\AbstractValidationRule;
30		use GraphQL\Validator\ValidationContext;
31
32		class QueryProcessor {
33
34		/**
35		* The current user account.
36		*
37		* @var \Drupal\Core\Session\AccountProxyInterface
38		*/
39		protected $currentUser;
40
41		/**
42		* The schema plugin manager.
43		*
44		* @var \Drupal\graphql\Plugin\SchemaPluginManager
45		*/
46		protected $pluginManager;
47
48		/**
49		* The query provider service.
50		*
51		* @var \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface
52		*/
53		protected $queryProvider;
54
55		/**
56		* Processor constructor.
57		*
58		* @param \Drupal\Core\Session\AccountProxyInterface $currentUser
59		* The current user.
60		* @param \Drupal\graphql\Plugin\SchemaPluginManager $pluginManager
61		* The schema plugin manager.
62		* @param \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface $queryProvider
63		* The query provider service.
64		*/
65		public function __construct(
66		AccountProxyInterface $currentUser,
67		SchemaPluginManager $pluginManager,
68		QueryProviderInterface $queryProvider
69		) {
70		$this->currentUser = $currentUser;
71		$this->pluginManager = $pluginManager;
72		$this->queryProvider = $queryProvider;
73		}
74
75		/**
76		* Processes one or multiple graphql operations.
77		*
78		* @param string $schema
79		* The plugin id of the schema to use.
80		* @param \GraphQL\Server\OperationParams\|\GraphQL\Server\OperationParams[] $params
81		* The graphql operation(s) to execute.
82		* @param array $globals
83		* The query context.
84		*
85		* @return \Drupal\graphql\GraphQL\Execution\QueryResult\|\Drupal\graphql\GraphQL\Execution\QueryResult[]
86		* The query result.
87		*
88		*/
89		public function processQuery($schema, $params, array $globals = []) {
90		// Load the plugin from the schema manager.
91		$plugin = $this->pluginManager->createInstance($schema);
92		$schema = $plugin->getSchema();
93
94		// If the current user has appropriate permissions, allow to bypass
95		// the secure fields restriction.
96		$globals['bypass field security'] = $this->currentUser->hasPermission('bypass graphql field security');
97
98		// Create the server config.
99		$config = ServerConfig::create();
100		$config->setDebug(!empty($globals['development']));
101		$config->setSchema($schema);
102		$config->setQueryBatching(TRUE);
103		$config->setContext(function () use ($globals) {
104		// Each document (e.g. in a batch query) gets its own resolve context but
105		// the global parameters are shared. This allows us to collect the cache
106		// metadata and contextual values (e.g. inheritance for language) for each
107		// query separately.
108		return new ResolveContext($globals);
109		});
110
111		$config->setValidationRules(function (OperationParams $params, DocumentNode $document, $operation) {
		0 ignored issues – show Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$document` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$operation` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
112		if (isset($params->queryId)) {
113		// Assume that pre-parsed documents are already validated. This allows
114		// us to store pre-validated query documents e.g. for persisted queries
115		// effectively improving performance by skipping run-time validation.
116		return [];
117		}
118
119		return array_values(DocumentValidator::allRules());
120		});
121
122		$config->setPersistentQueryLoader(function ($id, OperationParams $params) {
123		if ($query = $this->queryProvider->getQuery($id, $params)) {
124		return $query;
125		}
126
127		throw new RequestError(sprintf("Failed to load query map for id '%s'.", $id));
128		});
129
130		if (is_array($params)) {
131		return $this->executeBatch($config, $params);
132		}
133
134		return $this->executeSingle($config, $params);
135		}
136
137		/**
138		* @param \GraphQL\Server\ServerConfig $config
139		* @param \GraphQL\Server\OperationParams $params
140		*
141		* @return mixed
142		*/
143		public function executeSingle(ServerConfig $config, OperationParams $params) {
144		$adapter = new SyncPromiseAdapter();
145		$result = $this->executeOperation($adapter, $config, $params, FALSE);
146		return $adapter->wait($result);
147		}
148
149		/**
150		* @param \GraphQL\Server\ServerConfig $config
151		* @param array $params
152		*
153		* @return mixed
154		*/
155		public function executeBatch(ServerConfig $config, array $params) {
156		$adapter = new SyncPromiseAdapter();
157		$result = array_map(function ($params) use ($adapter, $config) {
158		return $this->executeOperation($adapter, $config, $params, TRUE);
159		}, $params);
160
161		$result = $adapter->all($result);
162		return $adapter->wait($result);
163		}
164
165		/**
166		* @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
167		* @param \GraphQL\Server\ServerConfig $config
168		* @param \GraphQL\Server\OperationParams $params
169		* @param bool $batching
170		*
171		* @return \GraphQL\Executor\Promise\Promise
172		*/
173		protected function executeOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, $batching = FALSE) {
174		try {
175		if (!$config->getSchema()) {
176		throw new \LogicException('Missing schema for query execution.');
177		}
178
179		if ($batching && !$config->getQueryBatching()) {
180		throw new RequestError('Batched queries are not supported by this server.');
181		}
182
183		if ($errors = (new Helper())->validateOperationParams($params)) {
184		$errors = Utils::map($errors, function (RequestError $err) {
185		return Error::createLocatedError($err, NULL, NULL);
186		});
187
188		return $adapter->createFulfilled(new QueryResult(NULL, $errors));
189		}
190
191		$schema = $config->getSchema();
192		$variables = $params->variables;
193		$operation = $params->operation;
194		$document = $params->queryId ? $this->loadPersistedQuery($config, $params) : $params->query;
195		if (!$document instanceof DocumentNode) {
196		$document = Parser::parse($document);
197		}
198
199		// Read the operation type from the document. Subscriptions and mutations
200		// only work through POST requests. One cannot have mutations and queries
201		// in the same document, hence this check is sufficient.
202		$type = AST::getOperation($document, $operation);
203		if ($params->isReadOnly() && $type !== 'query') {
204		throw new RequestError('GET requests are only supported for query operations.');
205		}
206
207		/** @var \Drupal\graphql\GraphQL\Execution\ResolveContext $context */
208		$context = $this->resolveContextValue($config, $params, $document, $operation);
209		$complexity = $this->resolveAllowedComplexity($config, $params, $document, $operation);
210		$rules = $this->resolveValidationRules($config, $params, $document, $operation);
211		$info = new TypeInfo($schema);
212		$validation = new ValidationContext($schema, $document, $info);
213
214		// Add a special visitor to the set of validation rules which will collect
215		// all nodes and fields (all possible edges) from the document to allow
216		// for static query analysis (e.g. for calculating the query complexity or
217		// for determining the cache metadata of a query so we can perform cache
218		// lookups).
219		$visitors = array_values(array_map(function (AbstractValidationRule $rule) use ($validation, $context) {
220		return $rule->getVisitor($validation);
221		}, array_merge($rules, [new QueryEdgeCollector(array_filter([
222		// Query operations can be cached. Collect static cache metadata from
223		// the document during the visitor phase.
224		$type === 'query' ? new CacheMetadataCalculator($context) : NULL,
225		$complexity !== NULL ? new ComplexityCalculator($complexity) : NULL,
		0 ignored issues – show Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The call to `ComplexityCalculator::__construct()` has too many arguments starting with `$complexity`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
226		]))])));
227
228		// Run the query visitor with the prepared validation rules and the cache
229		// metadata collector and query complexity calculator.
230		Visitor::visit($document, Visitor::visitWithTypeInfo($info, Visitor::visitInParallel($visitors)));
231
232		// If one of the validation rules found any problems, do not resolve the
233		// query and bail out early instead.
234		if ($errors = $validation->getErrors()) {
235		return $adapter->createFulfilled(new QueryResult(NULL, $errors));
236		}
237
238		// TODO: Perform a cach lookup.
239		if ($context->getCacheMaxAge() !== 0) {
240		$hash = hash('sha256', $this->serializeDocument($document));
		0 ignored issues – show Unused Code introduced 2018-02-25 10:28 UTC by Report Bug Copy Issue Report `$hash` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
241		}
242
243		$resolver = $config->getFieldResolver();
244		$root = $this->resolveRootValue($config, $params, $document, $operation);
245		$promise = Executor::promiseToExecute(
246		$adapter,
247		$schema,
248		$document,
249		$root,
250		$context,
251		$variables,
252		$operation,
253		$resolver
254		);
255
256		return $promise->then(function (ExecutionResult $result) use ($context) {
257		$metadata = (new CacheableMetadata())->addCacheableDependency($context);
258		return new QueryResult($result->data, $result->errors, $result->extensions, $metadata);
259		});
260		}
261		catch (RequestError $exception) {
262		$result = $adapter->createFulfilled(new QueryResult(NULL, [Error::createLocatedError($exception)]));
263		}
264		catch (Error $exception) {
265		$result = $adapter->createFulfilled(new QueryResult(NULL, [$exception]));
266		}
267
268		return $result->then(function(QueryResult $result) use ($config) {
269		if ($config->getErrorsHandler()) {
270		$result->setErrorsHandler($config->getErrorsHandler());
271		}
272
273		if ($config->getErrorFormatter() \|\| $config->getDebug()) {
274		$result->setErrorFormatter(FormattedError::prepareFormatter($config->getErrorFormatter(), $config->getDebug()));
275		}
276
277		return $result;
278		});
279		}
280
281		/**
282		* @param \GraphQL\Server\ServerConfig $config
283		* @param \GraphQL\Server\OperationParams $params
284		* @param \GraphQL\Language\AST\DocumentNode $document
285		* @param $operation
286		*
287		* @return mixed
288		*/
289	View Code Duplication	protected function resolveRootValue(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {
		0 ignored issues – show Duplication introduced 2018-02-19 09:47 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
290		$root = $config->getRootValue();
291		if (is_callable($root)) {
292		$root = $root($params, $document, $operation);
293		}
294
295		return $root;
296		}
297
298		/**
299		* @param \GraphQL\Server\ServerConfig $config
300		* @param \GraphQL\Server\OperationParams $params
301		* @param \GraphQL\Language\AST\DocumentNode $document
302		* @param $operation
303		*
304		* @return mixed
305		*/
306	View Code Duplication	protected function resolveContextValue(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {
		0 ignored issues – show Duplication introduced 2018-02-19 09:47 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
307		$context = $config->getContext();
308		if (is_callable($context)) {
309		$context = $context($params, $document, $operation);
310		}
311
312		return $context;
313		}
314
315		/**
316		* @param \GraphQL\Server\ServerConfig $config
317		* @param \GraphQL\Server\OperationParams $params
318		* @param \GraphQL\Language\AST\DocumentNode $document
319		* @param $operation
320		*
321		* @return array
322		*/
323		protected function resolveValidationRules(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {
324		// Allow customizing validation rules per operation:
325		$rules = $config->getValidationRules();
326		if (is_callable($rules)) {
327		$rules = $rules($params, $document, $operation);
328		if (!is_array($rules)) {
329		throw new \LogicException(sprintf("Expecting validation rules to be array or callable returning array, but got: %s", Utils::printSafe($rules)));
330		}
331		}
332
333		return $rules;
334		}
335
336		/**
337		* @param \GraphQL\Server\ServerConfig $config
338		* @param \GraphQL\Server\OperationParams $params
339		* @param \GraphQL\Language\AST\DocumentNode $document
340		* @param $operation
341		*
342		* @return int\|null
343		*/
344		protected function resolveAllowedComplexity(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {
		0 ignored issues – show Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$config` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$params` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$document` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2018-02-24 19:21 UTC by Report Bug Copy Issue Report The parameter `$operation` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
345		return NULL;
346		}
347
348		/**
349		* @param \GraphQL\Server\ServerConfig $config
350		* @param \GraphQL\Server\OperationParams $params
351		*
352		* @return mixed
353		* @throws \GraphQL\Server\RequestError
354		*/
355		protected function loadPersistedQuery(ServerConfig $config, OperationParams $params) {
356		if (!$loader = $config->getPersistentQueryLoader()) {
357		throw new RequestError('Persisted queries are not supported by this server.');
358		}
359
360		$source = $loader($params->queryId, $params);
361		if (!is_string($source) && !$source instanceof DocumentNode) {
362		throw new \LogicException(sprintf('The persisted query loader must return query string or instance of %s but got: %s.', DocumentNode::class, Utils::printSafe($source)));
363		}
364
365		return $source;
366		}
367
368		/**
369		* @param \GraphQL\Language\AST\DocumentNode $document
370		*
371		* @return array
372		*/
373		protected function serializeDocument(DocumentNode $document) {
374		return $this->sanitizeRecursive(AST::toArray($document));
375		}
376
377		/**
378		* @param array $item
379		*
380		* @return array
381		*/
382		protected function sanitizeRecursive(array $item) {
383		unset($item['loc']);
384
385		foreach ($item as &$value) {
386		if (is_array($value)) {
387		$value = $this->sanitizeRecursive($value);
388		}
389		}
390
391		return $item;
392		}
393
394		}
395

drupal-graphql / graphql

Pull Request — 8.x-3.x (#525)

QueryProcessor::loadPersistedQuery() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like