SchemaExtender::createInfo() - Code Metrics - Inspection of "Support for custom types and directives when build..." - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#215)

by Christoffer

created 2018-05-03 17:07 UTC

SchemaExtender::createInfo() D

↳ Parent: SchemaExtender

Complexity

Conditions	13
Paths	9

Size

Total Lines	88
Code Lines	53

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	88
c	0
b	0
f	0
rs	4.9922
cc	13
eloc	53
nc	9
nop	2

How to fix Long Method Complexity

<?php

namespace Digia\GraphQL\Schema\Extension;

use Digia\GraphQL\Error\ExtensionException;
use Digia\GraphQL\Language\Node\DirectiveDefinitionNode;
use Digia\GraphQL\Language\Node\DocumentNode;
use Digia\GraphQL\Language\Node\EnumTypeExtensionNode;
use Digia\GraphQL\Language\Node\InputObjectTypeExtensionNode;
use Digia\GraphQL\Language\Node\InterfaceTypeExtensionNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\ObjectTypeExtensionNode;
use Digia\GraphQL\Language\Node\ScalarTypeExtensionNode;
use Digia\GraphQL\Language\Node\TypeDefinitionNodeInterface;
use Digia\GraphQL\Language\Node\UnionTypeExtensionNode;
use Digia\GraphQL\Schema\DefinitionBuilder;
use Digia\GraphQL\Schema\Resolver\ResolverRegistryInterface;
use Digia\GraphQL\Schema\Schema;
use Digia\GraphQL\Type\Definition\InterfaceType;
use Digia\GraphQL\Type\Definition\ObjectType;
use Digia\GraphQL\Type\Definition\TypeInterface;
use Psr\SimpleCache\CacheInterface;
use function Digia\GraphQL\Type\newSchema;
use function Digia\GraphQL\Util\toString;

class SchemaExtender implements SchemaExtenderInterface
{
    /**
     * @inheritdoc
     */
    public function extend(
        Schema $schema,
        DocumentNode $document,
        ?ResolverRegistryInterface $resolverRegistry = null,
        array $options = []
    ): Schema {
        $context = $this->createContext($schema, $document, $resolverRegistry, $options);

        // If this document contains no new types, extensions, or directives then
        // return the same unmodified GraphQLSchema instance.
        if (!$context->isSchemaExtended()) {
            return $schema;
        }

        return newSchema([
            'query'        => $context->getExtendedQueryType(),
            'mutation'     => $context->getExtendedMutationType(),
            'subscription' => $context->getExtendedSubscriptionType(),
            'types'        => $context->getExtendedTypes(),
            'directives'   => $context->getExtendedDirectives(),
            'astNode'      => $schema->getAstNode(),
        ]);
    }

    /**
     * @inheritdoc
     */
    protected function createContext(
        Schema $schema,
        DocumentNode $document,
        ?ResolverRegistryInterface $resolverRegistry,
        array $options
    ): ExtensionContextInterface {
        $info = $this->createInfo($schema, $document);

        // Context has to be created in order to create the definition builder,
        // because we are using its `resolveType` function to resolve types.
        $context = new ExtensionContext($info);

        $definitionBuilder = new DefinitionBuilder(
            $info->getTypeDefinitionMap(),
            $resolverRegistry,
            $options['types'] ?? [],
            $options['directives'] ?? [],
            [$context, 'resolveType']
        );

        return $context->setDefinitionBuilder($definitionBuilder);
    }

    /**
     * @param Schema       $schema
     * @param DocumentNode $document
     * @return ExtendInfo
     * @throws ExtensionException
     */
    protected function createInfo(Schema $schema, DocumentNode $document): ExtendInfo
    {
        $typeDefinitionMap    = [];
        $typeExtensionsMap    = [];
        $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);

                $typeExtensionsMap[$extendedTypeName] = \array_merge(
                    $typeExtensionsMap[$extendedTypeName] ?? [],
                    [$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())
                );
            }
        }

        return new ExtendInfo(
            $schema,
            $document,
            $typeDefinitionMap,
            $typeExtensionsMap,
            $directiveDefinitions
        );
    }

    /**
     * @param TypeInterface $type
     * @param NodeInterface $node
     * @throws ExtensionException
     */
    protected function checkExtensionNode(TypeInterface $type, NodeInterface $node): void
    {
        if ($node instanceof ObjectTypeExtensionNode && !($type instanceof ObjectType)) {
            throw new ExtensionException(
                \sprintf('Cannot extend non-object type "%s".', toString($type)),
                [$node]
            );
        }

        if ($node instanceof InterfaceTypeExtensionNode && !($type instanceof InterfaceType)) {
            throw new ExtensionException(
                \sprintf('Cannot extend non-interface type "%s".', toString($type)),
                [$node]
            );
        }
    }
}


1			<?php
2
3			namespace Digia\GraphQL\Schema\Extension;
4
5			use Digia\GraphQL\Error\ExtensionException;
6			use Digia\GraphQL\Language\Node\DirectiveDefinitionNode;
7			use Digia\GraphQL\Language\Node\DocumentNode;
8			use Digia\GraphQL\Language\Node\EnumTypeExtensionNode;
9			use Digia\GraphQL\Language\Node\InputObjectTypeExtensionNode;
10			use Digia\GraphQL\Language\Node\InterfaceTypeExtensionNode;
11			use Digia\GraphQL\Language\Node\NodeInterface;
12			use Digia\GraphQL\Language\Node\ObjectTypeExtensionNode;
13			use Digia\GraphQL\Language\Node\ScalarTypeExtensionNode;
14			use Digia\GraphQL\Language\Node\TypeDefinitionNodeInterface;
15			use Digia\GraphQL\Language\Node\UnionTypeExtensionNode;
16			use Digia\GraphQL\Schema\DefinitionBuilder;
17			use Digia\GraphQL\Schema\Resolver\ResolverRegistryInterface;
18			use Digia\GraphQL\Schema\Schema;
19			use Digia\GraphQL\Type\Definition\InterfaceType;
20			use Digia\GraphQL\Type\Definition\ObjectType;
21			use Digia\GraphQL\Type\Definition\TypeInterface;
22			use Psr\SimpleCache\CacheInterface;
23			use function Digia\GraphQL\Type\newSchema;
24			use function Digia\GraphQL\Util\toString;
25
26			class SchemaExtender implements SchemaExtenderInterface
27			{
28			/**
29			* @inheritdoc
30			*/
31			public function extend(
32			Schema $schema,
33			DocumentNode $document,
34			?ResolverRegistryInterface $resolverRegistry = null,
35			array $options = []
36			): Schema {
37			$context = $this->createContext($schema, $document, $resolverRegistry, $options);
38
39			// If this document contains no new types, extensions, or directives then
40			// return the same unmodified GraphQLSchema instance.
41			if (!$context->isSchemaExtended()) {
42			return $schema;
43			}
44
45			return newSchema([
46			'query' => $context->getExtendedQueryType(),
47			'mutation' => $context->getExtendedMutationType(),
48			'subscription' => $context->getExtendedSubscriptionType(),
49			'types' => $context->getExtendedTypes(),
50			'directives' => $context->getExtendedDirectives(),
51			'astNode' => $schema->getAstNode(),
52			]);
53			}
54
55			/**
56			* @inheritdoc
57			*/
58			protected function createContext(
59			Schema $schema,
60			DocumentNode $document,
61			?ResolverRegistryInterface $resolverRegistry,
62			array $options
63			): ExtensionContextInterface {
64			$info = $this->createInfo($schema, $document);
65
66			// Context has to be created in order to create the definition builder,
67			// because we are using its `resolveType` function to resolve types.
68			$context = new ExtensionContext($info);
69
70			$definitionBuilder = new DefinitionBuilder(
71			$info->getTypeDefinitionMap(),
72			$resolverRegistry,
73			$options['types'] ?? [],
74			$options['directives'] ?? [],
75			[$context, 'resolveType']
76			);
77
78			return $context->setDefinitionBuilder($definitionBuilder);
79			}
80
81			/**
82			* @param Schema $schema
83			* @param DocumentNode $document
84			* @return ExtendInfo
85			* @throws ExtensionException
86			*/
87			protected function createInfo(Schema $schema, DocumentNode $document): ExtendInfo
88			{
89			$typeDefinitionMap = [];
90			$typeExtensionsMap = [];
91			$directiveDefinitions = [];
92
93			foreach ($document->getDefinitions() as $definition) {
94			if ($definition instanceof TypeDefinitionNodeInterface) {
95			// Sanity check that none of the defined types conflict with the schema's existing types.
96			$typeName = $definition->getNameValue();
97			$existingType = $schema->getType($typeName);
98
99			if (null !== $existingType) {
100			throw new ExtensionException(
101			\sprintf(
102			'Type "%s" already exists in the schema. It cannot also ' .
103			'be defined in this type definition.',
104			$typeName
105			),
106			[$definition]
107			);
108			}
109
110			$typeDefinitionMap[$typeName] = $definition;
111
112			continue;
113			}
114
115			if ($definition instanceof ObjectTypeExtensionNode \|\| $definition instanceof InterfaceTypeExtensionNode) {
116			// Sanity check that this type extension exists within the schema's existing types.
117			$extendedTypeName = $definition->getNameValue();
118			$existingType = $schema->getType($extendedTypeName);
119
120			if (null === $existingType) {
121			throw new ExtensionException(
122			\sprintf(
123			'Cannot extend type "%s" because it does not exist in the existing schema.',
124			$extendedTypeName
125			),
126			[$definition]
127			);
128			}
129
130			$this->checkExtensionNode($existingType, $definition);
131
132			$typeExtensionsMap[$extendedTypeName] = \array_merge(
133			$typeExtensionsMap[$extendedTypeName] ?? [],
134			[$definition]
135			);
136
137			continue;
138			}
139
140			if ($definition instanceof DirectiveDefinitionNode) {
141			$directiveName = $definition->getNameValue();
142			$existingDirective = $schema->getDirective($directiveName);
143
144			if (null !== $existingDirective) {
145			throw new ExtensionException(
146			\sprintf(
147			'Directive "%s" already exists in the schema. It cannot be redefined.',
148			$directiveName
149			),
150			[$definition]
151			);
152			}
153
154			$directiveDefinitions[] = $definition;
155
156			continue;
157			}
158
159			if ($definition instanceof ScalarTypeExtensionNode \|\|
160			$definition instanceof UnionTypeExtensionNode \|\|
161			$definition instanceof EnumTypeExtensionNode \|\|
162			$definition instanceof InputObjectTypeExtensionNode) {
163			throw new ExtensionException(
164			\sprintf('The %s kind is not yet supported by extendSchema().', $definition->getKind())
165			);
166			}
167			}
168
169			return new ExtendInfo(
170			$schema,
171			$document,
172			$typeDefinitionMap,
173			$typeExtensionsMap,
174			$directiveDefinitions
175			);
176			}
177
178			/**
179			* @param TypeInterface $type
180			* @param NodeInterface $node
181			* @throws ExtensionException
182			*/
183			protected function checkExtensionNode(TypeInterface $type, NodeInterface $node): void
184			{
185			if ($node instanceof ObjectTypeExtensionNode && !($type instanceof ObjectType)) {
186			throw new ExtensionException(
187			\sprintf('Cannot extend non-object type "%s".', toString($type)),
188			[$node]
189			);
190			}
191
192			if ($node instanceof InterfaceTypeExtensionNode && !($type instanceof InterfaceType)) {
193			throw new ExtensionException(
194			\sprintf('Cannot extend non-interface type "%s".', toString($type)),
195			[$node]
196			);
197			}
198			}
199			}
200

digiaonline / graphql-php

Pull Request — master (#215)

SchemaExtender::createInfo() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like