Digia\GraphQL\Validation\Rule\PossibleFragmentSpreadsRule

Complexity

Total Complexity

13

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	getFragmentType()	0	11	3
A	__construct()	0	3	1
D	enterNode()	0	38	9

<?php

namespace Digia\GraphQL\Validation\Rule;

use Digia\GraphQL\Error\InvalidTypeException;
use Digia\GraphQL\Error\ValidationException;
use Digia\GraphQL\Language\Node\FragmentSpreadNode;
use Digia\GraphQL\Language\Node\InlineFragmentNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Type\Definition\CompositeTypeInterface;
use Digia\GraphQL\Type\Definition\TypeInterface;
use Digia\GraphQL\Util\TypeComparator;
use function Digia\GraphQL\Util\typeFromAST;
use function Digia\GraphQL\Validation\typeIncompatibleAnonymousSpreadMessage;
use function Digia\GraphQL\Validation\typeIncompatibleSpreadMessage;

/**
 * Possible fragment spread
 *
 * A fragment spread is only valid if the type condition could ever possibly
 * be true: if there is a non-empty intersection of the possible parent types,
 * and possible types which pass the type condition.
 */
class PossibleFragmentSpreadsRule extends AbstractRule
{
    /**
     * @var TypeComparator
     */
    protected $typeComparator;

    /**
     * PossibleFragmentSpreadsRule constructor.
     */
    public function __construct()
    {
        $this->typeComparator = new TypeComparator();
    }


    /**
     * @inheritdoc
     */
    public function enterNode(NodeInterface $node): ?NodeInterface
    {
        if ($node instanceof InlineFragmentNode) {
            $fragmentType = $this->validationContext->getType();
            $parentType   = $this->validationContext->getParentType();

            if ($fragmentType instanceof CompositeTypeInterface &&
                $parentType instanceof CompositeTypeInterface &&
                !$this->typeComparator->doTypesOverlap($this->validationContext->getSchema(),
                    $fragmentType, $parentType)) {
                $this->validationContext->reportError(
                    new ValidationException(
                        typeIncompatibleAnonymousSpreadMessage($parentType, $fragmentType),

$fragmentType of type Digia\GraphQL\Type\Definition\TypeInterface&Digia\GraphQL\Type\Definition\CompositeTypeInterface|Digia\GraphQL\Type\Definition\CompositeTypeInterface is incompatible with the type string expected by parameter $fragmentType of Digia\GraphQL\Validation\typeIncompatibleAnonymousSpreadMessage().

$parentType of type Digia\GraphQL\Type\Definition\TypeInterface&Digia\GraphQL\Type\Definition\CompositeTypeInterface|Digia\GraphQL\Type\Definition\CompositeTypeInterface is incompatible with the type string expected by parameter $parentType of Digia\GraphQL\Validation\typeIncompatibleAnonymousSpreadMessage().

                        [$node]
                    )
                );
            }
        }

        if ($node instanceof FragmentSpreadNode) {
            $fragmentName = $node->getNameValue();
            $fragmentType = $this->getFragmentType($fragmentName);
            $parentType   = $this->validationContext->getParentType();

            if (null !== $fragmentType &&
                null !== $parentType &&
                !$this->typeComparator->doTypesOverlap($this->validationContext->getSchema(),
                    $fragmentType, $parentType)) {
                $this->validationContext->reportError(
                    new ValidationException(
                        typeIncompatibleSpreadMessage($fragmentName, $parentType, $fragmentType),

$fragmentType of type Digia\GraphQL\Type\Definition\TypeInterface is incompatible with the type string expected by parameter $fragmentType of Digia\GraphQL\Validation\typeIncompatibleSpreadMessage().

$parentType of type Digia\GraphQL\Type\Definition\TypeInterface is incompatible with the type string expected by parameter $parentType of Digia\GraphQL\Validation\typeIncompatibleSpreadMessage().

                        [$node]
                    )
                );
            }
        }

        return $node;
    }

    /**
     * @param string $name
     * @return TypeInterface|null
     * @throws InvalidTypeException
     */
    protected function getFragmentType(string $name): ?TypeInterface
    {
        $fragment = $this->validationContext->getFragment($name);

        if (null === $fragment) {
            return null;
        }

        $type = typeFromAST($this->validationContext->getSchema(), $fragment->getTypeCondition());

        return $type instanceof CompositeTypeInterface ? $type : null;

The expression return $type instanceof Digia\GraphQL\Type\Definition\CompositeTypeInterface ? $type : null could return the type Digia\GraphQL\Type\Definition\CompositeTypeInterface which is incompatible with the type-hinted return null|Digia\GraphQL\Type\Definition\TypeInterface. Consider adding an additional type-check to rule them out.

    }
}