Drupal\graphql\GraphQL\Execution\Processor

Complexity

Total Complexity

16

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
F	processPayload()	0	50	12
B	deferredResolve()	0	23	4

<?php

namespace Drupal\graphql\GraphQL\Execution;

use Youshido\GraphQL\Execution\DeferredResolverInterface;
use Youshido\GraphQL\Execution\DeferredResult;
use Youshido\GraphQL\Execution\Processor as BaseProcessor;
use Youshido\GraphQL\Field\FieldInterface;
use Youshido\GraphQL\Type\Enum\AbstractEnumType;
use Youshido\GraphQL\Type\Scalar\AbstractScalarType;

class Processor extends BaseProcessor {

  /**
   * {@inheritdoc}
   */
  public function processPayload($payload, $variables = [], $visitors = []) {
    $this->data = [];

    try {
      $this->parseAndCreateRequest($payload, $variables);

      if (!empty($reducers)) {

The variable $reducers seems to never exist, and therefore empty should always return true. Did you maybe rename this variable?

        $schema = $this->executionContext->getSchema();
        $request = $this->executionContext->getRequest();
        $reducer = new QueryReducer($schema, $request);

        foreach ($visitors as $visitor) {
          $reducer->reduceQuery($visitor);
        }
      }

      $operations = $this->executionContext->getRequest()->getAllOperations();
      foreach ($operations as $query) {
        if ($operationResult = $this->resolveQuery($query)) {
          $this->data = array_replace_recursive($this->data, $operationResult);
        };
      }

      // If the processor found any deferred results, resolve them now.
      if (!empty($this->data) && (!empty($this->deferredResultsLeaf) || !empty($this->deferredResultsComplex))) {
        try {
          while ($deferredResolver = array_shift($this->deferredResultsComplex)) {
            $deferredResolver->resolve();
          }

          // Deferred scalar and enum fields should be resolved last to
          // pick up as many as possible for a single batch.
          while ($deferredResolver = array_shift($this->deferredResultsLeaf)) {
            $deferredResolver->resolve();
          }
        }
        catch (\Exception $exception) {
          $this->executionContext->addError($exception);
        }
        finally {
          $this->data = static::unpackDeferredResults($this->data);
        }
      }
    }
    catch (\Exception $exception) {
      $this->executionContext->addError($exception);
    }

    return $this;
  }

  /**
   * {@inheritdoc}
   */
  protected function deferredResolve($resolvedValue, FieldInterface $field, callable $callback) {
    if ($resolvedValue instanceof DeferredResolverInterface) {
      $deferredResult = new DeferredResult($resolvedValue, function ($resolvedValue) use ($field, $callback) {
        // Allow nested deferred resolvers.
        return $this->deferredResolve($resolvedValue, $field, $callback);
      });

      // Whenever we stumble upon a deferred resolver, add it to the queue to be
      // resolved later.
      $type = $field->getType()->getNamedType();
      if ($type instanceof AbstractScalarType || $type instanceof AbstractEnumType) {
        array_push($this->deferredResultsLeaf, $deferredResult);
      }
      else {
        array_push($this->deferredResultsComplex, $deferredResult);
      }

      return $deferredResult;
    }

    // For simple values, invoke the callback immediately.
    return $callback($resolvedValue);
  }

}