Fubhy\GraphQL\Schema

Complexity

Total Complexity

25

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

93.65%

Importance

Changes	3
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getQueryType()	0	4	1
A	getMutationType()	0	4	1
A	getDirective()	0	9	3
A	getDirectives()	0	14	2
A	getTypeMap()	0	15	2
A	getType()	0	5	2
C	typeMapReducer()	0	44	12
A	__wakeup()	0	7	1

<?php

namespace Fubhy\GraphQL;

use Fubhy\GraphQL\Type\Definition\FieldArgument;
use Fubhy\GraphQL\Type\Definition\Types\InterfaceType;
use Fubhy\GraphQL\Type\Definition\Types\ModifierInterface;
use Fubhy\GraphQL\Type\Definition\Types\ObjectType;
use Fubhy\GraphQL\Type\Definition\Types\Type;
use Fubhy\GraphQL\Type\Definition\Types\TypeInterface;
use Fubhy\GraphQL\Type\Definition\Types\UnionType;
use Fubhy\GraphQL\Type\Directives\Directive;
use Fubhy\GraphQL\Type\Introspection;

/**
 * Schema Definition
 *
 * A Schema is created by supplying the root types of each type of operation,
 * query and mutation (optional). A schema definition is then supplied to the
 * validator and executor.
 */
class Schema
{
    /**
     * @var \Fubhy\GraphQL\Type\Definition\Types\ObjectType|null
     */
    protected $mutationType;

    /**
     * @var \Fubhy\GraphQL\Type\Definition\Types\ObjectType
     */
    protected $queryType;

    /**
     * @var \Fubhy\GraphQL\Type\Directives\DirectiveInterface[]
     */
    protected $directives;

    /**
     * @var \Fubhy\GraphQL\Type\Definition\Types\TypeInterface[]
     */
    protected $typeMap;

    /**
     * Constructor.
     *
     * @param \Fubhy\GraphQL\Type\Definition\Types\TypeInterface $queryType
     * @param \Fubhy\GraphQL\Type\Definition\Types\TypeInterface|null $mutationType
     */
    public function __construct(TypeInterface $queryType, TypeInterface $mutationType = NULL)
    {
        $this->queryType = $queryType;

$queryType is of type object<Fubhy\GraphQL\Type\Definition\Types\TypeInterface>, but the property $queryType was declared to be of type object<Fubhy\GraphQL\Type\Definition\Types\ObjectType>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->mutationType = $mutationType;

It seems like $mutationType can also be of type object<Fubhy\GraphQL\Type\Definition\Types\TypeInterface>. However, the property $mutationType is declared as type object<Fubhy\GraphQL\Type\Definition\Types\ObjectType>|null. Maybe add an additional type check?

    }

    /**
     * @return \Fubhy\GraphQL\Type\Definition\Types\ObjectType
     */
    public function getQueryType()
    {
        return $this->queryType;
    }

    /**
     * @return \Fubhy\GraphQL\Type\Definition\Types\ObjectType|null
     */
    public function getMutationType()
    {
        return $this->mutationType;
    }

    /**
     * @param string $name
     *
     * @return \Fubhy\GraphQL\Type\Directives\DirectiveInterface|null
     */
    public function getDirective($name)
    {
        foreach ($this->getDirectives() as $directive) {
            if ($directive->getName() === $name) {
                return $directive;
            }
        }
        return NULL;
    }

    /**
     * @return \Fubhy\GraphQL\Type\Directives\DirectiveInterface[]
     */
    public function getDirectives()
    {
        if (!isset($this->directives)) {
            $include = Directive::includeDirective();
            $skip = Directive::skipDirective();

            $this->directives = [

It seems like array($include->getName() => $include, $skip->getName() => $skip) of type array<string,object<Fubhy\GraphQL\Type\Directives\DirectiveInterface>> is incompatible with the declared type array<integer,object<Fubhy\GraphQL\Type\Directives\DirectiveInterface>> of property $directives.

                $include->getName() => $include,
                $skip->getName() => $skip,
            ];
        }

        return $this->directives;
    }

    /**
     * @return \Fubhy\GraphQL\Type\Definition\Types\TypeInterface[]
     */
    public function getTypeMap()
    {
        if (!isset($this->typeMap)) {
            $input = [$this->getQueryType(), $this->getMutationType(), Introspection::schema()];
            $this->typeMap = array_reduce($input, [$this, 'typeMapReducer'], []);

It seems like array_reduce($input, array($this, 'typeMapReducer'), array()) of type * is incompatible with the declared type array<integer,object<Fubhy\GraphQL\Type\Definition\Types\TypeInterface>> of property $typeMap.

            $this->typeMap['Boolean'] = Type::booleanType();
            $this->typeMap['Float'] = Type::floatType();
            $this->typeMap['Id'] = Type::idType();
            $this->typeMap['Integer'] = Type::intType();
            $this->typeMap['String'] = Type::stringType();
        }

        return $this->typeMap;
    }

    /**
     * @param string $name
     *
     * @return \Fubhy\GraphQL\Type\Definition\Types\TypeInterface
     */
    public function getType($name)
    {
        $map = $this->getTypeMap();
        return isset($map[$name]) ? $map[$name] : NULL;
    }

    /**
     * @param \Fubhy\GraphQL\Type\Definition\Types\TypeInterface[] $map
     * @param mixed $type
     *
     * @return \Fubhy\GraphQL\Type\Definition\Types\TypeInterface[]
     */
    protected function typeMapReducer(array $map, $type)
    {
        if ($type instanceof ModifierInterface) {
            return $this->typeMapReducer($map, $type->getWrappedType());
        }

        if (!$type instanceof TypeInterface) {
            return $map;
        }

        if (!empty($map[$type->getName()])) {
            if ($type instanceof ObjectType || $type instanceof InterfaceType) {
                $type->setFields($map[$type->getName()]->getFields());

It seems like you code against a concrete implementation and not the interface Fubhy\GraphQL\Type\Definition\Types\TypeInterface as the method getFields() does only exist in the following implementations of said interface: Fubhy\GraphQL\Type\Definition\Types\InputObjectType, Fubhy\GraphQL\Type\Definition\Types\InterfaceType, Fubhy\GraphQL\Type\Definition\Types\ObjectType.

            }

            return $map;
        }

        $reducedMap = array_merge($map, [$type->getName() => $type]);
        if ($type instanceof InterfaceType || $type instanceof UnionType) {
            $reducedMap = array_reduce(
                $type->getPossibleTypes(), [$this, 'typeMapReducer'], $reducedMap
            );
        }

        if ($type instanceof ObjectType) {
            $reducedMap = array_reduce(
                $type->getInterfaces(), [$this, 'typeMapReducer'], $reducedMap
            );
        }

        if ($type instanceof ObjectType || $type instanceof InterfaceType) {
            foreach ($type->getFields() as $fieldName => $field) {
                $args = $field->getArguments();
                $reducedMap = array_reduce(array_map(function (FieldArgument $arg) {
                    return $arg->getType();
                }, $args), [$this, 'typeMapReducer'], $reducedMap);

                $reducedMap = $this->typeMapReducer($reducedMap, $field->getType());
            }
        }

        return $reducedMap;
    }

    /**
     * Re-populate static properties when de-serializing.
     */
    public function __wakeup() {
        Type::intType();
        Type::booleanType();
        Type::floatType();
        Type::idType();
        Type::stringType();
    }
}