Bakery\Support\TypeRegistry

Complexity

Total Complexity

39

Size/Duplication

Total Lines	392
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	ID()	0	3	1
A	__sleep()	0	3	1
A	addModelSchema()	0	9	1
A	string()	0	3	1
A	hasType()	0	3	1
A	setTypes()	0	3	1
A	__wakeup()	0	4	1
A	getTypes()	0	3	1
A	getSchemaForModel()	0	14	1
A	getTypeInstances()	0	3	1
A	field()	0	7	2
A	addTypes()	0	5	3
A	boolean()	0	3	1
A	int()	0	3	1
A	setTypeInstances()	0	3	1
A	type()	0	7	2
A	getModelSchema()	0	8	1
A	polymorphic()	0	3	1
A	resolveSchemaForModel()	0	10	1
A	hasSchemaForModel()	0	5	2
A	__construct()	0	4	1
A	getType()	0	20	4
A	addType()	0	5	2
A	float()	0	3	1
A	resolve()	0	20	3
A	eloquent()	0	3	1
A	addModelSchemas()	0	4	2

<?php

namespace Bakery\Support;

use Bakery\Utils\Utils;
use Bakery\Fields\Field;
use Bakery\Eloquent\ModelSchema;
use Bakery\Fields\EloquentField;
use Bakery\Exceptions\TypeNotFound;
use Bakery\Fields\PolymorphicField;
use Bakery\Types\Definitions\RootType;
use Illuminate\Database\Eloquent\Model;
use Bakery\Types\Definitions\InternalType;
use Bakery\Types\Definitions\ReferenceType;
use GraphQL\Type\Definition\Type as GraphQLType;

class TypeRegistry
{
    /**
     * The registered types.
     *
     * @var array
     */
    protected $types = [];

    /**
     * The GraphQL type instances.
     *
     * @var array
     */
    protected $typeInstances = [];

    /**
     * The model schema instances.
     *
     * @var \Illuminate\Support\Collection
     */
    protected $modelSchemas;

    /**
     * The model schemas keyed by model class name.
     *
     * @var \Illuminate\Support\Collection
     */
    protected $schemasByModel;

    /**
     * Bakery constructor.
     */
    public function __construct()
    {
        $this->modelSchemas = collect();
        $this->schemasByModel = collect();
    }

    /**
     * Add types to the registry.
     *
     * @param array $classes
     */
    public function addTypes(array $classes)
    {
        foreach ($classes as $class) {
            $class = is_object($class) ? $class : resolve($class);
            $this->addType($class);

It seems like $class can also be of type Illuminate\Contracts\Foundation\Application; however, parameter $type of Bakery\Support\TypeRegistry::addType() does only seem to accept Bakery\Types\Definitions\RootType, maybe add an additional type check?

        }
    }

    /**
     * Explicitly set all the types of the registry.
     *
     * @param $types
     * @return void
     */
    public function setTypes($types)
    {
        $this->types = $types;
    }

    /**
     * Get all the types of the registry.
     *
     * @return array
     */
    public function getTypes()
    {
        return $this->types;
    }

    /**
     * Add a type to the registry.
     *
     * @param \Bakery\Types\Definitions\RootType $type
     * @param string|null $name
     */
    public function addType(RootType $type, string $name = null)
    {
        $type->setRegistry($this);
        $name = $name ?: $type->getName();
        $this->types[$name] = $type;
    }

    /**
     * Add the models as model schemas to the registry.
     *
     * @param \ArrayAccess|array $models
     */
    public function addModelSchemas($models)
    {
        foreach ($models as $model) {
            $this->addModelSchema($model);
        }
    }

    /**
     * Add a single model schema to the registry.
     *
     * @param string $class
     */
    public function addModelSchema(string $class)
    {
        Utils::invariant(is_subclass_of($class, ModelSchema::class), 'Model schema '.$class.' does not extend '.ModelSchema::class);

        /** @var ModelSchema $schema */
        $schema = new $class($this);

        $this->modelSchemas->put($class, $schema);
        $this->schemasByModel->put($schema->getModelClass(), $class);
    }

    /**
     * Get a model schema instance based on it's class name.
     *
     * @param string $class
     * @return mixed
     */
    public function getModelSchema(string $class): ModelSchema
    {
        Utils::invariant(
            $this->modelSchemas->has($class),
            $class.' is not registered as model schema in the schema\'s type registry.'
        );

        return $this->modelSchemas->get($class);
    }

    /**
     * Return a model schema for a Eloquent model instance.
     * This 'wraps' a model schema around it.
     *
     * @param mixed $model
     * @return \Bakery\Eloquent\ModelSchema
     */
    public function getSchemaForModel(Model $model): ModelSchema
    {
        $class = get_class($model);

        Utils::invariant(
            $this->hasSchemaForModel($class),
            $class.' has no registered model schema in the schema\'s type registry.'
        );

        $schemaClass = $this->schemasByModel->get($class);

        $modelSchema = new $schemaClass($this, $model);

        return $modelSchema;
    }

    /**
     * Resolve the schema for a model based on the class name.
     *
     * @param string $model
     * @return \Bakery\Eloquent\ModelSchema
     */
    public function resolveSchemaForModel(string $model): ModelSchema
    {
        Utils::invariant(
            $this->hasSchemaForModel($model),
            'Model '.$model.' has no registered model schema in the schema\'s type registry.'
        );

        $schema = $this->schemasByModel->get($model);

        return $this->getModelSchema($schema);
    }

    /**
     * Returns if there is a model schema for a model registered.
     *
     * @param $model
     * @return bool
     */
    public function hasSchemaForModel($model): bool
    {
        $model = is_string($model) ? $model : get_class($model);

        return $this->schemasByModel->has($model);
    }

    /**
     * Return if the name is registered as a type.
     *
     * @param string $name
     * @return bool
     */
    public function hasType(string $name): bool
    {
        return array_key_exists($name, $this->types);
    }

    /**
     * Get a type by name.
     * This can be a string or a class path of a Type that has that name.
     *
     * @param string $name
     * @return \Bakery\Types\Definitions\RootType|null
     */
    public function getType(string $name): ?RootType
    {
        // If the string is the name of the type we return it straight away.
        if ($this->hasType($name)) {
            return $this->types[$name];
        }

        // If the string is a class, we resolve it, check if it is an instance of type and grab it's name.
        // and then call this method again to check.
        if (class_exists($name)) {
            $instance = resolve($name);

            if ($instance instanceof RootType) {
                $name = $instance->getName();

                return $this->getType($name);
            }
        }

        return null;
    }

    /**
     * Resolve a type from the registry.
     *
     * @param string $name
     * @return GraphQLType
     * @throws \Bakery\Exceptions\TypeNotFound
     */
    public function resolve(string $name): GraphQLType
    {
        $type = $this->getType($name);

        if (! $type) {

$type is of type Bakery\Types\Definitions\RootType, thus it always evaluated to true.

            throw new TypeNotFound('Type '.$name.' not found.');
        }

        $name = $type->getName();

        // If we already have an instance of this type, return it.
        if (isset($this->typeInstances[$name])) {
            return $this->typeInstances[$name];
        }

        // Otherwise we create it and store it for future references.
        $type = $type->toType();
        $this->typeInstances[$name] = $type;

        return $type;
    }

    /**
     * Get the type instances of Bakery.
     *
     * @return array
     */
    public function getTypeInstances()
    {
        return $this->typeInstances;
    }

    /**
     * Set the type instances.
     *
     * @param array $typeInstances
     */
    public function setTypeInstances(array $typeInstances)
    {
        $this->typeInstances = $typeInstances;
    }

    /**
     * Construct a new field.
     *
     * @param $type
     * @return \Bakery\Fields\Field
     */
    public function field($type): Field
    {
        if (is_string($type)) {
            $type = new ReferenceType($this, $type);
        }

        return new Field($this, $type);
    }

    /**
     * Create a new Eloquent field.
     *
     * @param string $modelSchema
     * @return \Bakery\Fields\EloquentField
     */
    public function eloquent(string $modelSchema): EloquentField
    {
        return new EloquentField($this, $modelSchema);
    }

    /**
     * Create a new polymorphic field.
     *
     * @param array $modelSchemas
     * @return \Bakery\Fields\PolymorphicField
     */
    public function polymorphic(array $modelSchemas): PolymorphicField
    {
        return new PolymorphicField($this, $modelSchemas);
    }

    /**
     * Construct a new type.
     *
     * @param $type
     * @return \Bakery\Types\Definitions\RootType
     */
    public function type($type): RootType
    {
        if (is_string($type)) {
            return (new ReferenceType($this, $type))->setRegistry($this);
        }

        return (new RootType($this))->setRegistry($this);
    }

    /**
     * Construct a new ID type.
     *
     * @return \Bakery\Types\Definitions\InternalType
     */
    public function ID()
    {
        return new InternalType($this, GraphQLType::ID());
    }

    /**
     * Construct a new boolean type.
     *
     * @return \Bakery\Types\Definitions\InternalType
     */
    public function boolean()
    {
        return new InternalType($this, GraphQLType::boolean());
    }

    /**
     * Construct a new string type.
     *
     * @return \Bakery\Types\Definitions\InternalType
     */
    public function string()
    {
        return new InternalType($this, GraphQLType::string());
    }

    /**
     * Construct a new int type.
     *
     * @return \Bakery\Types\Definitions\InternalType
     */
    public function int()
    {
        return new InternalType($this, GraphQLType::int());
    }

    /**
     * Construct a new float type.
     *
     * @return \Bakery\Types\Definitions\InternalType
     */
    public function float()
    {
        return new InternalType($this, GraphQLType::float());
    }

    /**
     * Invoked when the object is being serialized.
     *
     * @return array
     */
    public function __sleep()
    {
        return ['types', 'typeInstances'];
    }

    /**
     * Invoked when the object is being unserialized.
     */
    public function __wakeup()
    {
        $this->modelSchemas = collect();
        $this->schemasByModel = collect();
    }
}