Automattic\WooCommerce\Vendor\GraphQL\Utils

BuildSchema::buildSchema │ public │ WC 1.0

Method of the class: BuildSchema{}

No Hooks.

Returns

null. Nothing (null).

Usage

$BuildSchema = new BuildSchema();
$BuildSchema->buildSchema(): Schema;

BuildSchema::buildSchema() BuildSchema::buildSchema code ^{WC 10.9.1}

public function buildSchema(): Schema
{
    if (
        ! ($this->options['assumeValid'] ?? false)
        && ! ($this->options['assumeValidSDL'] ?? false)
    ) {
        DocumentValidator::assertValidSDL($this->ast);
    }

    $schemaDef = null;

    /** @var array<string, Node&TypeDefinitionNode> */
    $typeDefinitionsMap = [];

    /** @var array<string, array<int, Node&TypeExtensionNode>> $typeExtensionsMap */
    $typeExtensionsMap = [];

    /** @var array<int, DirectiveDefinitionNode> $directiveDefs */
    $directiveDefs = [];

    foreach ($this->ast->definitions as $definition) {
        switch (true) {
            case $definition instanceof SchemaDefinitionNode:
                $schemaDef = $definition;
                break;
            case $definition instanceof TypeDefinitionNode:
                $name = $definition->getName()->value;
                $typeDefinitionsMap[$name] = $definition;
                break;
            case $definition instanceof TypeExtensionNode:
                $name = $definition->getName()->value;
                $typeExtensionsMap[$name][] = $definition;
                break;
            case $definition instanceof DirectiveDefinitionNode:
                $directiveDefs[] = $definition;
                break;
        }
    }

    $operationTypes = $schemaDef !== null
        ? $this->getOperationTypes($schemaDef)
        : [
            'query' => 'Query',
            'mutation' => 'Mutation',
            'subscription' => 'Subscription',
        ];

    $definitionBuilder = new ASTDefinitionBuilder(
        $typeDefinitionsMap,
        $typeExtensionsMap,
        static function (string $typeName): Type {
            throw self::unknownType($typeName);
        },
        $this->typeConfigDecorator,
        $this->fieldConfigDecorator
    );

    $directives = array_map(
        [$definitionBuilder, 'buildDirective'],
        $directiveDefs
    );

    $directivesByName = [];
    foreach ($directives as $directive) {
        $directivesByName[$directive->name][] = $directive;
    }

    // If specified directives were not explicitly declared, add them.
    if (! isset($directivesByName['include'])) {
        $directives[] = Directive::includeDirective();
    }
    if (! isset($directivesByName['skip'])) {
        $directives[] = Directive::skipDirective();
    }
    if (! isset($directivesByName['deprecated'])) {
        $directives[] = Directive::deprecatedDirective();
    }
    if (! isset($directivesByName['oneOf'])) {
        $directives[] = Directive::oneOfDirective();
    }

    // Note: While this could make early assertions to get the correctly
    // typed values below, that would throw immediately while type system
    // validation with validateSchema() will produce more actionable results.
    return new Schema(
        (new SchemaConfig())
            ->setDescription($schemaDef->description->value ?? null)
        // @phpstan-ignore-next-line
            ->setQuery(isset($operationTypes['query'])
                ? $definitionBuilder->maybeBuildType($operationTypes['query'])
                : null)
        // @phpstan-ignore-next-line
            ->setMutation(isset($operationTypes['mutation'])
                ? $definitionBuilder->maybeBuildType($operationTypes['mutation'])
                : null)
        // @phpstan-ignore-next-line
            ->setSubscription(isset($operationTypes['subscription'])
                ? $definitionBuilder->maybeBuildType($operationTypes['subscription'])
                : null)
            ->setTypeLoader(static fn (string $name): ?Type => $definitionBuilder->maybeBuildType($name))
            ->setDirectives($directives)
            ->setAstNode($schemaDef)
            ->setTypes(fn (): array => array_map(
                static fn (TypeDefinitionNode $def): Type => $definitionBuilder->buildType($def->getName()->value),
                $typeDefinitionsMap,
            ))
    );
}