DefinitionBuilder::buildDirective() - Code Metrics - Inspection of "WIP: Support for building schema" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#19)

by Christoffer
created 2018-02-28 18:02 UTC
DefinitionBuilder::buildDirective() A

↳ Parent: DefinitionBuilder
Complexity

Conditions	2
Paths	1
Size

Total Lines	10
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	8
nc	1
nop	1
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
<?php

namespace Digia\GraphQL\Language\AST\Schema;

use Digia\GraphQL\Language\AST\Node\Contract\NodeInterface;
use Digia\GraphQL\Language\AST\Node\Contract\TypeDefinitionNodeInterface;
use Digia\GraphQL\Language\AST\Node\Contract\TypeNodeInterface;
use Digia\GraphQL\Language\AST\Node\DirectiveDefinitionNode;
use Digia\GraphQL\Language\AST\Node\EnumTypeDefinitionNode;
use Digia\GraphQL\Language\AST\Node\EnumValueDefinitionNode;
use Digia\GraphQL\Language\AST\Node\FieldDefinitionNode;
use Digia\GraphQL\Language\AST\Node\InputObjectTypeDefinitionNode;
use Digia\GraphQL\Language\AST\Node\InputValueDefinitionNode;
use Digia\GraphQL\Language\AST\Node\InterfaceTypeDefinitionNode;
use Digia\GraphQL\Language\AST\Node\ListTypeNode;
use Digia\GraphQL\Language\AST\Node\NamedTypeNode;
use Digia\GraphQL\Language\AST\Node\NameNode;
use Digia\GraphQL\Language\AST\Node\NonNullTypeNode;
use Digia\GraphQL\Language\AST\Node\ObjectTypeDefinitionNode;
use Digia\GraphQL\Language\AST\Node\ScalarTypeDefinitionNode;
use Digia\GraphQL\Language\AST\Node\UnionTypeDefinitionNode;
use Digia\GraphQL\Language\AST\Schema\Builder\Contract\BuilderInterface;
filter:
    dependency_paths: ["lib/*"]
use Digia\GraphQL\Language\AST\Schema\Builder\Contract\DirectorInterface;
filter:
    dependency_paths: ["lib/*"]
use Digia\GraphQL\Language\AST\Schema\Contract\DefinitionBuilderInterface;
use Digia\GraphQL\Type\Definition\Contract\DirectiveInterface;
use Digia\GraphQL\Type\Definition\Contract\NamedTypeInterface;
use Digia\GraphQL\Type\Definition\Contract\TypeInterface;
use Digia\GraphQL\Type\Definition\EnumType;
use Digia\GraphQL\Type\Definition\InputObjectType;
use Digia\GraphQL\Type\Definition\InterfaceType;
use Digia\GraphQL\Type\Definition\ObjectType;
use Digia\GraphQL\Type\Definition\ScalarType;
use Digia\GraphQL\Type\Definition\UnionType;
use function Digia\GraphQL\Type\assertNullableType;
use function Digia\GraphQL\Type\GraphQLDirective;
use function Digia\GraphQL\Type\GraphQLEnumType;
use function Digia\GraphQL\Type\GraphQLInputObjectType;
use function Digia\GraphQL\Type\GraphQLInterfaceType;
use function Digia\GraphQL\Type\GraphQLList;
use function Digia\GraphQL\Type\GraphQLNonNull;
use function Digia\GraphQL\Type\GraphQLObjectType;
use function Digia\GraphQL\Type\GraphQLScalarType;
use function Digia\GraphQL\Type\GraphQLUnionType;
use function Digia\GraphQL\Type\specifiedScalarTypes;
use function Digia\GraphQL\Util\keyMap;
use function Digia\GraphQL\Util\keyValMap;

class DefinitionBuilder implements DefinitionBuilderInterface
{

    /**
     * @var array
     */
    protected $_cache = [];

    /**
     * @var array
     */
    protected $typeDefinitionsMap;

    /**
     * @var ?callable
     */

    protected $resolveTypeFunction;

    /**
     * DefinitionBuilder constructor.
     *
     * @param callable $resolveTypeFunction
     */
    public function __construct(callable $resolveTypeFunction)
    {
        $this->typeDefinitionsMap  = [];
        $this->resolveTypeFunction = $resolveTypeFunction;
        $this->_cache              = keyMap(
            array_merge(specifiedScalarTypes()/*, introspectionTypes()*/),
            function (NamedTypeInterface $type) {
                return $type->getName();
            }
        );
    }

    /**
     * @inheritdoc
     */
    public function setTypeDefinitionMap(array $typeDefinitionMap)
    {
        $this->typeDefinitionsMap = $typeDefinitionMap;
        return $this;
    }

    /**
     * @param NamedTypeNode|TypeDefinitionNodeInterface $node
     * @inheritdoc
     */
    public function buildType(NodeInterface $node): TypeInterface
    {
        $typeName = $node->getNameValue();
        $typeName = $node->getNameValue();

        if (!$this->isInCache($typeName)) {
            if ($node instanceof NamedTypeNode) {
                $definition = $this->getTypeDefinition($typeName);

                $this->setInCache(
                    $typeName,
                    null !== $definition ? $this->buildNamedType($definition) : $this->resolveType($node)
                );
            } else {
                $this->setInCache($typeName, $this->buildNamedType($node));
            }
        }

        return $this->getFromCache($typeName);

    }

    /**
     * @inheritdoc
     */
    public function buildDirective(DirectiveDefinitionNode $node): DirectiveInterface
    {
        return GraphQLDirective([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'locations'   => array_map(function (NameNode $node) {
                return $node->getValue();
            }, $node->getLocations()),
            'arguments'   => $node->hasArguments() ? $this->buildArguments($node->getArguments()) : [],
            'astNode'     => $node,
        ]);
    }

    /**
     * @param TypeNodeInterface $typeNode
     * @return TypeInterface
     * @throws \Exception
     * @throws \TypeError
     */
    protected function buildWrappedType(TypeNodeInterface $typeNode): TypeInterface
    {
        $typeDefinition = $this->buildType(getNamedTypeNode($typeNode));
        return buildWrappedType($typeDefinition, $typeNode);
    }

    /**
     * @param FieldDefinitionNode|InputValueDefinitionNode $node
     * @return array
     * @throws \Exception
     * @throws \TypeError
     */
    protected function buildField($node): array
    {
        return [
            'type'              => $this->buildWrappedType($node->getType()),
            'description'       => $node->getDescriptionValue(),
            'arguments'         => $node->hasArguments() ? $this->buildArguments($node->getArguments()) : [],
            'arguments'         => $node->/** @scrutinizer ignore-call */ hasArguments() ? $this->buildArguments($node->getArguments()) : [],
            // TODO: Implement support for deprecation reason
            'deprecationReason' => null,
            'astNode'           => $node,
        ];
    }

    /**
     * @param array $nodes
     * @return array
     */
    protected function buildArguments(array $nodes): array
    {
        return keyValMap(
            $nodes,
            function (InputValueDefinitionNode $value) {
                return $value->getNameValue();
            },
            function (InputValueDefinitionNode $value): array {
                return [
                    'type'         => $this->buildWrappedType($value->getType()),
                    'description'  => $value->getDescriptionValue(),
                    // TODO: Implement support for default value
                    'defaultValue' => null,
                    'astNode'      => $value,
                ];
            });
    }

    /**
     * @param TypeDefinitionNodeInterface $node
     * @return NamedTypeInterface
     * @throws \Exception
     */
    protected function buildNamedType(TypeDefinitionNodeInterface $node): NamedTypeInterface
    {
        if ($node instanceof ObjectTypeDefinitionNode) {
            return $this->buildObjectType($node);
        }
        if ($node instanceof InterfaceTypeDefinitionNode) {
            return $this->buildInterfaceType($node);
        }
        if ($node instanceof EnumTypeDefinitionNode) {
            return $this->buildEnumType($node);
        }
        if ($node instanceof UnionTypeDefinitionNode) {
            return $this->buildUnionType($node);
        }
        if ($node instanceof ScalarTypeDefinitionNode) {
            return $this->buildScalarType($node);
        }
        if ($node instanceof InputObjectTypeDefinitionNode) {
            return $this->buildInputObjectType($node);
        }

        throw new \Exception(sprintf('Type kind "%s" not supported.', $node->getKind()));
    }

    /**
     * @param ObjectTypeDefinitionNode $node
     * @return ObjectType
     */
    protected function buildObjectType(ObjectTypeDefinitionNode $node): ObjectType
    {
        return GraphQLObjectType([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'fields'      => function () use ($node) {
                return $this->buildFields($node);
            },
            'interfaces'  => function () use ($node) {
                return $node->hasInterfaces() ? array_map(function (InterfaceTypeDefinitionNode $interface) {
                    return $this->buildType($interface);
                }, $node->getInterfaces()) : [];
            },
        ]);
    }

    /**
     * @param ObjectTypeDefinitionNode|InterfaceTypeDefinitionNode|InputObjectTypeDefinitionNode $node
     * @return array
     */
    protected function buildFields($node): array
    {
        return $node->hasFields() ? keyValMap(
            $node->getFields(),
            function ($value) {
                return $value->getNameValue();
            },
            function ($value) {
                return $this->buildField($value);
            }
        ) : [];
    }

    /**
     * @param InterfaceTypeDefinitionNode $node
     * @return InterfaceType
     */
    protected function buildInterfaceType(InterfaceTypeDefinitionNode $node): InterfaceType
    {
        return GraphQLInterfaceType([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'fields'      => function () use ($node): array {
                return $this->buildFields($node);
            },
            'astNode'     => $node,
        ]);
    }

    /**
     * @param EnumTypeDefinitionNode $node
     * @return EnumType
     */
    protected function buildEnumType(EnumTypeDefinitionNode $node): EnumType
    {
        return GraphQLEnumType([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'values'      => $node->hasValues() ? keyValMap(
                $node->getValues(),
                function (EnumValueDefinitionNode $value): string {
                    return $value->getNameValue();

                },
                function (EnumValueDefinitionNode $value): array {
                    return [
                        'description'       => $value->getDescriptionValue(),
                        // TODO: Implement support for deprecation reason
                        'deprecationReason' => null,
                        'astNode'           => $value,
                    ];
                }
            ) : [],
            'astNode'     => $node,
        ]);
    }

    protected function buildUnionType(UnionTypeDefinitionNode $node): UnionType
    {
        return GraphQLUnionType([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'types'       => $node->hasTypes() ? array_map(function (TypeNodeInterface $type) {
                return $this->buildType($type);
            }, $node->getTypes()) : [],
            'astNode'     => $node,
        ]);
    }

    /**
     * @param ScalarTypeDefinitionNode $node
     * @return ScalarType
     */
    protected function buildScalarType(ScalarTypeDefinitionNode $node): ScalarType
    {
        return GraphQLScalarType([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'serialize'   => function ($value) {
                return $value;
            },
            'astNode'     => $node,
        ]);
    }

    /**
     * @param InputObjectTypeDefinitionNode $node
     * @return InputObjectType
     */
    protected function buildInputObjectType(InputObjectTypeDefinitionNode $node): InputObjectType
    {
        return GraphQLInputObjectType([
            'name'        => $node->getNameValue(),
            'description' => $node->getDescriptionValue(),
            'fields'      => $node->hasFields() ? keyValMap(
                $node->getFields(),
                function (InputValueDefinitionNode $value): string {
                    return $value->getNameValue();

                },
                function (InputValueDefinitionNode $value): array {
                    return [
                        'type'         => $this->buildWrappedType($value->getType()),
                        'description'  => $value->getDescriptionValue(),
                        // TODO: Implement support for default value
                        'defaultValue' => null,
                        'astNode'      => $value,
                    ];
                }) : [],
            'astNode'     => $node,
        ]);
    }

    /**
     * @param string $key
     * @return bool
     */
    protected function isInCache(string $key): bool
    {
        return isset($this->_cache[$key]);
    }

    /**
     * @inheritdoc
     */
    protected function getFromCache(string $typeName): ?TypeInterface
    {
        return $this->_cache[$typeName] ?? null;
    }

    /**
     * @param string $key
     * @param mixed  $value
     */
    protected function setInCache(string $key, $value)
    {
        $this->_cache[$key] = $value;
    }

    /**
     * @inheritdoc
     */
    protected function resolveType(NodeInterface $node): TypeInterface
    {
        return call_user_func($this->resolveTypeFunction, $node);
    }

    /**
     * @param string $typeName
     * @return TypeDefinitionNodeInterface|null
     */
    protected function getTypeDefinition(string $typeName): ?TypeDefinitionNodeInterface
    {
        return $this->typeDefinitionsMap[$typeName] ?? null;
    }
}

/**
 * @param TypeNodeInterface $typeNode
 * @return NamedTypeNode
 */
function getNamedTypeNode(TypeNodeInterface $typeNode): NamedTypeNode
{
    $namedType = $typeNode;

    while ($namedType instanceof ListTypeNode || $namedType instanceof NonNullTypeNode) {
        $namedType = $namedType->getType();
    }

    return $namedType;

}

/**
 * @param TypeInterface                        $innerType
 * @param NamedTypeInterface|TypeNodeInterface $inputTypeNode
 * @return TypeInterface
 * @throws \TypeError
 * @throws \Exception
 */
function buildWrappedType(TypeInterface $innerType, TypeNodeInterface $inputTypeNode): TypeInterface
{
    if ($inputTypeNode instanceof ListTypeNode) {
        return GraphQLList(buildWrappedType($innerType, $inputTypeNode->getType()));
    }
    if ($inputTypeNode instanceof NonNullTypeNode) {
        $wrappedType = buildWrappedType($innerType, $inputTypeNode->getType());
        return GraphQLNonNull(assertNullableType($wrappedType));
    }

    return $innerType;
}

digiaonline / graphql-php

Pull Request — master (#19)

DefinitionBuilder::buildDirective() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
