Sirius\Orm\Mapper

Complexity

Total Complexity

29

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getReadConnection()	0	3	1
A	getWriteConnection()	0	3	1
A	getConfig()	0	3	1
A	__construct()	0	7	1
A	init()	0	2	1
A	patch()	0	3	1
A	newEntity()	0	9	1
A	newQuery()	0	5	1
A	__call()	0	11	3
A	newCollection()	0	9	3
A	use()	0	5	2
A	addRelation()	0	9	3
A	getRelations()	0	3	1
A	newSubselectQuery()	0	5	1
A	without()	0	6	1
A	getRelation()	0	11	3
A	hasRelation()	0	3	1
A	getHydrator()	0	3	1
A	runActionInTransaction()	0	12	2

<?php
declare(strict_types=1);

namespace Sirius\Orm;

use Sirius\Orm\Behaviour\BehaviourInterface;
use Sirius\Orm\Collection\Collection;
use Sirius\Orm\Contract\EntityInterface;
use Sirius\Orm\Contract\HydratorInterface;
use Sirius\Orm\Entity\GenericHydrator;
use Sirius\Orm\Entity\Patcher;
use Sirius\Orm\Relation\Relation;
use Sirius\Sql\Bindings;

/**
 * @method Query where($column, $value, $condition)
 * @method Query orderBy(string $expr, string ...$exprs)
 */
class Mapper
{
    /**
     * @var Orm
     */
    protected $orm;

    /**
     * @var ConnectionLocator
     */
    protected $connectionLocator;

    /**
     * @var MapperConfig
     */
    protected $mapperConfig;

    /**
     * @var HydratorInterface
     */
    protected $hydrator;

    /**
     * @var Behaviours
     */
    protected $behaviours;

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

    public function __construct(Orm $orm)
    {
        $this->orm               = $orm;
        $this->connectionLocator = $orm->getConnectionLocator();
        $this->behaviours        = new Behaviours();
        $this->hydrator          = new GenericHydrator($this->orm->getCastingManager());
        $this->init();
    }

    protected function init()
    {
    }

    public function __call(string $method, array $params)
    {
        switch ($method) {
            case 'where':
            case 'orderBy':
                $query = $this->newQuery();

                return $query->{$method}(...$params);
        }

        throw new \BadMethodCallException("Unknown method {$method} for class " . get_class($this));
    }

    /**
     * @return MapperConfig
     */
    public function getConfig(): MapperConfig
    {
        return $this->mapperConfig;
    }

    /**
     * @return HydratorInterface
     */
    public function getHydrator(): HydratorInterface
    {
        return $this->hydrator;
    }

    /**
     * Add behaviours to the mapper
     *
     * @param mixed ...$behaviours
     */
    public function use(...$behaviours)
    {
        /** @var BehaviourInterface $behaviour */
        foreach ($behaviours as $behaviour) {
            $this->behaviours->add($behaviour);
        }
    }

    /**
     * Create a clone of the mapper without the selected behaviour
     *
     * @param mixed ...$behaviours
     *
     * @return self
     */
    public function without(...$behaviours)
    {
        $mapper             = clone $this;
        $mapper->behaviours = $this->behaviours->without(...$behaviours);

        return $mapper;
    }

    public function newEntity(array $data): EntityInterface
    {
        $entity = $this->getHydrator()
                       ->hydrate(array_merge(
                           $this->getConfig()->getAttributeDefaults(),
                           $data
                       ));

        return $this->behaviours->apply($this, __FUNCTION__, $entity);
    }

    public function newCollection(array $datas = []): Collection
    {
        $entities = [];
        foreach ($datas as $data) {
            // if $data is an entity or some other object, keep it as is
            $entities[] = (is_array($data)) ? $this->newEntity($data) : $data;
        }

        return new Collection($entities, $this->hydrator);
    }

    public function patch($entity, array $data)
    {
        return (new Patcher($this))($entity, $data);
    }

    /**
     * @param string $name
     * @param array|Relation $relation
     */
    public function addRelation(string $name, $relation)
    {
        if (is_array($relation) || $relation instanceof Relation) {

$relation is always a sub-type of Sirius\Orm\Relation\Relation.

            $this->relations[$name] = $relation;

            return;
        }
        throw new \InvalidArgumentException(
            sprintf('The relation has to be a Relation instance or an array of configuration options')
        );
    }

    public function hasRelation(string $name): bool
    {
        return isset($this->relations[$name]);
    }

    public function getRelation(string $name): Relation
    {
        if (! $this->hasRelation($name)) {
            throw new \InvalidArgumentException("Relation named {$name} is not registered for this mapper");
        }

        if (is_array($this->relations[$name])) {
            $this->relations[$name] = $this->orm->createRelation($this, $name, $this->relations[$name]);
        }

        return $this->relations[$name];
    }

    public function getRelations(): array
    {
        return array_keys($this->relations);
    }

    public function newQuery()
    {
        $query = new Query($this->getReadConnection(), $this);

        return $this->behaviours->apply($this, __FUNCTION__, $query);
    }

    public function newSubselectQuery(Connection $connection, Bindings $bindings, string $indent)
    {
        $query = new Query($connection, $this, $bindings, $indent);

        return $this->behaviours->apply($this, __FUNCTION__, $query);
    }

    public function getReadConnection(): Connection
    {
        return $this->connectionLocator->getRead();

The expression return $this->connectionLocator->getRead() returns the type Atlas\Pdo\Connection which includes types incompatible with the type-hinted return Sirius\Orm\Connection.

    }

    public function getWriteConnection(): Connection
    {
        return $this->connectionLocator->getWrite();

The expression return $this->connectionLocator->getWrite() returns the type Atlas\Pdo\Connection which includes types incompatible with the type-hinted return Sirius\Orm\Connection.

    }

    protected function runActionInTransaction(Action\BaseAction $action)
    {
        $this->connectionLocator->lockToWrite(true);
        $this->getWriteConnection()->beginTransaction();
        try {
            $action->run();
            $this->getWriteConnection()->commit();

            return true;
        } catch (\Exception $e) {
            $this->getWriteConnection()->rollBack();
            throw $e;
        }
    }
}