Cycle\ORM\Factory

Complexity

Total Complexity

37

Size/Duplication

Total Lines	285
Duplicated Lines	0 %

Test Coverage

Coverage

96.23%

Importance

Changes	3
Bugs	1	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	repository()	0	18	2
A	collection()	0	18	6
A	source()	0	30	6
A	mapper()	0	15	2
A	database()	0	3	1
A	loader()	0	26	3
A	makeTypecastHandler()	0	15	2
A	withDefaultSchemaClasses()	0	7	1
A	relation()	0	19	1
B	typecast()	0	43	9
A	withCollectionFactory()	0	14	2
A	make()	0	5	1
A	__construct()	0	9	1

<?php

declare(strict_types=1);

namespace Cycle\ORM;

use Cycle\Database\DatabaseInterface;
use Cycle\Database\DatabaseProviderInterface;
use Cycle\ORM\Collection\ArrayCollectionFactory;
use Cycle\ORM\Collection\CollectionFactoryInterface;
use Cycle\ORM\Config\RelationConfig;
use Cycle\ORM\Exception\FactoryTypecastException;
use Cycle\ORM\Exception\TypecastException;
use Cycle\ORM\Mapper\Mapper;
use Cycle\ORM\Parser\CompositeTypecast;
use Cycle\ORM\Parser\Typecast;
use Cycle\ORM\Parser\TypecastInterface;
use Cycle\ORM\Service\SourceProviderInterface;
use Cycle\ORM\Relation\RelationInterface;
use Cycle\ORM\Select\Loader\ParentLoader;
use Cycle\ORM\Select\Loader\SubclassLoader;
use Cycle\ORM\Select\LoaderInterface;
use Cycle\ORM\Select\Repository;
use Cycle\ORM\Select\ScopeInterface;
use Cycle\ORM\Select\Source;
use Cycle\ORM\Select\SourceInterface;
use Spiral\Core\Container;
use Spiral\Core\FactoryInterface as CoreFactory;

final class Factory implements FactoryInterface
{
    private RelationConfig $config;
    private CoreFactory $factory;

    /** @var array<int, string> */
    private array $defaults = [
        SchemaInterface::REPOSITORY => Repository::class,
        SchemaInterface::SOURCE => Source::class,
        SchemaInterface::MAPPER => Mapper::class,
        SchemaInterface::SCOPE => null,
        SchemaInterface::TYPECAST_HANDLER => null,
    ];

    /** @var array<string, CollectionFactoryInterface> */
    private array $collectionFactoryAlias = [];

    /**
     * @var array<string, CollectionFactoryInterface>
     *
     * @psalm-var array<class-string, CollectionFactoryInterface>
     */
    private array $collectionFactoryInterface = [];

    private CollectionFactoryInterface $defaultCollectionFactory;

    public function __construct(
        private DatabaseProviderInterface $dbal,
        RelationConfig $config = null,
        CoreFactory $factory = null,
        CollectionFactoryInterface $defaultCollectionFactory = null
    ) {
        $this->config = $config ?? RelationConfig::getDefault();
        $this->factory = $factory ?? new Container();
        $this->defaultCollectionFactory = $defaultCollectionFactory ?? new ArrayCollectionFactory();
    }

    public function make(
        string $alias,
        array $parameters = []
    ): mixed {
        return $this->factory->make($alias, $parameters);
    }

    public function typecast(SchemaInterface $schema, DatabaseInterface $database, string $role): ?TypecastInterface
    {
        // Get parent's typecast
        $parent = $schema->define($role, SchemaInterface::PARENT);
        $parentHandler = $parent === null ? null : $this->typecast($schema, $database, $parent);
        $handlers = [];

        // Schema's `typecast` option
        $rules = (array)$schema->define($role, SchemaInterface::TYPECAST);
        $handler = $schema->define($role, SchemaInterface::TYPECAST_HANDLER)
            ?? $this->defaults[SchemaInterface::TYPECAST_HANDLER];

        // Create basic typecast implementation
        try {
            if ($handler === null) {
                if (!$rules) {

The expression $rules of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                    return $parentHandler;
                }

                $handlers[] = new Typecast($database);
            } elseif (\is_array($handler)) { // We need to use composite typecast for array
                foreach ($handler as $type) {
                    $handlers[] = $this->makeTypecastHandler($type, $database, $schema, $role);
                }
            } else {
                $handlers[] = $this->makeTypecastHandler($handler, $database, $schema, $role);
            }
        } catch (\Throwable $e) {
            throw new FactoryTypecastException(
                message: \sprintf(
                    'Bad typecast handler declaration for the `%s` role. %s',
                    $role,
                    $e->getMessage()
                ),
                code: $e->getCode(),
                previous: $e,
            );
        }
        $handler = count($handlers) === 1 ? reset($handlers) : new CompositeTypecast(...$handlers);
        $handler->setRules($rules);
        return $parentHandler === null
            ? $handler
            : new CompositeTypecast($parentHandler, $handler);
    }

    public function mapper(ORMInterface $orm, string $role): MapperInterface
    {
        $schema = $orm->getSchema();
        $class = $schema->define($role, SchemaInterface::MAPPER) ?? $this->defaults[SchemaInterface::MAPPER];

        if (!\is_subclass_of($class, MapperInterface::class)) {
            throw new TypecastException(sprintf('%s does not implement %s.', $class, MapperInterface::class));
        }

        return $this->factory->make(

The expression return $this->factory->make($class, array('orm' => $orm, 'role' => $role, 'schema' => $schema->define($role, Cycle\ORM\SchemaInterface::SCHEMA))) could return the type null which is incompatible with the type-hinted return Cycle\ORM\MapperInterface. Consider adding an additional type-check to rule them out.

            $class,
            [
                'orm' => $orm,
                'role' => $role,
                'schema' => $schema->define($role, SchemaInterface::SCHEMA),
            ]
        );
    }

    public function loader(
        SchemaInterface $schema,
        SourceProviderInterface $sourceProvider,
        string $role,
        string $relation
    ): LoaderInterface {
        if ($relation === self::PARENT_LOADER) {
            $parent = $schema->define($role, SchemaInterface::PARENT);
            return new ParentLoader($schema, $sourceProvider, $this, $role, $parent);
        }
        if ($relation === self::CHILD_LOADER) {
            $parent = $schema->define($role, SchemaInterface::PARENT);
            return new SubclassLoader($schema, $sourceProvider, $this, $parent, $role);
        }
        $definition = $schema->defineRelation($role, $relation);

        return $this->config->getLoader($definition[Relation::TYPE])->resolve(

The expression return $this->config->getLoader($definition[Cycle\ORM\Relation::TYPE])->resolve($this->factory, array('ormSchema' => $schema, 'sourceProvider' => $sourceProvider, 'factory' => $this, 'role' => $role, 'name' => $relation, 'target' => $definition[Cycle\ORM\Relation::TARGET], 'schema' => $definition[Cycle\ORM\Relation::SCHEMA])) could return the type null which is incompatible with the type-hinted return Cycle\ORM\Select\LoaderInterface. Consider adding an additional type-check to rule them out.

            $this->factory,
            [
                'ormSchema' => $schema,
                'sourceProvider' => $sourceProvider,
                'factory' => $this,
                'role' => $role,
                'name' => $relation,
                'target' => $definition[Relation::TARGET],
                'schema' => $definition[Relation::SCHEMA],
            ]
        );
    }

    public function collection(
        string $name = null
    ): CollectionFactoryInterface {
        if ($name === null) {
            return $this->defaultCollectionFactory;
        }
        if (array_key_exists($name, $this->collectionFactoryAlias)) {
            return $this->collectionFactoryAlias[$name];
        }
        // Find by interface
        if (\class_exists($name)) {
            foreach ($this->collectionFactoryInterface as $interface => $factory) {
                if (\is_subclass_of($name, $interface, true)) {
                    return $this->collectionFactoryAlias[$name] = $factory->withCollectionClass($name);
                }
            }
        }
        return $this->collectionFactoryAlias[$name] = $this->factory->make($name);

The expression return $this->collectionFactoryAlias[$name] = $this->factory->make($name) could return the type null which is incompatible with the type-hinted return Cycle\ORM\Collection\CollectionFactoryInterface. Consider adding an additional type-check to rule them out.

    }

    public function relation(
        ORMInterface $orm,
        SchemaInterface $schema,
        string $role,
        string $relation
    ): RelationInterface {
        $relSchema = $schema->defineRelation($role, $relation);
        $type = $relSchema[Relation::TYPE];

        return $this->config->getRelation($type)->resolve(

The expression return $this->config->getRelation($type)->resolve($this->factory, array('orm' => $orm, 'role' => $role, 'name' => $relation, 'target' => $relSchema[Cycle\ORM\Relation::TARGET], 'schema' => $relSchema[Cycle\ORM\Relation::SCHEMA] + array(Cycle\ORM\Relation::LOAD => $relSchema[Cycle\ORM\Relation::LOAD] ?? null) + array(Cycle\ORM\Relation::COLLECTION_TYPE => $relSchema[Cycle\ORM\Relation::COLLECTION_TYPE] ?? null))) could return the type null which is incompatible with the type-hinted return Cycle\ORM\Relation\RelationInterface. Consider adding an additional type-check to rule them out.

            $this->factory,
            [
                'orm' => $orm,
                'role' => $role,
                'name' => $relation,
                'target' => $relSchema[Relation::TARGET],
                'schema' => $relSchema[Relation::SCHEMA]
                    + [Relation::LOAD => $relSchema[Relation::LOAD] ?? null]
                    + [Relation::COLLECTION_TYPE => $relSchema[Relation::COLLECTION_TYPE] ?? null],
            ]
        );
    }

    public function database(string $database = null): DatabaseInterface
    {
        return $this->dbal->database($database);
    }

    public function repository(
        ORMInterface $orm,
        SchemaInterface $schema,
        string $role,
        ?Select $select
    ): RepositoryInterface {
        $class = $schema->define($role, SchemaInterface::REPOSITORY) ?? $this->defaults[SchemaInterface::REPOSITORY];

        if (!\is_subclass_of($class, RepositoryInterface::class)) {
            throw new TypecastException($class . ' does not implement ' . RepositoryInterface::class);
        }

        return $this->factory->make(

The expression return $this->factory->make($class, array('select' => $select, 'orm' => $orm, 'role' => $role)) could return the type null which is incompatible with the type-hinted return Cycle\ORM\RepositoryInterface. Consider adding an additional type-check to rule them out.

            $class,
            [
                'select' => $select,
                'orm' => $orm,
                'role' => $role,
            ]
        );
    }

    public function source(
        SchemaInterface $schema,
        string $role
    ): SourceInterface {
        /** @var class-string<SourceInterface> $source */
        $source = $schema->define($role, SchemaInterface::SOURCE) ?? $this->defaults[SchemaInterface::SOURCE];

        if (!\is_subclass_of($source, SourceInterface::class)) {
            throw new TypecastException($source . ' does not implement ' . SourceInterface::class);
        }

        $table = $schema->define($role, SchemaInterface::TABLE);
        $database = $this->database($schema->define($role, SchemaInterface::DATABASE));

        $source = $source !== Source::class
            ? $this->factory->make($source, ['role' => $role, 'table' => $table, 'database' => $database])
            : new Source($database, $table);

        /** @var class-string<ScopeInterface>|ScopeInterface|null $scope */
        $scope = $schema->define($role, SchemaInterface::SCOPE) ?? $this->defaults[SchemaInterface::SCOPE];

        if ($scope === null) {
            return $source;

The expression return $source could return the type null which is incompatible with the type-hinted return Cycle\ORM\Select\SourceInterface. Consider adding an additional type-check to rule them out.

        }

        if (!\is_subclass_of($scope, ScopeInterface::class)) {
            throw new TypecastException(sprintf('%s does not implement %s.', $scope, ScopeInterface::class));
        }

        return $source->withScope(\is_object($scope) ? $scope : $this->factory->make($scope));

The method withScope() does not exist on null.

The expression return $source->withScope(is_object($scope) ? $scope : $this->factory->make($scope)) could return the type null which is incompatible with the type-hinted return Cycle\ORM\Select\SourceInterface. Consider adding an additional type-check to rule them out.

    }

    public function withDefaultSchemaClasses(array $defaults): self
    {
        $clone = clone $this;

        $clone->defaults = $defaults + $this->defaults;

        return $clone;
    }

    public function withCollectionFactory(
        string $alias,
        CollectionFactoryInterface $factory,
        string $interface = null
    ): self {
        $clone = clone $this;
        $interface = $interface ?? $factory->getInterface();

        $clone->collectionFactoryAlias[$alias] = $factory;
        if ($interface !== null) {
            $clone->collectionFactoryInterface[$interface] = $factory;
        }

        return $clone;
    }

    /**
     * Make typecast handler from giver string or object
     *
     * @return TypecastInterface
     */
    private function makeTypecastHandler(
        string|TypecastInterface $handler,
        DatabaseInterface $database,
        SchemaInterface $schema,
        string $role
    ): TypecastInterface {
        // If handler is an object we don't need to use factory, we should return it as is
        if (is_object($handler)) {
            return $handler;
        }

        return $this->factory->make($handler, [

The expression return $this->factory->make($handler, array('database' => $database, 'schema' => $schema, 'role' => $role)) could return the type null which is incompatible with the type-hinted return Cycle\ORM\Parser\TypecastInterface. Consider adding an additional type-check to rule them out.

            'database' => $database,
            'schema' => $schema,
            'role' => $role,
        ]);
    }
}