Digia\GraphQL\Execution\Strategy\FieldCollector

Complexity

Total Complexity

19

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	collectFields()	0	53	9
A	doesFragmentConditionMatch()	0	19	4
A	__construct()	0	6	1
A	shouldIncludeNode()	0	17	5

<?php

namespace Digia\GraphQL\Execution\Strategy;

use Digia\GraphQL\Error\InvalidTypeException;
use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Execution\ExecutionContext;
use Digia\GraphQL\Execution\ExecutionException;
use Digia\GraphQL\Execution\ValuesResolver;
use Digia\GraphQL\Language\Node\FieldNode;
use Digia\GraphQL\Language\Node\FragmentDefinitionNode;
use Digia\GraphQL\Language\Node\FragmentSpreadNode;
use Digia\GraphQL\Language\Node\InlineFragmentNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\SelectionSetNode;
use Digia\GraphQL\Type\Definition\AbstractTypeInterface;
use Digia\GraphQL\Type\Definition\Directive;
use Digia\GraphQL\Type\Definition\ObjectType;
use Digia\GraphQL\Util\ConversionException;
use Digia\GraphQL\Util\TypeASTConverter;

class FieldCollector
{
    /**
     * @var ExecutionContext
     */
    protected $context;

    /**
     * @var Directive
     */
    protected $skipDirective;

    /**
     * @var Directive
     */
    protected $includeDirective;

    /**
     * @var ValuesResolver
     */
    protected $valuesResolver;

    /**
     * FieldCollector constructor.
     * @param ExecutionContext $context
     * @param ValuesResolver   $valuesResolver
     */
    public function __construct(ExecutionContext $context, ValuesResolver $valuesResolver)
    {
        $this->context          = $context;
        $this->skipDirective    = SkipDirective();
        $this->includeDirective = IncludeDirective();
        $this->valuesResolver   = $valuesResolver;
    }

    /**
     * @param ObjectType       $runtimeType
     * @param SelectionSetNode $selectionSet
     * @param array            $fields
     * @param array            $visitedFragmentNames
     * @return array
     * @throws InvalidTypeException
     * @throws ExecutionException
     * @throws InvariantException
     * @throws ConversionException
     */
    public function collectFields(
        ObjectType $runtimeType,
        SelectionSetNode $selectionSet,
        array &$fields,
        array &$visitedFragmentNames
    ): array {
        foreach ($selectionSet->getSelections() as $selection) {
            // Check if this Node should be included first
            if (!$this->shouldIncludeNode($selection)) {
                continue;
            }

            // Collect fields
            if ($selection instanceof FieldNode) {
                $fieldName = $selection->getAliasOrNameValue();

                if (!isset($fields[$fieldName])) {
                    $fields[$fieldName] = [];
                }

                $fields[$fieldName][] = $selection;

                continue;
            }

            if ($selection instanceof InlineFragmentNode) {
                if (!$this->doesFragmentConditionMatch($selection, $runtimeType)) {
                    continue;
                }

                $this->collectFields($runtimeType, $selection->getSelectionSet(), $fields, $visitedFragmentNames);

It seems like $selection->getSelectionSet() can also be of type null; however, parameter $selectionSet of Digia\GraphQL\Execution\Strategy\FieldCollector::collectFields() does only seem to accept Digia\GraphQL\Language\Node\SelectionSetNode, maybe add an additional type check?

                continue;
            }

            if ($selection instanceof FragmentSpreadNode) {
                $fragmentName = $selection->getNameValue();

                if (isset($visitedFragmentNames[$fragmentName])) {
                    continue;
                }

                $visitedFragmentNames[$fragmentName] = true;

                $fragment = $this->context->getFragments()[$fragmentName];

                $this->collectFields($runtimeType, $fragment->getSelectionSet(), $fields, $visitedFragmentNames);

                continue;
            }
        }

        return $fields;
    }

    /**
     * @param NodeInterface $node
     * @return bool
     * @throws ExecutionException
     * @throws InvalidTypeException
     * @throws InvariantException
     */
    protected function shouldIncludeNode(NodeInterface $node): bool
    {
        $contextVariables = $this->context->getVariableValues();

        $skip = $this->valuesResolver->coerceDirectiveValues($this->skipDirective, $node, $contextVariables);

        if ($skip && $skip['if'] === true) {
            return false;
        }

        $include = $this->valuesResolver->coerceDirectiveValues($this->includeDirective, $node, $contextVariables);

        if ($include && $include['if'] === false) {
            return false;
        }

        return true;
    }

    /**
     * @param FragmentDefinitionNode|InlineFragmentNode $fragment
     * @param ObjectType                                $type
     * @return bool
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function doesFragmentConditionMatch($fragment, ObjectType $type): bool
    {
        $typeConditionNode = $fragment->getTypeCondition();

        if (null === $typeConditionNode) {
            return true;
        }

        $conditionalType = TypeASTConverter::convert($this->context->getSchema(), $typeConditionNode);

        if ($type === $conditionalType) {

The condition $type === $conditionalType is always false.

            return true;
        }

        if ($conditionalType instanceof AbstractTypeInterface) {
            return $this->context->getSchema()->isPossibleType($conditionalType, $type);
        }

        return false;
    }
}