Overblog\GraphQLBundle\Request\Validator\Rule\AbstractQuerySecurity

Complexity

Total Complexity

30

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getFragments()	0	4	1
A	checkIfGreaterOrEqualToZero()	0	6	2
A	gatherFragmentDefinition()	0	11	3
A	getFragment()	0	7	2
A	invokeIfNeeded()	0	11	2
C	collectFieldASTsAndDefs()	0	67	18
A	getFieldName()	0	7	2
	isEnabled()	0	1	?

<?php

/*
 * This file is part of the OverblogGraphQLBundle package.
 *
 * (c) Overblog <http://github.com/overblog/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Overblog\GraphQLBundle\Request\Validator\Rule;

use GraphQL\Language\AST\Field;
use GraphQL\Language\AST\FragmentDefinition;
use GraphQL\Language\AST\FragmentSpread;
use GraphQL\Language\AST\InlineFragment;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\SelectionSet;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Introspection;
use GraphQL\Utils\TypeInfo;
use GraphQL\Validator\ValidationContext;

abstract class AbstractQuerySecurity
{
    const DISABLED = 0;

    /** @var FragmentDefinition[] */
    private $fragments = [];

    /**
     * @return \GraphQL\Language\AST\FragmentDefinition[]
     */
    protected function getFragments()
    {
        return $this->fragments;
    }

    /**
     * check if equal to 0 no check is done. Must be greater or equal to 0.
     *
     * @param $value
     */
    protected static function checkIfGreaterOrEqualToZero($name, $value)
    {
        if ($value < 0) {
            throw new \InvalidArgumentException(sprintf('$%s argument must be greater or equal to 0.', $name));
        }
    }

    protected function gatherFragmentDefinition(ValidationContext $context)
    {
        // Gather all the fragment definition.
        // Importantly this does not include inline fragments.
        $definitions = $context->getDocument()->definitions;
        foreach ($definitions as $node) {
            if ($node instanceof FragmentDefinition) {
                $this->fragments[$node->name->value] = $node;
            }
        }
    }

    protected function getFragment(FragmentSpread $fragmentSpread)
    {
        $spreadName = $fragmentSpread->name->value;
        $fragments = $this->getFragments();

        return isset($fragments[$spreadName]) ? $fragments[$spreadName] : null;
    }

    protected function invokeIfNeeded(ValidationContext $context, array $validators)
    {
        $this->gatherFragmentDefinition($context);

        // is disabled?
        if (!$this->isEnabled()) {
            return [];
        }

        return $validators;
    }

    /**
     * Given a selectionSet, adds all of the fields in that selection to
     * the passed in map of fields, and returns it at the end.
     *
     * Note: This is not the same as execution's collectFields because at static
     * time we do not know what object type will be used, so we unconditionally
     * spread in all fragments.
     *
     * @see GraphQL\Validator\Rules\OverlappingFieldsCanBeMerged
     *
     * @param ValidationContext $context
     * @param Type|null         $parentType
     * @param SelectionSet      $selectionSet
     * @param \ArrayObject      $visitedFragmentNames
     * @param \ArrayObject      $astAndDefs
     *
     * @return \ArrayObject
     */
    protected function collectFieldASTsAndDefs(ValidationContext $context, $parentType, SelectionSet $selectionSet, \ArrayObject $visitedFragmentNames = null, \ArrayObject $astAndDefs = null)
    {
        $_visitedFragmentNames = $visitedFragmentNames ?: new \ArrayObject();
        $_astAndDefs = $astAndDefs ?: new \ArrayObject();

        foreach ($selectionSet->selections as $selection) {
            switch ($selection->kind) {

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

                case Node::FIELD:
                    $fieldName = $selection->name->value;

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

                    $fieldDef = null;
                    if ($parentType && method_exists($parentType, 'getFields')) {
                        $tmp = $parentType->getFields();

It seems like you code against a specific sub-type and not the parent class GraphQL\Type\Definition\Type as the method getFields() does only exist in the following sub-classes of GraphQL\Type\Definition\Type: GraphQL\Type\Definition\InputObjectType, GraphQL\Type\Definition\InterfaceType, GraphQL\Type\Definition\ObjectType, Overblog\GraphQLBundle\Definition\InputObjectType, Overblog\GraphQLBundle\Definition\InterfaceType, Overblog\GraphQLBundle\Definition\ObjectType, Overblog\GraphQLBundle\Relay\Connection\ConnectionType, Overblog\GraphQLBundle\Relay\Connection\EdgeType, Overblog\GraphQLBundle\Relay\Connection\PageInfoType, Overblog\GraphQLBundle\Relay\Mutation\InputType, Overblog\GraphQLBundle\Relay\Mutation\PayloadType, Overblog\GraphQLBundle\Relay\Node\NodeInterfaceType. Maybe you want to instanceof check for one of these explicitly?

                        $schemaMetaFieldDef = Introspection::schemaMetaFieldDef();
                        $typeMetaFieldDef = Introspection::typeMetaFieldDef();
                        $typeNameMetaFieldDef = Introspection::typeNameMetaFieldDef();

                        if ($fieldName === $schemaMetaFieldDef->name && $context->getSchema()->getQueryType() === $parentType) {
                            $fieldDef = $schemaMetaFieldDef;
                        } elseif ($fieldName === $typeMetaFieldDef->name && $context->getSchema()->getQueryType() === $parentType) {
                            $fieldDef = $typeMetaFieldDef;
                        } elseif ($fieldName === $typeNameMetaFieldDef->name) {
                            $fieldDef = $typeNameMetaFieldDef;
                        } elseif (isset($tmp[$fieldName])) {
                            $fieldDef = $tmp[$fieldName];
                        }
                    }
                    $responseName = $this->getFieldName($selection);

$selection is of type object<GraphQL\Language\AST\Selection>, but the function expects a object<GraphQL\Language\AST\Field>.

                    if (!isset($_astAndDefs[$responseName])) {
                        $_astAndDefs[$responseName] = new \ArrayObject();
                    }
                    // create field context
                    $_astAndDefs[$responseName][] = [$selection, $fieldDef];
                    break;
                case Node::INLINE_FRAGMENT:
                    /* @var InlineFragment $inlineFragment */
                    $_astAndDefs = $this->collectFieldASTsAndDefs(
                        $context,
                        TypeInfo::typeFromAST($context->getSchema(), $selection->typeCondition),

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

It seems like \GraphQL\Utils\TypeInfo::typeFromAST($context->getSchema(), $selection->typeCondition) targeting GraphQL\Utils\TypeInfo::typeFromAST() can also be of type object<GraphQL\Language\AST\Name>; however, Overblog\GraphQLBundle\Request\Validator\Rule\AbstractQuerySecurity::collectFieldASTsAndDefs() does only seem to accept object<GraphQL\Type\Definition\Type>|null, maybe add an additional type check?

                        $selection->selectionSet,

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

                        $_visitedFragmentNames,
                        $_astAndDefs
                    );
                    break;
                case Node::FRAGMENT_SPREAD:
                    /* @var FragmentSpread $selection */
                    $fragName = $selection->name->value;

                    if (empty($_visitedFragmentNames[$fragName])) {
                        $_visitedFragmentNames[$fragName] = true;
                        $fragment = $context->getFragment($fragName);

                        if ($fragment) {
                            $_astAndDefs = $this->collectFieldASTsAndDefs(
                                $context,
                                TypeInfo::typeFromAST($context->getSchema(), $fragment->typeCondition),

It seems like \GraphQL\Utils\TypeInfo::typeFromAST($context->getSchema(), $fragment->typeCondition) targeting GraphQL\Utils\TypeInfo::typeFromAST() can also be of type object<GraphQL\Language\AST\Name>; however, Overblog\GraphQLBundle\Request\Validator\Rule\AbstractQuerySecurity::collectFieldASTsAndDefs() does only seem to accept object<GraphQL\Type\Definition\Type>|null, maybe add an additional type check?

                                $fragment->selectionSet,
                                $_visitedFragmentNames,
                                $_astAndDefs
                            );
                        }
                    }
                    break;
            }
        }

        return $_astAndDefs;
    }

    protected function getFieldName(Field $node)
    {
        $fieldName = $node->name->value;
        $responseName = $node->alias ? $node->alias->value : $fieldName;

        return $responseName;
    }

    abstract protected function isEnabled();
}