QueryProcessor::executeUncachableOperation() - 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-03-02 21:29 UTC

QueryProcessor::executeUncachableOperation() A

↳ Parent: QueryProcessor

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	5
nc	1
nop	4
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0

<?php

namespace Drupal\graphql\GraphQL\Execution;

use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Cache\CacheBackendInterface;
use Drupal\Core\Cache\Context\CacheContextsManager;
use Drupal\Core\Session\AccountProxyInterface;
use Drupal\graphql\GraphQL\Visitors\CacheContextsCollector;
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;

  /**
   * The cache backend for caching query results.
   *
   * @var \Drupal\Core\Cache\CacheBackendInterface
   */
  protected $cacheBackend;

  /**
   * The cache contexts manager service.
   *
   * @var \Drupal\Core\Cache\Context\CacheContextsManager
   */
  protected $contextsManager;

  /**
   * Processor constructor.
   *
   * @param \Drupal\Core\Session\AccountProxyInterface $currentUser
   *   The current user.
   * @param \Drupal\Core\Cache\Context\CacheContextsManager $contextsManager
   *   The cache contexts manager service.
   * @param \Drupal\graphql\Plugin\SchemaPluginManager $pluginManager
   *   The schema plugin manager.
   * @param \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface $queryProvider
   *   The query provider service.
   * @param \Drupal\Core\Cache\CacheBackendInterface $cacheBackend
   *   The cache backend for caching query results.
   */
  public function __construct(
    AccountProxyInterface $currentUser,
    CacheContextsManager $contextsManager,
    SchemaPluginManager $pluginManager,
    QueryProviderInterface $queryProvider,
    CacheBackendInterface $cacheBackend
  ) {
    $this->currentUser = $currentUser;
    $this->contextsManager = $contextsManager;
    $this->pluginManager = $pluginManager;
    $this->queryProvider = $queryProvider;
    $this->cacheBackend = $cacheBackend;
  }

  /**
   * 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::defaultRules());
    });

    $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->executeOperationWithReporting($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->executeOperationWithReporting($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 executeOperationWithReporting(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, $batching = FALSE) {
    $result = $this->executeOperation($adapter, $config, $params, $batching);

    // Format and print errors.
    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\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 = $this->validateOperationParams($params)) {
        return $adapter->createFulfilled(new QueryResult(NULL, $errors));
      }

      $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.
      $operation = $params->operation;
      $type = AST::getOperation($document, $operation);
      if ($params->isReadOnly() && $type !== 'query') {
        throw new RequestError('GET requests are only supported for query operations.');
      }

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

      // Only queries can be cached (mutations and subscriptions can't).
      if ($type === 'query') {
        return $this->executeCacheableOperation($adapter, $config, $params, $document);
      }

      return $this->executeUncachableOperation($adapter, $config, $params, $document);
    }
    catch (RequestError $exception) {
      return $adapter->createFulfilled(new QueryResult(NULL, [Error::createLocatedError($exception)]));
    }
    catch (Error $exception) {
      return $adapter->createFulfilled(new QueryResult(NULL, [$exception]));
    }
  }

  /**
   * @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   *
   * @return \GraphQL\Executor\Promise\Promise|mixed
   */
  protected function executeCacheableOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, DocumentNode $document) {
    $schema = $config->getSchema();

    // Collect cache contexts from the query document.
    $contexts = [];
    $info = new TypeInfo($schema);
    $visitor = (new CacheContextsCollector())->getVisitor($info, $contexts);
    Visitor::visit($document, Visitor::visitWithTypeInfo($info, $visitor));

    // Generate a cache identifier from the collected contexts.
    $metadata = (new CacheableMetadata())->addCacheContexts($contexts);
    $cid = $this->cacheIdentifier($params, $document, $metadata);
    if (($cache = $this->cacheBackend->get($cid)) && $result = $cache->data) {
      return $adapter->createFulfilled($result);
    }

    $result = $this->doExecuteOperation($adapter, $config, $params, $document);
    return $result->then(function (QueryResult $result) use ($cid, $metadata) {
      if ($missing = array_diff($result->getCacheContexts(), $metadata->getCacheContexts())) {
        throw new \LogicException(sprintf(
          'The query result yielded cache contexts (%s) that were not part of the static query analysis.',
          implode(', ', $missing)
        ));
      }

      // Add the statically collected cache contexts and the global default
      // cache tag (useful for clearing all cached responses) to the result.
      $result->addCacheableDependency($metadata);
      $result->addCacheTags(['graphql_response']);

      // Write this query into the cache if it is cacheable.
      if ($result->getCacheMaxAge() !== 0) {
        $this->cacheBackend->set($cid, $result, $result->getCacheMaxAge(), $result->getCacheTags());
      }

      return $result;
    });
  }

  /**
   * @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   *
   * @return \GraphQL\Executor\Promise\Promise
   */
  protected function executeUncachableOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, DocumentNode $document) {
    $result = $this->doExecuteOperation($adapter, $config, $params, $document);
    return $result->then(function (QueryResult $result) {
      // Mark the query result as uncacheable.
      $result->mergeCacheMaxAge(0);
      return $result;
    });
  }

  /**
   * @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   *
   * @return \GraphQL\Executor\Promise\Promise
   */
  protected function doExecuteOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, DocumentNode $document) {
    $operation = $params->operation;
    $variables = $params->variables;
    $context = $this->resolveContextValue($config, $params, $document, $operation);
    $root = $this->resolveRootValue($config, $params, $document, $operation);
    $resolver = $config->getFieldResolver();
    $schema = $config->getSchema();

    $promise = Executor::promiseToExecute(
      $adapter,
      $schema,
      $document,
      $root,
      $context,
      $variables,
      $operation,
      $resolver
    );

    return $promise->then(function (ExecutionResult $result) use ($context) {
      // Add the collected cache metadata to the result.
      $metadata = (new CacheableMetadata())->addCacheableDependency($context);
      $output = new QueryResult($result->data, $result->errors, $result->extensions, $metadata);

      // Do not cache in development mode.
      if ($context->getGlobal('development')) {
        $metadata->setCacheMaxAge(0);
      }

      return $output;
    });
  }

  /**
   * @param \GraphQL\Server\OperationParams $params
   *
   * @return array
   */
  protected function validateOperationParams(OperationParams $params) {
    $errors = (new Helper())->validateOperationParams($params);
    return array_map(function (RequestError $error) {
      return Error::createLocatedError($error, NULL, NULL);
    }, $errors);
  }

  /**
   * @param \GraphQL\Server\ServerConfig $config
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   *
   * @return \GraphQL\Error\Error[]
   */
  protected function validateOperation(ServerConfig $config, OperationParams $params, DocumentNode $document) {
    $operation = $params->operation;
    // Skip validation if there are no validation rules to be applied.
    if (!$rules = $this->resolveValidationRules($config, $params, $document, $operation)) {
      return [];
    }

    $schema = $config->getSchema();
    $info = new TypeInfo($schema);
    $validation = new ValidationContext($schema, $document, $info);
    $visitors = array_values(array_map(function (AbstractValidationRule $rule) use ($validation) {
      return $rule($validation);
    }, $rules));

    // 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)));

    // Return any possible errors collected during validation.
    return $validation->getErrors();
  }

  /**
   * @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
   *
   * @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;
  }

  /**
   * @param \GraphQL\Server\OperationParams $params
   * @param \GraphQL\Language\AST\DocumentNode $document
   * @param \Drupal\Core\Cache\CacheableMetadata $metadata
   *
   * @return string
   */
  protected function cacheIdentifier(OperationParams $params, DocumentNode $document, CacheableMetadata $metadata) {
    $contexts = $metadata->getCacheContexts();
    $keys = $this->contextsManager->convertTokensToKeys($contexts)->getKeys();

    // Sorting the variables will cause fewer cache vectors.
    $variables = $params->variables ?: [];
    ksort($variables);

    // Prepend the hash of the serialized document to the cache contexts.
    $hash = hash('sha256', json_encode([
      'query' => $this->serializeDocument($document),
      'variables' => $variables,
    ]));

    return implode(':', array_values(array_merge([$hash], $keys)));
  }
}


1		<?php
2
3		namespace Drupal\graphql\GraphQL\Execution;
4
5		use Drupal\Core\Cache\CacheableMetadata;
6		use Drupal\Core\Cache\CacheBackendInterface;
7		use Drupal\Core\Cache\Context\CacheContextsManager;
8		use Drupal\Core\Session\AccountProxyInterface;
9		use Drupal\graphql\GraphQL\Visitors\CacheContextsCollector;
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		* The cache backend for caching query results.
57		*
58		* @var \Drupal\Core\Cache\CacheBackendInterface
59		*/
60		protected $cacheBackend;
61
62		/**
63		* The cache contexts manager service.
64		*
65		* @var \Drupal\Core\Cache\Context\CacheContextsManager
66		*/
67		protected $contextsManager;
68
69		/**
70		* Processor constructor.
71		*
72		* @param \Drupal\Core\Session\AccountProxyInterface $currentUser
73		* The current user.
74		* @param \Drupal\Core\Cache\Context\CacheContextsManager $contextsManager
75		* The cache contexts manager service.
76		* @param \Drupal\graphql\Plugin\SchemaPluginManager $pluginManager
77		* The schema plugin manager.
78		* @param \Drupal\graphql\GraphQL\QueryProvider\QueryProviderInterface $queryProvider
79		* The query provider service.
80		* @param \Drupal\Core\Cache\CacheBackendInterface $cacheBackend
81		* The cache backend for caching query results.
82		*/
83		public function __construct(
84		AccountProxyInterface $currentUser,
85		CacheContextsManager $contextsManager,
86		SchemaPluginManager $pluginManager,
87		QueryProviderInterface $queryProvider,
88		CacheBackendInterface $cacheBackend
89		) {
90		$this->currentUser = $currentUser;
91		$this->contextsManager = $contextsManager;
92		$this->pluginManager = $pluginManager;
93		$this->queryProvider = $queryProvider;
94		$this->cacheBackend = $cacheBackend;
95		}
96
97		/**
98		* Processes one or multiple graphql operations.
99		*
100		* @param string $schema
101		* The plugin id of the schema to use.
102		* @param \GraphQL\Server\OperationParams\|\GraphQL\Server\OperationParams[] $params
103		* The graphql operation(s) to execute.
104		* @param array $globals
105		* The query context.
106		*
107		* @return \Drupal\graphql\GraphQL\Execution\QueryResult\|\Drupal\graphql\GraphQL\Execution\QueryResult[]
108		* The query result.
109		*
110		*/
111		public function processQuery($schema, $params, array $globals = []) {
112		// Load the plugin from the schema manager.
113		$plugin = $this->pluginManager->createInstance($schema);
114		$schema = $plugin->getSchema();
115
116		// If the current user has appropriate permissions, allow to bypass
117		// the secure fields restriction.
118		$globals['bypass field security'] = $this->currentUser->hasPermission('bypass graphql field security');
119
120		// Create the server config.
121		$config = ServerConfig::create();
122		$config->setDebug(!empty($globals['development']));
123		$config->setSchema($schema);
124		$config->setQueryBatching(TRUE);
125		$config->setContext(function () use ($globals) {
126		// Each document (e.g. in a batch query) gets its own resolve context but
127		// the global parameters are shared. This allows us to collect the cache
128		// metadata and contextual values (e.g. inheritance for language) for each
129		// query separately.
130		return new ResolveContext($globals);
131		});
132
133		$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...
134		if (isset($params->queryId)) {
135		// Assume that pre-parsed documents are already validated. This allows
136		// us to store pre-validated query documents e.g. for persisted queries
137		// effectively improving performance by skipping run-time validation.
138		return [];
139		}
140
141		return array_values(DocumentValidator::defaultRules());
142		});
143
144		$config->setPersistentQueryLoader(function ($id, OperationParams $params) {
145		if ($query = $this->queryProvider->getQuery($id, $params)) {
146		return $query;
147		}
148
149		throw new RequestError(sprintf("Failed to load query map for id '%s'.", $id));
150		});
151
152		if (is_array($params)) {
153		return $this->executeBatch($config, $params);
154		}
155
156		return $this->executeSingle($config, $params);
157		}
158
159		/**
160		* @param \GraphQL\Server\ServerConfig $config
161		* @param \GraphQL\Server\OperationParams $params
162		*
163		* @return mixed
164		*/
165		public function executeSingle(ServerConfig $config, OperationParams $params) {
166		$adapter = new SyncPromiseAdapter();
167		$result = $this->executeOperationWithReporting($adapter, $config, $params, FALSE);
168		return $adapter->wait($result);
169		}
170
171		/**
172		* @param \GraphQL\Server\ServerConfig $config
173		* @param array $params
174		*
175		* @return mixed
176		*/
177		public function executeBatch(ServerConfig $config, array $params) {
178		$adapter = new SyncPromiseAdapter();
179		$result = array_map(function ($params) use ($adapter, $config) {
180		return $this->executeOperationWithReporting($adapter, $config, $params, TRUE);
181		}, $params);
182
183		$result = $adapter->all($result);
184		return $adapter->wait($result);
185		}
186
187		/**
188		* @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
189		* @param \GraphQL\Server\ServerConfig $config
190		* @param \GraphQL\Server\OperationParams $params
191		* @param bool $batching
192		*
193		* @return \GraphQL\Executor\Promise\Promise
194		*/
195		protected function executeOperationWithReporting(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, $batching = FALSE) {
196		$result = $this->executeOperation($adapter, $config, $params, $batching);
197
198		// Format and print errors.
199		return $result->then(function(QueryResult $result) use ($config) {
200		if ($config->getErrorsHandler()) {
201		$result->setErrorsHandler($config->getErrorsHandler());
202		}
203
204		if ($config->getErrorFormatter() \|\| $config->getDebug()) {
205		$result->setErrorFormatter(FormattedError::prepareFormatter($config->getErrorFormatter(), $config->getDebug()));
206		}
207
208		return $result;
209		});
210		}
211
212		/**
213		* @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
214		* @param \GraphQL\Server\ServerConfig $config
215		* @param \GraphQL\Server\OperationParams $params
216		* @param bool $batching
217		*
218		* @return \GraphQL\Executor\Promise\Promise
219		*/
220		protected function executeOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, $batching = FALSE) {
221		try {
222		if (!$config->getSchema()) {
223		throw new \LogicException('Missing schema for query execution.');
224		}
225
226		if ($batching && !$config->getQueryBatching()) {
227		throw new RequestError('Batched queries are not supported by this server.');
228		}
229
230		if ($errors = $this->validateOperationParams($params)) {
231		return $adapter->createFulfilled(new QueryResult(NULL, $errors));
232		}
233
234		$document = $params->queryId ? $this->loadPersistedQuery($config, $params) : $params->query;
235		if (!$document instanceof DocumentNode) {
236		$document = Parser::parse($document);
237		}
238
239		// Read the operation type from the document. Subscriptions and mutations
240		// only work through POST requests. One cannot have mutations and queries
241		// in the same document, hence this check is sufficient.
242		$operation = $params->operation;
243		$type = AST::getOperation($document, $operation);
244		if ($params->isReadOnly() && $type !== 'query') {
245		throw new RequestError('GET requests are only supported for query operations.');
246		}
247
248		// If one of the validation rules found any problems, do not resolve the
249		// query and bail out early instead.
250		if ($errors = $this->validateOperation($config, $params, $document)) {
251		return $adapter->createFulfilled(new QueryResult(NULL, $errors));
252		}
253
254		// Only queries can be cached (mutations and subscriptions can't).
255		if ($type === 'query') {
256		return $this->executeCacheableOperation($adapter, $config, $params, $document);
257		}
258
259		return $this->executeUncachableOperation($adapter, $config, $params, $document);
260		}
261		catch (RequestError $exception) {
262		return $adapter->createFulfilled(new QueryResult(NULL, [Error::createLocatedError($exception)]));
263		}
264		catch (Error $exception) {
265		return $adapter->createFulfilled(new QueryResult(NULL, [$exception]));
266		}
267		}
268
269		/**
270		* @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
271		* @param \GraphQL\Server\ServerConfig $config
272		* @param \GraphQL\Server\OperationParams $params
273		* @param \GraphQL\Language\AST\DocumentNode $document
274		*
275		* @return \GraphQL\Executor\Promise\Promise\|mixed
276		*/
277		protected function executeCacheableOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, DocumentNode $document) {
278		$schema = $config->getSchema();
279
280		// Collect cache contexts from the query document.
281		$contexts = [];
282		$info = new TypeInfo($schema);
283		$visitor = (new CacheContextsCollector())->getVisitor($info, $contexts);
284		Visitor::visit($document, Visitor::visitWithTypeInfo($info, $visitor));
285
286		// Generate a cache identifier from the collected contexts.
287		$metadata = (new CacheableMetadata())->addCacheContexts($contexts);
288		$cid = $this->cacheIdentifier($params, $document, $metadata);
289		if (($cache = $this->cacheBackend->get($cid)) && $result = $cache->data) {
290		return $adapter->createFulfilled($result);
291		}
292
293		$result = $this->doExecuteOperation($adapter, $config, $params, $document);
294		return $result->then(function (QueryResult $result) use ($cid, $metadata) {
295		if ($missing = array_diff($result->getCacheContexts(), $metadata->getCacheContexts())) {
296		throw new \LogicException(sprintf(
297		'The query result yielded cache contexts (%s) that were not part of the static query analysis.',
298		implode(', ', $missing)
299		));
300		}
301
302		// Add the statically collected cache contexts and the global default
303		// cache tag (useful for clearing all cached responses) to the result.
304		$result->addCacheableDependency($metadata);
305		$result->addCacheTags(['graphql_response']);
306
307		// Write this query into the cache if it is cacheable.
308		if ($result->getCacheMaxAge() !== 0) {
309		$this->cacheBackend->set($cid, $result, $result->getCacheMaxAge(), $result->getCacheTags());
310		}
311
312		return $result;
313		});
314		}
315
316		/**
317		* @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
318		* @param \GraphQL\Server\ServerConfig $config
319		* @param \GraphQL\Server\OperationParams $params
320		* @param \GraphQL\Language\AST\DocumentNode $document
321		*
322		* @return \GraphQL\Executor\Promise\Promise
323		*/
324		protected function executeUncachableOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, DocumentNode $document) {
325		$result = $this->doExecuteOperation($adapter, $config, $params, $document);
326		return $result->then(function (QueryResult $result) {
327		// Mark the query result as uncacheable.
328		$result->mergeCacheMaxAge(0);
329		return $result;
330		});
331		}
332
333		/**
334		* @param \GraphQL\Executor\Promise\PromiseAdapter $adapter
335		* @param \GraphQL\Server\ServerConfig $config
336		* @param \GraphQL\Server\OperationParams $params
337		* @param \GraphQL\Language\AST\DocumentNode $document
338		*
339		* @return \GraphQL\Executor\Promise\Promise
340		*/
341		protected function doExecuteOperation(PromiseAdapter $adapter, ServerConfig $config, OperationParams $params, DocumentNode $document) {
342		$operation = $params->operation;
343		$variables = $params->variables;
344		$context = $this->resolveContextValue($config, $params, $document, $operation);
345		$root = $this->resolveRootValue($config, $params, $document, $operation);
346		$resolver = $config->getFieldResolver();
347		$schema = $config->getSchema();
348
349		$promise = Executor::promiseToExecute(
350		$adapter,
351		$schema,
352		$document,
353		$root,
354		$context,
355		$variables,
356		$operation,
357		$resolver
358		);
359
360		return $promise->then(function (ExecutionResult $result) use ($context) {
361		// Add the collected cache metadata to the result.
362		$metadata = (new CacheableMetadata())->addCacheableDependency($context);
363		$output = new QueryResult($result->data, $result->errors, $result->extensions, $metadata);
364
365		// Do not cache in development mode.
366		if ($context->getGlobal('development')) {
367		$metadata->setCacheMaxAge(0);
368		}
369
370		return $output;
371		});
372		}
373
374		/**
375		* @param \GraphQL\Server\OperationParams $params
376		*
377		* @return array
378		*/
379		protected function validateOperationParams(OperationParams $params) {
380		$errors = (new Helper())->validateOperationParams($params);
381		return array_map(function (RequestError $error) {
382		return Error::createLocatedError($error, NULL, NULL);
383		}, $errors);
384		}
385
386		/**
387		* @param \GraphQL\Server\ServerConfig $config
388		* @param \GraphQL\Server\OperationParams $params
389		* @param \GraphQL\Language\AST\DocumentNode $document
390		*
391		* @return \GraphQL\Error\Error[]
392		*/
393		protected function validateOperation(ServerConfig $config, OperationParams $params, DocumentNode $document) {
394		$operation = $params->operation;
395		// Skip validation if there are no validation rules to be applied.
396		if (!$rules = $this->resolveValidationRules($config, $params, $document, $operation)) {
397		return [];
398		}
399
400		$schema = $config->getSchema();
401		$info = new TypeInfo($schema);
402		$validation = new ValidationContext($schema, $document, $info);
403		$visitors = array_values(array_map(function (AbstractValidationRule $rule) use ($validation) {
404		return $rule($validation);
405		}, $rules));
406
407		// Run the query visitor with the prepared validation rules and the cache
408		// metadata collector and query complexity calculator.
409		Visitor::visit($document, Visitor::visitWithTypeInfo($info, Visitor::visitInParallel($visitors)));
410
411		// Return any possible errors collected during validation.
412		return $validation->getErrors();
413		}
414
415		/**
416		* @param \GraphQL\Server\ServerConfig $config
417		* @param \GraphQL\Server\OperationParams $params
418		* @param \GraphQL\Language\AST\DocumentNode $document
419		* @param $operation
420		*
421		* @return mixed
422		*/
423	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...
424		$root = $config->getRootValue();
425		if (is_callable($root)) {
426		$root = $root($params, $document, $operation);
427		}
428
429		return $root;
430		}
431
432		/**
433		* @param \GraphQL\Server\ServerConfig $config
434		* @param \GraphQL\Server\OperationParams $params
435		* @param \GraphQL\Language\AST\DocumentNode $document
436		* @param $operation
437		*
438		* @return mixed
439		*/
440	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...
441		$context = $config->getContext();
442		if (is_callable($context)) {
443		$context = $context($params, $document, $operation);
444		}
445
446		return $context;
447		}
448
449		/**
450		* @param \GraphQL\Server\ServerConfig $config
451		* @param \GraphQL\Server\OperationParams $params
452		* @param \GraphQL\Language\AST\DocumentNode $document
453		* @param $operation
454		*
455		* @return array
456		*/
457		protected function resolveValidationRules(ServerConfig $config, OperationParams $params, DocumentNode $document, $operation) {
458		// Allow customizing validation rules per operation:
459		$rules = $config->getValidationRules();
460		if (is_callable($rules)) {
461		$rules = $rules($params, $document, $operation);
462		if (!is_array($rules)) {
463		throw new \LogicException(sprintf("Expecting validation rules to be array or callable returning array, but got: %s", Utils::printSafe($rules)));
464		}
465		}
466
467		return $rules;
468		}
469
470		/**
471		* @param \GraphQL\Server\ServerConfig $config
472		* @param \GraphQL\Server\OperationParams $params
473		*
474		* @return mixed
475		* @throws \GraphQL\Server\RequestError
476		*/
477		protected function loadPersistedQuery(ServerConfig $config, OperationParams $params) {
478		if (!$loader = $config->getPersistentQueryLoader()) {
479		throw new RequestError('Persisted queries are not supported by this server.');
480		}
481
482		$source = $loader($params->queryId, $params);
483		if (!is_string($source) && !$source instanceof DocumentNode) {
484		throw new \LogicException(sprintf('The persisted query loader must return query string or instance of %s but got: %s.', DocumentNode::class, Utils::printSafe($source)));
485		}
486
487		return $source;
488		}
489
490		/**
491		* @param \GraphQL\Language\AST\DocumentNode $document
492		*
493		* @return array
494		*/
495		protected function serializeDocument(DocumentNode $document) {
496		return $this->sanitizeRecursive(AST::toArray($document));
497		}
498
499		/**
500		* @param array $item
501		*
502		* @return array
503		*/
504		protected function sanitizeRecursive(array $item) {
505		unset($item['loc']);
506
507		foreach ($item as &$value) {
508		if (is_array($value)) {
509		$value = $this->sanitizeRecursive($value);
510		}
511		}
512
513		return $item;
514		}
515
516		/**
517		* @param \GraphQL\Server\OperationParams $params
518		* @param \GraphQL\Language\AST\DocumentNode $document
519		* @param \Drupal\Core\Cache\CacheableMetadata $metadata
520		*
521		* @return string
522		*/
523		protected function cacheIdentifier(OperationParams $params, DocumentNode $document, CacheableMetadata $metadata) {
524		$contexts = $metadata->getCacheContexts();
525		$keys = $this->contextsManager->convertTokensToKeys($contexts)->getKeys();
526
527		// Sorting the variables will cause fewer cache vectors.
528		$variables = $params->variables ?: [];
529		ksort($variables);
530
531		// Prepend the hash of the serialized document to the cache contexts.
532		$hash = hash('sha256', json_encode([
533		'query' => $this->serializeDocument($document),
534		'variables' => $variables,
535		]));
536
537		return implode(':', array_values(array_merge([$hash], $keys)));
538		}
539		}
540

drupal-graphql / graphql

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

QueryProcessor::executeUncachableOperation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like