digiaonline / graphql-php

src/Validation/Rule/PossibleFragmentSpreadsRule.php

<?php

namespace Digia\GraphQL\Validation\Rule;

use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Language\Node\FragmentSpreadNode;
use Digia\GraphQL\Language\Node\InlineFragmentNode;
use Digia\GraphQL\Language\Visitor\VisitorResult;
use Digia\GraphQL\Type\Definition\CompositeTypeInterface;
use Digia\GraphQL\Type\Definition\TypeInterface;
use Digia\GraphQL\Util\ConversionException;
use Digia\GraphQL\Util\TypeASTConverter;
use Digia\GraphQL\Util\TypeHelper;
use Digia\GraphQL\Validation\ValidationException;
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
{
    /**
     * @inheritdoc
     *
     * @throws InvariantException
     */
    protected function enterInlineFragment(InlineFragmentNode $node): VisitorResult
    {
        $fragmentType = $this->context->getType();
        $parentType   = $this->context->getParentType();

        if ($fragmentType instanceof CompositeTypeInterface &&
            $parentType instanceof CompositeTypeInterface &&
            !TypeHelper::doTypesOverlap($this->context->getSchema(), $fragmentType, $parentType)
        ) {
            $this->context->reportError(
                new ValidationException(
                    typeIncompatibleAnonymousSpreadMessage((string)$parentType, (string)$fragmentType),
                    [$node]
                )
            );
        }

        return new VisitorResult($node);
    }

    /**
     * @inheritdoc
     *
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function enterFragmentSpread(FragmentSpreadNode $node): VisitorResult
    {
        $fragmentName = $node->getNameValue();
        $fragmentType = $this->getFragmentType($fragmentName);

It seems like $fragmentName can also be of type null; however, parameter $name of Digia\GraphQL\Validation\Rule\PossibleFragmentSpreadsRule::getFragmentType() does only seem to accept string, maybe add an additional type check?

        $parentType   = $this->context->getParentType();

        if (null !== $fragmentType &&
            null !== $parentType &&
            !TypeHelper::doTypesOverlap($this->context->getSchema(), $fragmentType, $parentType)
        ) {
            $this->context->reportError(
                new ValidationException(
                    typeIncompatibleSpreadMessage($fragmentName, (string)$parentType, (string)$fragmentType),

It seems like $fragmentName can also be of type null; however, parameter $fragmentName of Digia\GraphQL\Validation\typeIncompatibleSpreadMessage() does only seem to accept string, maybe add an additional type check?

                    [$node]
                )
            );
        }

        return new VisitorResult($node);
    }

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

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

        $type = TypeASTConverter::convert($this->context->getSchema(), $fragment->getTypeCondition());

It seems like $fragment->getTypeCondition() can also be of type null; however, parameter $typeNode of Digia\GraphQL\Util\TypeASTConverter::convert() does only seem to accept Digia\GraphQL\Language\Node\TypeNodeInterface, maybe add an additional type check?

        return $type instanceof CompositeTypeInterface ? $type : null;
    }
}