Digia\GraphQL\SchemaExtension\SchemaExtender::extend()

Complexity

Conditions	20
Paths	14

Size

Total Lines	135
Code Lines	82

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function extend(SchemaInterface $schema, DocumentNode $document, array $options = []): SchemaInterface
    {
        $typeDefinitionMap    = [];
        $directiveDefinitions = [];

        foreach ($document->getDefinitions() as $definition) {
            if ($definition instanceof TypeDefinitionNodeInterface) {
                // Sanity check that none of the defined types conflict with the schema's existing types.
                $typeName     = $definition->getNameValue();
                $existingType = $schema->getType($typeName);

                if (null !== $existingType) {
                    throw new ExtensionException(
                        \sprintf(
                            'Type "%s" already exists in the schema. It cannot also ' .
                            'be defined in this type definition.',
                            $typeName
                        ),
                        [$definition]
                    );
                }

                $typeDefinitionMap[$typeName] = $definition;

                continue;
            }

            if ($definition instanceof ObjectTypeExtensionNode || $definition instanceof InterfaceTypeExtensionNode) {
                // Sanity check that this type extension exists within the schema's existing types.
                $extendedTypeName = $definition->getNameValue();
                $existingType     = $schema->getType($extendedTypeName);

                if (null === $existingType) {
                    throw new ExtensionException(
                        \sprintf(
                            'Cannot extend type "%s" because it does not exist in the existing schema.',
                            $extendedTypeName
                        ),
                        [$definition]
                    );
                }

                $this->checkExtensionNode($existingType, $definition);

                $existingTypeExtensions                     = $this->typeExtensionsMap[$extendedTypeName] ?? [];
                $this->typeExtensionsMap[$extendedTypeName] = \array_merge($existingTypeExtensions, [$definition]);

                continue;
            }

            if ($definition instanceof DirectiveDefinitionNode) {
                $directiveName     = $definition->getNameValue();
                $existingDirective = $schema->getDirective($directiveName);

                if (null !== $existingDirective) {
                    throw new ExtensionException(
                        \sprintf(
                            'Directive "%s" already exists in the schema. It cannot be redefined.',
                            $directiveName
                        ),
                        [$definition]
                    );
                }

                $directiveDefinitions[] = $definition;

                continue;
            }

            if ($definition instanceof ScalarTypeExtensionNode ||
                $definition instanceof UnionTypeExtensionNode ||
                $definition instanceof EnumTypeExtensionNode ||
                $definition instanceof InputObjectTypeExtensionNode) {
                throw new ExtensionException(
                    \sprintf('The %s kind is not yet supported by extendSchema().', $definition->getKind())
                );
            }
        }

        // If this document contains no new types, extensions, or directives then
        // return the same unmodified GraphQLSchema instance.
        if (empty($typeDefinitionMap) && empty($this->typeExtensionsMap) && empty($directiveDefinitions)) {
            return $schema;
        }

        $resolveTypeFunction = function (NamedTypeNode $node) use ($schema): ?TypeInterface {
            $typeName     = $node->getNameValue();
            $existingType = $schema->getType($typeName);

            if (null !== $existingType) {
                /** @noinspection PhpIncompatibleReturnTypeInspection */
                /** @noinspection PhpParamsInspection */
                return $this->getExtendedType($existingType);

The expression return $this->getExtendedType($existingType) returns the type Digia\GraphQL\Type\Definition\NamedTypeInterface which is incompatible with the type-hinted return null|Digia\GraphQL\Type\Definition\TypeInterface.

$existingType of type Digia\GraphQL\Type\Definition\TypeInterface is incompatible with the type Digia\GraphQL\Type\Definition\NamedTypeInterface expected by parameter $type of Digia\GraphQL\SchemaExtension\SchemaExtender::getExtendedType().

            }

            throw new ExecutionException(
                \sprintf(
                    'Unknown type: "%s". Ensure that this type exists ' .
                    'either in the original schema, or is added in a type definition.',
                    $typeName
                ),
                [$node]
            );
        };

        $this->definitionBuilder = $this->definitionBuilderCreator->create(
            $typeDefinitionMap,
            $resolveTypeFunction
        );

        $this->cache->clear();

        $existingQueryType        = $schema->getQueryType();
        $existingMutationType     = $schema->getMutationType();
        $existingSubscriptionType = $schema->getSubscriptionType();

        /** @noinspection PhpParamsInspection */
        return GraphQLSchema([
            'query'        => null !== $existingQueryType
                ? $this->getExtendedType($existingQueryType)

$existingQueryType of type Digia\GraphQL\Type\Definition\TypeInterface is incompatible with the type Digia\GraphQL\Type\Definition\NamedTypeInterface expected by parameter $type of Digia\GraphQL\SchemaExtension\SchemaExtender::getExtendedType().

                : null,
            'mutation'     => null !== $existingMutationType ?
                $this->getExtendedType($existingMutationType)
                : null,
            'subscription' => null !== $existingSubscriptionType
                ? $this->getExtendedType($existingSubscriptionType)
                : null,
            'types'        => \array_merge(
                \array_map(function ($type) {
                    return $this->getExtendedType($type);
                }, \array_values($schema->getTypeMap())),
                $this->definitionBuilder->buildTypes(\array_values($typeDefinitionMap))
            ),
            'directives'   => $this->getMergedDirectives($schema, $directiveDefinitions),
            'astNode'      => $schema->getAstNode(),
        ]);