GraphQL\Validator\ValidationContext

Complexity

Total Complexity

33

Size/Duplication

Total Lines	262
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getDirective()	0	3	1
A	getSchema()	0	3	1
A	__construct()	0	10	1
A	getFragment()	0	16	4
A	getType()	0	3	1
A	getRecursiveVariableUsages()	0	17	3
A	getVariableUsages()	0	29	2
A	getErrors()	0	3	1
A	getFragmentSpreads()	0	22	6
A	getParentInputType()	0	3	1
A	getParentType()	0	3	1
A	getArgument()	0	3	1
A	getDocument()	0	3	1
A	reportError()	0	3	1
B	getRecursivelyReferencedFragments()	0	32	6
A	getFieldDef()	0	3	1
A	getInputType()	0	3	1

<?php

declare(strict_types=1);

namespace GraphQL\Validator;

use GraphQL\Error\Error;
use GraphQL\Language\AST\DocumentNode;
use GraphQL\Language\AST\FragmentDefinitionNode;
use GraphQL\Language\AST\FragmentSpreadNode;
use GraphQL\Language\AST\HasSelectionSet;
use GraphQL\Language\AST\NodeKind;
use GraphQL\Language\AST\OperationDefinitionNode;
use GraphQL\Language\AST\VariableNode;
use GraphQL\Language\Visitor;
use GraphQL\Type\Definition\FieldDefinition;
use GraphQL\Type\Definition\InputType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;
use GraphQL\Utils\TypeInfo;
use SplObjectStorage;
use function array_pop;
use function call_user_func_array;
use function count;

/**
 * An instance of this class is passed as the "this" context to all validators,
 * allowing access to commonly useful contextual information from within a
 * validation rule.
 */
class ValidationContext
{
    /** @var Schema */
    private $schema;

    /** @var DocumentNode */
    private $ast;

    /** @var TypeInfo */
    private $typeInfo;

    /** @var Error[] */
    private $errors;

    /** @var FragmentDefinitionNode[] */
    private $fragments;

    /** @var SplObjectStorage */
    private $fragmentSpreads;

    /** @var SplObjectStorage */
    private $recursivelyReferencedFragments;

    /** @var SplObjectStorage */
    private $variableUsages;

    /** @var SplObjectStorage */
    private $recursiveVariableUsages;

    public function __construct(Schema $schema, DocumentNode $ast, TypeInfo $typeInfo)
    {
        $this->schema                         = $schema;
        $this->ast                            = $ast;
        $this->typeInfo                       = $typeInfo;
        $this->errors                         = [];
        $this->fragmentSpreads                = new SplObjectStorage();
        $this->recursivelyReferencedFragments = new SplObjectStorage();
        $this->variableUsages                 = new SplObjectStorage();
        $this->recursiveVariableUsages        = new SplObjectStorage();
    }

    public function reportError(Error $error)
    {
        $this->errors[] = $error;
    }

    /**
     * @return Error[]
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * @return Schema
     */
    public function getSchema()
    {
        return $this->schema;
    }

    /**
     * @return mixed[][] List of ['node' => VariableNode, 'type' => ?InputObjectType]
     */
    public function getRecursiveVariableUsages(OperationDefinitionNode $operation)
    {
        $usages = $this->recursiveVariableUsages[$operation] ?? null;

        if (! $usages) {
            $usages    = $this->getVariableUsages($operation);
            $fragments = $this->getRecursivelyReferencedFragments($operation);

            $tmp = [$usages];
            for ($i = 0; $i < count($fragments); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                $tmp[] = $this->getVariableUsages($fragments[$i]);
            }
            $usages                                    = call_user_func_array('array_merge', $tmp);
            $this->recursiveVariableUsages[$operation] = $usages;
        }

        return $usages;
    }

    /**
     * @return mixed[][] List of ['node' => VariableNode, 'type' => ?InputObjectType]
     */
    private function getVariableUsages(HasSelectionSet $node)
    {
        $usages = $this->variableUsages[$node] ?? null;

        if (! $usages) {
            $newUsages = [];
            $typeInfo  = new TypeInfo($this->schema);
            Visitor::visit(
                $node,
                Visitor::visitWithTypeInfo(
                    $typeInfo,
                    [
                        NodeKind::VARIABLE_DEFINITION => function () {
                            return false;
                        },
                        NodeKind::VARIABLE            => function (VariableNode $variable) use (
                            &$newUsages,
                            $typeInfo
                        ) {
                            $newUsages[] = ['node' => $variable, 'type' => $typeInfo->getInputType()];
                        },
                    ]
                )
            );
            $usages                      = $newUsages;
            $this->variableUsages[$node] = $usages;
        }

        return $usages;
    }

    /**
     * @return FragmentDefinitionNode[]
     */
    public function getRecursivelyReferencedFragments(OperationDefinitionNode $operation)
    {
        $fragments = $this->recursivelyReferencedFragments[$operation] ?? null;

        if (! $fragments) {
            $fragments      = [];
            $collectedNames = [];
            $nodesToVisit   = [$operation];
            while (! empty($nodesToVisit)) {
                $node    = array_pop($nodesToVisit);
                $spreads = $this->getFragmentSpreads($node);
                for ($i = 0; $i < count($spreads); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                    $fragName = $spreads[$i]->name->value;

                    if (! empty($collectedNames[$fragName])) {
                        continue;
                    }

                    $collectedNames[$fragName] = true;
                    $fragment                  = $this->getFragment($fragName);
                    if (! $fragment) {
                        continue;
                    }

                    $fragments[]    = $fragment;
                    $nodesToVisit[] = $fragment;
                }
            }
            $this->recursivelyReferencedFragments[$operation] = $fragments;
        }

        return $fragments;
    }

    /**
     * @return FragmentSpreadNode[]
     */
    public function getFragmentSpreads(HasSelectionSet $node)
    {
        $spreads = $this->fragmentSpreads[$node] ?? null;
        if (! $spreads) {
            $spreads     = [];
            $setsToVisit = [$node->selectionSet];

Accessing selectionSet on the interface GraphQL\Language\AST\HasSelectionSet suggest that you code against a concrete implementation. How about adding an instanceof check?

            while (! empty($setsToVisit)) {
                $set = array_pop($setsToVisit);

                for ($i = 0; $i < count($set->selections); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                    $selection = $set->selections[$i];
                    if ($selection->kind === NodeKind::FRAGMENT_SPREAD) {
                        $spreads[] = $selection;
                    } elseif ($selection->selectionSet) {
                        $setsToVisit[] = $selection->selectionSet;
                    }
                }
            }
            $this->fragmentSpreads[$node] = $spreads;
        }

        return $spreads;
    }

    /**
     * @param string $name
     * @return FragmentDefinitionNode|null
     */
    public function getFragment($name)
    {
        $fragments = $this->fragments;
        if (! $fragments) {

The expression $fragments of type GraphQL\Language\AST\FragmentDefinitionNode[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $fragments = [];
            foreach ($this->getDocument()->definitions as $statement) {
                if ($statement->kind !== NodeKind::FRAGMENT_DEFINITION) {

Accessing kind on the interface GraphQL\Language\AST\DefinitionNode suggest that you code against a concrete implementation. How about adding an instanceof check?

                    continue;
                }

                $fragments[$statement->name->value] = $statement;

Accessing name on the interface GraphQL\Language\AST\DefinitionNode suggest that you code against a concrete implementation. How about adding an instanceof check?

            }
            $this->fragments = $fragments;
        }

        return $fragments[$name] ?? null;
    }

    /**
     * @return DocumentNode
     */
    public function getDocument()
    {
        return $this->ast;
    }

    /**
     * Returns OutputType
     *
     * @return Type
     */
    public function getType()
    {
        return $this->typeInfo->getType();
    }

    /**
     * @return Type
     */
    public function getParentType()
    {
        return $this->typeInfo->getParentType();
    }

    /**
     * @return InputType
     */
    public function getInputType()
    {
        return $this->typeInfo->getInputType();
    }

    /**
     * @return InputType
     */
    public function getParentInputType()
    {
        return $this->typeInfo->getParentInputType();
    }

    /**
     * @return FieldDefinition
     */
    public function getFieldDef()
    {
        return $this->typeInfo->getFieldDef();
    }

    public function getDirective()
    {
        return $this->typeInfo->getDirective();
    }

    public function getArgument()
    {
        return $this->typeInfo->getArgument();
    }
}