QueryProcessor::getCacheIdentifier() - Code Metrics - Inspection of "Implement query reducers." - drupal-graphql/graphql - Measure and Improve Code Quality continuously with Scrutinizer

Completed

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

by Sebastian

created 2018-02-14 17:25 UTC

QueryProcessor::getCacheIdentifier() A

↳ Parent: QueryProcessor

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Drupal\graphql\GraphQL\Execution;

use Drupal\Core\Cache\Cache;
use Drupal\Core\Cache\CacheableDependencyInterface;
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\Execution\Visitor\CacheMetadataVisitor;
use Drupal\graphql\GraphQL\Execution\Visitor\MaxComplexityVisitor;
use Drupal\graphql\GraphQL\Schema\SchemaLoader;
use Symfony\Component\HttpFoundation\RequestStack;
use Youshido\GraphQL\Exception\ResolveException;

class QueryProcessor {

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

  /**
   * The schema loader service.
   *
   * @var \Drupal\graphql\GraphQL\Schema\SchemaLoader
   */
  protected $schemaLoader;

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

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

  /**
   * The request stack.
   *
   * @var \Symfony\Component\HttpFoundation\RequestStack
   */
  protected $requestStack;

  /**
   * QueryProcessor constructor.
   *
   * @param \Drupal\graphql\GraphQL\Schema\SchemaLoader $schemaLoader
   *   The schema loader service.
   * @param \Drupal\Core\Session\AccountProxyInterface $currentUser
   *   The current user.
   * @param \Symfony\Component\HttpFoundation\RequestStack $requestStack
   * @param \Drupal\Core\Cache\Context\CacheContextsManager $contextsManager
   *   The cache contexts manager service.
   * @param \Drupal\Core\Cache\CacheBackendInterface $cacheBackend
   *   The cache backend for caching response.
   */
  public function __construct(
    SchemaLoader $schemaLoader,
    AccountProxyInterface $currentUser,
    RequestStack $requestStack,
    CacheBackendInterface $cacheBackend,
    CacheContextsManager $contextsManager
  ) {
    $this->currentUser = $currentUser;
    $this->schemaLoader = $schemaLoader;
    $this->requestStack = $requestStack;
    $this->cacheBackend = $cacheBackend;
    $this->contextsManager = $contextsManager;
  }

  /**
   * Processes a graphql query.
   *
   * @param string $id
   *   The name of the schema to process the query against.
   * @param string $query
   *   The GraphQL query.
   * @param array $variables
   *   The query variables.
   * @param bool $useCache
   *   Whether to use caching.
   * @param int|null $maxComplexity
   *   The maximum complexity of the query or NULL if any complexity is allowed.
   * @param bool $bypassSecurity
   *   Bypass field security
   *
   * @return \Drupal\graphql\GraphQL\Execution\QueryResult .
   *   The query result.
   */
  public function processQuery($id, $query, array $variables = [], $useCache = TRUE, $maxComplexity = NULL, $bypassSecurity = FALSE) {
    if (!$schema = $this->schemaLoader->getSchema($id)) {
      throw new \InvalidArgumentException(sprintf('Could not load schema %s', [$id]));
    }

    // The processor isolates the parsing and execution of the query.
    $processor = new Processor($schema, $query, $variables);
    $context = $processor->getExecutionContext();
    $container = $context->getContainer();

    // Set up some parameters in the container.
    $secure = $bypassSecurity || $this->currentUser->hasPermission('bypass graphql field security');
    $metadata = new CacheableMetadata();
    $container->set('secure', $secure);
    $container->set('metadata', $metadata);

    $visitor = new CacheMetadataVisitor();
    /** @var \Drupal\Core\Cache\RefinableCacheableDependencyInterface $metadata */
    $metadata = $processor->reduceRequest($visitor, function ($result) {
      $metadata = new CacheableMetadata();
      $metadata->addCacheableDependency($result);
      // TODO: Use a cache context that includes the AST instead of the raw values.
      $metadata->addCacheContexts(['gql']);
      $metadata->addCacheTags(['graphql_response']);

      return $metadata;
    }) ?: new CacheableMetadata();

    // The cache identifier will later be re-used for writing the cache entry.
    $cid = $this->getCacheIdentifier($metadata);
    if (!empty($useCache) && $metadata->getCacheMaxAge() !== 0) {
      if (($cache = $this->cacheBackend->get($cid)) && $result = $cache->data) {
        return $result;
      }
    }

    if (!empty($maxComplexity)) {
      $visitor = new MaxComplexityVisitor();
      $processor->reduceRequest($visitor, function ($result) use ($maxComplexity) {
        if ($result > $maxComplexity) {
          throw new ResolveException('Maximum complexity exceeded.');
        }
      });
    }

    // Retrieve the result from the processor.
    $data = $processor->resolveRequest();

    // Add collected cache metadata from the query processor.
    if ($container->has('metadata') && ($collected = $container->get('metadata'))) {
      if ($collected instanceof CacheableDependencyInterface) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
        $metadata->addCacheableDependency($collected);
      }
    }

    // If we encountered any errors, do not cache anything.
    if ($context->hasErrors()) {
      $metadata->setCacheMaxAge(0);
    }

    // Build the result object. The keys are only set if they contain data.
    $result = new QueryResult(array_filter([
      'data' => $data,
      'errors' => $processor->getExecutionContext()->getErrorsArray(),
    ]), $metadata);

    // Write the query result into the cache if the cache metadata permits.
    if (!empty($useCache) && $metadata->getCacheMaxAge() !== 0) {
      $tags = $metadata->getCacheTags();
      $expire = $this->maxAgeToExpire($metadata->getCacheMaxAge());

      // The cache identifier for the cache entry is built based on the
      // previously extracted cache contexts from the query visitor. That
      // means, that dynamically returned cache contexts have no effect.
      $this->cacheBackend->set($cid, $result, $expire, $tags);
    }

    return $result;
  }

  /**
   * Maps a max age value to an "expire" value for the Cache API.
   *
   * @param int $maxAge
   *   A max age value.
   *
   * @return int
   *   A corresponding "expire" value.
   *
   * @see \Drupal\Core\Cache\CacheBackendInterface::set()
   */
  protected function maxAgeToExpire($maxAge) {

    if ($maxAge === Cache::PERMANENT) {
      return Cache::PERMANENT;
    }

    return (int) $this->requestStack->getMasterRequest()->server->get('REQUEST_TIME') + $maxAge;
  }

  /**
   * Generates a cache identifier for the passed cache contexts.
   *
   * @param \Drupal\Core\Cache\CacheableDependencyInterface $metadata
   *   Optional array of cache context tokens.
   *
   * @return string The generated cache identifier.
   *   The generated cache identifier.
   */
  protected function getCacheIdentifier(CacheableDependencyInterface $metadata) {
    $tokens = $metadata->getCacheContexts();
    $keys = $this->contextsManager->convertTokensToKeys($tokens)->getKeys();
    return implode(':', array_merge(['graphql'], array_values($keys)));
  }

}


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

QueryProcessor::getCacheIdentifier() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1		<?php
2
3		namespace Drupal\graphql\GraphQL\Execution;
4
5		use Drupal\Core\Cache\Cache;
6		use Drupal\Core\Cache\CacheableDependencyInterface;
7		use Drupal\Core\Cache\CacheableMetadata;
8		use Drupal\Core\Cache\CacheBackendInterface;
9		use Drupal\Core\Cache\Context\CacheContextsManager;
10		use Drupal\Core\Session\AccountProxyInterface;
11		use Drupal\graphql\GraphQL\Execution\Visitor\CacheMetadataVisitor;
12		use Drupal\graphql\GraphQL\Execution\Visitor\MaxComplexityVisitor;
13		use Drupal\graphql\GraphQL\Schema\SchemaLoader;
14		use Symfony\Component\HttpFoundation\RequestStack;
15		use Youshido\GraphQL\Exception\ResolveException;
16
17		class QueryProcessor {
18
19		/**
20		* The current user account.
21		*
22		* @var \Drupal\Core\Session\AccountProxyInterface
23		*/
24		protected $currentUser;
25
26		/**
27		* The schema loader service.
28		*
29		* @var \Drupal\graphql\GraphQL\Schema\SchemaLoader
30		*/
31		protected $schemaLoader;
32
33		/**
34		* The cache contexts manager service.
35		*
36		* @var \Drupal\Core\Cache\Context\CacheContextsManager
37		*/
38		protected $contextsManager;
39
40		/**
41		* The cache backend for caching responses.
42		*
43		* @var \Drupal\Core\Cache\CacheBackendInterface
44		*/
45		protected $cacheBackend;
46
47		/**
48		* The request stack.
49		*
50		* @var \Symfony\Component\HttpFoundation\RequestStack
51		*/
52		protected $requestStack;
53
54		/**
55		* QueryProcessor constructor.
56		*
57		* @param \Drupal\graphql\GraphQL\Schema\SchemaLoader $schemaLoader
58		* The schema loader service.
59		* @param \Drupal\Core\Session\AccountProxyInterface $currentUser
60		* The current user.
61		* @param \Symfony\Component\HttpFoundation\RequestStack $requestStack
62		* @param \Drupal\Core\Cache\Context\CacheContextsManager $contextsManager
63		* The cache contexts manager service.
64		* @param \Drupal\Core\Cache\CacheBackendInterface $cacheBackend
65		* The cache backend for caching response.
66		*/
67		public function __construct(
68		SchemaLoader $schemaLoader,
69		AccountProxyInterface $currentUser,
70		RequestStack $requestStack,
71		CacheBackendInterface $cacheBackend,
72		CacheContextsManager $contextsManager
73		) {
74		$this->currentUser = $currentUser;
75		$this->schemaLoader = $schemaLoader;
76		$this->requestStack = $requestStack;
77		$this->cacheBackend = $cacheBackend;
78		$this->contextsManager = $contextsManager;
79		}
80
81		/**
82		* Processes a graphql query.
83		*
84		* @param string $id
85		* The name of the schema to process the query against.
86		* @param string $query
87		* The GraphQL query.
88		* @param array $variables
89		* The query variables.
90		* @param bool $useCache
91		* Whether to use caching.
92		* @param int\|null $maxComplexity
93		* The maximum complexity of the query or NULL if any complexity is allowed.
94		* @param bool $bypassSecurity
95		* Bypass field security
96		*
97		* @return \Drupal\graphql\GraphQL\Execution\QueryResult .
98		* The query result.
99		*/
100		public function processQuery($id, $query, array $variables = [], $useCache = TRUE, $maxComplexity = NULL, $bypassSecurity = FALSE) {
101		if (!$schema = $this->schemaLoader->getSchema($id)) {
102		throw new \InvalidArgumentException(sprintf('Could not load schema %s', [$id]));
103		}
104
105		// The processor isolates the parsing and execution of the query.
106		$processor = new Processor($schema, $query, $variables);
107		$context = $processor->getExecutionContext();
108		$container = $context->getContainer();
109
110		// Set up some parameters in the container.
111		$secure = $bypassSecurity \|\| $this->currentUser->hasPermission('bypass graphql field security');
112		$metadata = new CacheableMetadata();
113		$container->set('secure', $secure);
114		$container->set('metadata', $metadata);
115
116		$visitor = new CacheMetadataVisitor();
117		/** @var \Drupal\Core\Cache\RefinableCacheableDependencyInterface $metadata */
118		$metadata = $processor->reduceRequest($visitor, function ($result) {
119		$metadata = new CacheableMetadata();
120		$metadata->addCacheableDependency($result);
121		// TODO: Use a cache context that includes the AST instead of the raw values.
122		$metadata->addCacheContexts(['gql']);
123		$metadata->addCacheTags(['graphql_response']);
124
125		return $metadata;
126		}) ?: new CacheableMetadata();
127
128		// The cache identifier will later be re-used for writing the cache entry.
129		$cid = $this->getCacheIdentifier($metadata);
130		if (!empty($useCache) && $metadata->getCacheMaxAge() !== 0) {
131		if (($cache = $this->cacheBackend->get($cid)) && $result = $cache->data) {
132		return $result;
133		}
134		}
135
136		if (!empty($maxComplexity)) {
137		$visitor = new MaxComplexityVisitor();
138		$processor->reduceRequest($visitor, function ($result) use ($maxComplexity) {
139		if ($result > $maxComplexity) {
140		throw new ResolveException('Maximum complexity exceeded.');
141		}
142		});
143		}
144
145		// Retrieve the result from the processor.
146		$data = $processor->resolveRequest();
147
148		// Add collected cache metadata from the query processor.
149		if ($container->has('metadata') && ($collected = $container->get('metadata'))) {
150		if ($collected instanceof CacheableDependencyInterface) {
		0 ignored issues – show Bug introduced 2018-02-13 23:10 UTC by Report Bug Copy Issue Report The class `Drupal\Core\Cache\CacheableDependencyInterface` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
151		$metadata->addCacheableDependency($collected);
152		}
153		}
154
155		// If we encountered any errors, do not cache anything.
156		if ($context->hasErrors()) {
157		$metadata->setCacheMaxAge(0);
158		}
159
160		// Build the result object. The keys are only set if they contain data.
161		$result = new QueryResult(array_filter([
162		'data' => $data,
163		'errors' => $processor->getExecutionContext()->getErrorsArray(),
164		]), $metadata);
165
166		// Write the query result into the cache if the cache metadata permits.
167		if (!empty($useCache) && $metadata->getCacheMaxAge() !== 0) {
168		$tags = $metadata->getCacheTags();
169		$expire = $this->maxAgeToExpire($metadata->getCacheMaxAge());
170
171		// The cache identifier for the cache entry is built based on the
172		// previously extracted cache contexts from the query visitor. That
173		// means, that dynamically returned cache contexts have no effect.
174		$this->cacheBackend->set($cid, $result, $expire, $tags);
175		}
176
177		return $result;
178		}
179
180		/**
181		* Maps a max age value to an "expire" value for the Cache API.
182		*
183		* @param int $maxAge
184		* A max age value.
185		*
186		* @return int
187		* A corresponding "expire" value.
188		*
189		* @see \Drupal\Core\Cache\CacheBackendInterface::set()
190		*/
191	View Code Duplication	protected function maxAgeToExpire($maxAge) {
		0 ignored issues – show Duplication introduced 2018-02-14 16:13 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...
192		if ($maxAge === Cache::PERMANENT) {
193		return Cache::PERMANENT;
194		}
195
196		return (int) $this->requestStack->getMasterRequest()->server->get('REQUEST_TIME') + $maxAge;
197		}
198
199		/**
200		* Generates a cache identifier for the passed cache contexts.
201		*
202		* @param \Drupal\Core\Cache\CacheableDependencyInterface $metadata
203		* Optional array of cache context tokens.
204		*
205		* @return string The generated cache identifier.
206		* The generated cache identifier.
207		*/
208		protected function getCacheIdentifier(CacheableDependencyInterface $metadata) {
209		$tokens = $metadata->getCacheContexts();
210		$keys = $this->contextsManager->convertTokensToKeys($tokens)->getKeys();
211		return implode(':', array_merge(['graphql'], array_values($keys)));
212		}
213
214		}
215

drupal-graphql / graphql

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

QueryProcessor::getCacheIdentifier() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like