Youshido\GraphQL\Definition\QueryType

Complexity

Total Complexity

14

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

61.36%

Importance

Changes	8
Bugs	3	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	9	2
A	getName()	0	4	1
C	build()	0	52	11

<?php
/**
 * Date: 03.12.15
 *
 * @author Portey Vasil <portey@gmail.com>
 */

namespace Youshido\GraphQL\Definition;

use Youshido\GraphQL\Definition\Traits\TypeCollectorTrait;
use Youshido\GraphQL\Schema;
use Youshido\GraphQL\Type\Config\TypeConfigInterface;
use Youshido\GraphQL\Type\Field\Field;
use Youshido\GraphQL\Type\ListType\ListType;
use Youshido\GraphQL\Type\Object\AbstractObjectType;
use Youshido\GraphQL\Type\TypeInterface;
use Youshido\GraphQL\Type\TypeMap;

class QueryType extends AbstractObjectType
{
    use TypeCollectorTrait;

    public function resolve($value = null, $args = [])
    {
        /** @var Schema|Field $value */
        if ($value instanceof Schema) {
            return $value->getQueryType();
        }

        return $value->getConfig()->getType();
    }

    /**
     * @return String type name
     */
    public function getName()
    {
        return '__Type';
    }

    protected function build(TypeConfigInterface $config)
    {
        $config
            ->addField('name', TypeMap::TYPE_STRING)
            ->addField('kind', TypeMap::TYPE_STRING)
            ->addField('description', TypeMap::TYPE_STRING)
            ->addField('ofType', new QueryType(), [
                'resolve' => function ($value) {
                    if ($value->getKind() == TypeMap::KIND_LIST) {
                        return $value->getConfig()->getItem();
                    }

                    return null;
                }
            ])
            ->addField('inputFields', new InputValueListType())
            ->addField('enumValues', new EnumValueListType())
            ->addField('fields', new FieldListType())
            ->addField('interfaces', new InterfaceListType())
            ->addField('possibleTypes', new ListType(new QueryType()), [
                'resolve' => function ($value) {
                    if ($value) {
                        if ($value->getKind() == TypeMap::KIND_INTERFACE) {
                            $this->collectTypes(SchemaType::$schema->getQueryType());

                            $possibleTypes = [];
                            foreach ($this->types as $type) {
                                /** @var $type TypeInterface */
                                if ($type->getKind() == TypeMap::KIND_OBJECT) {
                                    $interfaces = $type->getConfig()->getInterfaces();

                                    if ($interfaces) {
                                        foreach ($interfaces as $interface) {
                                            if (get_class($interface) == get_class($value)) {
                                                $possibleTypes[] = $type;
                                            }
                                        }
                                    }
                                }
                            }

                            return $possibleTypes ?: [];
                        } elseif ($value->getKind() == TypeMap::KIND_UNION) {
                            return $value->getTypes();
                        }

                    }

                    return null;
                }
            ]);
    }
}