Digia\GraphQL\Schema\Building\BuildingContext

Complexity

Total Complexity

12

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	buildDirectives()	0	21	3
A	getSchemaDefinition()	0	3	1
A	buildQueryType()	0	4	2
A	buildSubscriptionType()	0	4	2
A	buildTypes()	0	5	1
A	__construct()	0	8	1
A	buildMutationType()	0	4	2

<?php

namespace Digia\GraphQL\Schema\Building;

use Digia\GraphQL\Language\Node\DirectiveDefinitionNode;
use Digia\GraphQL\Language\Node\DocumentNode;
use Digia\GraphQL\Language\Node\SchemaDefinitionNode;
use Digia\GraphQL\Language\Node\TypeDefinitionNodeInterface;
use Digia\GraphQL\Schema\DefinitionBuilderInterface;
use Digia\GraphQL\Schema\ResolverRegistryInterface;
use Digia\GraphQL\Type\Definition\Directive;
use Digia\GraphQL\Type\Definition\TypeInterface;
use function Digia\GraphQL\Util\arraySome;

class BuildingContext implements BuildingContextInterface
{
    /**
     * @var ResolverRegistryInterface
     */
    protected $resolverRegistry;

    /**
     * @var DefinitionBuilderInterface
     */
    protected $definitionBuilder;

    /**
     * @var BuildingInfo
     */
    protected $info;

    /**
     * BuilderContext constructor.
     * @param ResolverRegistryInterface  $resolverRegistry
     * @param DefinitionBuilderInterface $definitionBuilder
     * @param BuildingInfo               $info
     */
    public function __construct(
        ResolverRegistryInterface $resolverRegistry,
        DefinitionBuilderInterface $definitionBuilder,
        BuildingInfo $info
    ) {
        $this->resolverRegistry  = $resolverRegistry;
        $this->definitionBuilder = $definitionBuilder;
        $this->info              = $info;
    }

    /**
     * @return TypeInterface|null
     */
    public function buildQueryType(): ?TypeInterface
    {
        $definition = $this->info->getOperationTypeDefinition('query');
        return null !== $definition ? $this->definitionBuilder->buildType($definition) : null;
    }

    /**
     * @return TypeInterface|null
     */
    public function buildMutationType(): ?TypeInterface
    {
        $definition = $this->info->getOperationTypeDefinition('mutation');
        return null !== $definition ? $this->definitionBuilder->buildType($definition) : null;
    }

    /**
     * @return TypeInterface|null
     */
    public function buildSubscriptionType(): ?TypeInterface
    {
        $definition = $this->info->getOperationTypeDefinition('subscription');
        return null !== $definition ? $this->definitionBuilder->buildType($definition) : null;
    }

    /**
     * @return TypeInterface[]
     */
    public function buildTypes(): array
    {
        return \array_map(function (TypeDefinitionNodeInterface $definition) {
            return $this->definitionBuilder->buildType($definition);
        }, \array_values($this->info->getTypeDefinitionMap()));
    }

    /**
     * @return Directive[]
     */
    public function buildDirectives(): array
    {
        $directives = \array_map(function (DirectiveDefinitionNode $definition) {
            return $this->definitionBuilder->buildDirective($definition);
        }, $this->info->getDirectiveDefinitions());

        $specifiedDirectivesMap = [
            'skip'       => SkipDirective(),
            'include'    => IncludeDirective(),
            'deprecated' => DeprecatedDirective(),
        ];

        foreach ($specifiedDirectivesMap as $name => $directive) {
            if (!arraySome($directives, function (Directive $directive) use ($name) {
                return $directive->getName() === $name;
            })) {
                $directives[] = $directive;
            }
        }

        return $directives;
    }

    /**
     * @return SchemaDefinitionNode|null
     */
    public function getSchemaDefinition(): ?SchemaDefinitionNode
    {
        return $this->info->getSchemaDefinition();
    }
}