Drupal\graphql\Plugin\GraphQL\Fields\FieldPluginBase

Complexity

Total Complexity

24

Size/Duplication

Total Lines	204
Duplicated Lines	8.82 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefinition()	18	18	3
A	isSecure()	0	3	2
A	resolve()	0	9	4
B	resolveDeferred()	0	27	5
A	getCacheDependencies()	0	5	1
A	getCacheCollector()	0	10	4
A	commitCacheableDependency()	0	3	1
A	commitCacheContexts()	0	3	1
A	commitCacheTags()	0	3	1
A	commitCacheMaxAge()	0	3	1
A	resolveValues()	0	4	1

<?php

namespace Drupal\graphql\Plugin\GraphQL\Fields;

use Drupal\Component\Plugin\PluginBase;
use Drupal\Core\Cache\CacheableDependencyInterface;
use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
use Drupal\graphql\GraphQL\Field\Field;
use Drupal\graphql\GraphQL\SecureFieldInterface;
use Drupal\graphql\GraphQL\ValueWrapperInterface;
use Drupal\graphql\Plugin\GraphQL\PluggableSchemaBuilderInterface;
use Drupal\graphql\Plugin\GraphQL\Traits\ArgumentAwarePluginTrait;
use Drupal\graphql\Plugin\GraphQL\Traits\CacheablePluginTrait;
use Drupal\graphql\Plugin\GraphQL\Traits\NamedPluginTrait;
use Drupal\graphql\Plugin\GraphQL\TypeSystemPluginInterface;
use Youshido\GraphQL\Exception\ResolveException;
use Youshido\GraphQL\Execution\DeferredResolver;
use Youshido\GraphQL\Execution\ResolveInfo;
use Youshido\GraphQL\Type\ListType\ListType;

/**
 * Base class for field plugins.
 */
abstract class FieldPluginBase extends PluginBase implements TypeSystemPluginInterface, SecureFieldInterface {
  use CacheablePluginTrait;
  use NamedPluginTrait;
  use ArgumentAwarePluginTrait;

  /**
   * The field instance.
   *
   * @var \Drupal\graphql\GraphQL\Field\Field
   */
  protected $definition;

  /**
   * {@inheritdoc}
   */
  public function getDefinition(PluggableSchemaBuilderInterface $schemaBuilder) {

This method seems to be duplicated in your project.

    if (!isset($this->definition)) {
      $definition = $this->getPluginDefinition();

      $config = [
        'name' => $this->buildName(),
        'description' => $this->buildDescription(),
        'type' => $this->buildType($schemaBuilder),
        'args' => $this->buildArguments($schemaBuilder),
        'isDeprecated' => !empty($definition['deprecated']),
        'deprecationReason' => !empty($definition['deprecated']) ? !empty($definition['deprecated']) : '',
      ];

      $this->definition = new Field($this, $schemaBuilder, $config);
    }

    return $this->definition;
  }

  /**
   * {@inheritdoc}
   */
  public function isSecure() {
    return isset($this->getPluginDefinition()['secure']) && $this->getPluginDefinition()['secure'];
  }

  /**
   * {@inheritdoc}
   */
  public function resolve($value, array $args, ResolveInfo $info) {
    // If not resolving in a trusted environment, check if the field is secure.
    $container = $info->getExecutionContext()->getContainer();
    if ($container->has('secure') && !$container->get('secure') && !$this->isSecure()) {
      throw new ResolveException(sprintf("Unable to resolve insecure field '%s' (%s).", $info->getField()->getName(), get_class($this)));
    }

    return $this->resolveDeferred([$this, 'resolveValues'], $value, $args, $info);
  }

  /**
   * {@inheritdoc}
   */
  protected function resolveDeferred(callable $callback, $value, array $args, ResolveInfo $info) {
    $result = $callback($value, $args, $info);
    if (is_callable($result)) {
      return new DeferredResolver(function () use ($result, $args, $info, $value) {
        return $this->resolveDeferred($result, $value, $args, $info);
      });
    }

    // Extract the result array and the corresponding cache dependencies.
    $result = iterator_to_array($result);
    // TODO: Remove this cleanup step before the stable release.
    $clean = array_map(function ($item) {
      return $item instanceof ValueWrapperInterface ? $item->getValue() : $item;
    }, $result);

    // Commit the cache dependencies into the processor's cache collector.
    $dependencies = $this->getCacheDependencies($result, $value, $args, $info);
    array_walk($dependencies, [$this->getCacheCollector($info), 'addCacheableDependency']);

    // If this is a list, return the result as an array.
    $type = $info->getReturnType()->getNullableType();
    if ($type instanceof ListType) {
      return $clean;
    }

    return !empty($clean) ? reset($clean) : NULL;
  }

  /**
   * Retrieve the list of cache dependencies for a given value and arguments.
   *
   * @param array $result
   *   The result of the field.
   * @param mixed $parent
   *   The parent value.
   * @param array $args
   *   The arguments passed to the field.
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *   The resolve info object.
   *
   * @return array
   *   A list of cacheable dependencies.
   */
  protected function getCacheDependencies(array $result, $parent, array $args, ResolveInfo $info) {
    return array_filter($result, function ($item) {
      return $item instanceof CacheableDependencyInterface;

The class Drupal\Core\Cache\CacheableDependencyInterface does not exist. Did you forget a USE statement, or did you not list all dependencies?

    });
  }

  /**
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *
   * @return \Drupal\Core\Cache\RefinableCacheableDependencyInterface
   */
  protected function getCacheCollector(ResolveInfo $info) {
    $container = $info->getExecutionContext()->getContainer();
    if ($container->has('metadata') && $metadata = $container->get('metadata')) {
      if ($metadata instanceof RefinableCacheableDependencyInterface) {

The class Drupal\Core\Cache\RefinableCacheableDependencyInterface does not exist. Did you forget a USE statement, or did you not list all dependencies?

        return $metadata;
      }
    }

    throw new \LogicException('The processor does not support cache metadata collection.');
  }

  /**
   * Commit a cache dependency into the processor's cache collector.
   *
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *   The resolve info object.
   * @param mixed $object
   *   The object to merge into the cache metadata of the processor.
   *
   * @return \Drupal\Core\Cache\RefinableCacheableDependencyInterface
   *   The processor's cache metadata object.
   */
  public function commitCacheableDependency(ResolveInfo $info, $object) {
    return $this->getCacheCollector($info)->addCacheableDependency($object);
  }

  /**
   * Commit cache contexts into the processor's cache collector.
   *
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *   The resolve info object.
   * @param array $contexts
   *   The array of cache contexts to commit.
   *
   * @return \Drupal\Core\Cache\RefinableCacheableDependencyInterface
   *   The processor's cache metadata object.
   */
  public function commitCacheContexts(ResolveInfo $info, array $contexts) {
    return $this->getCacheCollector($info)->addCacheContexts($contexts);
  }

  /**
   * Commit cache tags into the processor's cache collector.
   *
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *   The resolve info object.
   * @param array $tags
   *   The array of cache tags to commit.
   *
   * @return \Drupal\Core\Cache\RefinableCacheableDependencyInterface
   *   The processor's cache metadata object.
   */
  public function commitCacheTags(ResolveInfo $info, array $tags) {
    return $this->getCacheCollector($info)->addCacheTags($tags);
  }

  /**
   * Commit a cache max age into the processor's cache collector.
   *
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *   The resolve info object.
   * @param int $age
   *   The max age to set.
   *
   * @return \Drupal\Core\Cache\RefinableCacheableDependencyInterface
   *   The processor's cache metadata object.
   */
  public function commitCacheMaxAge(ResolveInfo $info, $age) {
    return $this->getCacheCollector($info)->mergeCacheMaxAge($age);
  }

  /**
   * Retrieve the list of field values.
   *
   * Always returns a list of field values. Even for single value fields.
   * Single/multi field handling is responsibility of the base class.
   *
   * @param mixed $value
   *   The current object value.
   * @param array $args
   *   Field arguments.
   * @param \Youshido\GraphQL\Execution\ResolveInfo $info
   *   The resolve info object.
   *
   * @return \Generator
   *   The value generator.
   */
  protected function resolveValues($value, array $args, ResolveInfo $info) {
    // Allow overriding this class without having to declare this method.
    yield NULL;
  }

}