Bdf\Prime\Repository\RepositoryQueryFactory

Complexity

Total Complexity

32

Size/Duplication

Total Lines	355
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	builder()	0	3	1
A	extension()	0	7	2
A	fromAlias()	0	3	1
A	keyValue()	0	13	3
A	__call()	0	7	2
A	isPrimaryKeyFilter()	0	15	4
A	make()	0	3	1
A	findById()	0	25	5
A	countKeyValue()	0	17	4
A	configure()	0	19	4
A	entities()	0	20	4

<?php

namespace Bdf\Prime\Repository;

use Bdf\Prime\Cache\CacheInterface;
use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Exception\QueryException;
use Bdf\Prime\Mapper\Metadata;
use Bdf\Prime\Query\CommandInterface;
use Bdf\Prime\Query\Compiler\Preprocessor\OrmPreprocessor;
use Bdf\Prime\Query\Contract\Cachable;
use Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface;
use Bdf\Prime\Query\Contract\ReadOperation;
use Bdf\Prime\Query\QueryInterface;
use Bdf\Prime\Query\QueryRepositoryExtension;
use Bdf\Prime\Query\ReadCommandInterface;

/**
 * Factory for repository queries
 */
class RepositoryQueryFactory
{
    /**
     * @var RepositoryInterface
     */
    private $repository;

    /**
     * @var ConnectionInterface
     */
    private $connection;

    /**
     * @var Metadata
     */
    private $metadata;

    /**
     * @var callable[]
     */
    private $queries;

    /**
     * Query result cache
     *
     * @var CacheInterface
     */
    private $resultCache;

    /**
     * Check if the repository can support optimised KeyValue query
     * If this value is false, keyValue() must returns null

Doc comment short description must be on a single line, further text should be a separate paragraph

     *
     * @var bool

Expected "boolean" but found "bool" for @var tag in member variable comment

     */
    private $supportsKeyValue;

    //===============//

No space found before comment text; expected "// ===============//" but found "//===============//"

    // Optimisations //
    //===============//

No space found before comment text; expected "// ===============//" but found "//===============//"

    /**
     * @var KeyValueQueryInterface
     */
    private $findByIdQuery;

Expected 1 blank line(s) before member var; 5 found

    /**
     * @var KeyValueQueryInterface
     */
    private $countKeyValueQuery;

    /**
     * Save extension instance for optimisation
     *
     * @var QueryRepositoryExtension
     */
    private $extension;


    /**
     * RepositoryQueryFactory constructor.
     *
     * @param RepositoryInterface $repository
     * @param CacheInterface|null $resultCache
     */
    public function __construct(RepositoryInterface $repository, ?CacheInterface $resultCache = null)

Expected 1 blank line before function; 2 found

    {
        $this->repository = $repository;
        $this->resultCache = $resultCache;

        $this->supportsKeyValue = empty($repository->constraints());

        $this->connection = $repository->connection();
        $this->queries = $repository->mapper()->queries();
        $this->metadata = $repository->metadata();
    }

    /**
     * Get query builder
     *
     * @return QueryInterface
     */
    public function builder()
    {
        return $this->fromAlias();
    }

    /**
     * Get query builder with a defined table alias on FROM clause
     *
     * @param string|null $alias The FROM table alias
     *
     * @return QueryInterface
     *
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    public function fromAlias(?string $alias = null)
    {
        return $this->configure($this->connection->builder(new OrmPreprocessor($this->repository)), $alias);
    }

    /**
     * Make a query
     *
     * @param string $query The query name or class name to make
     *
     * @return CommandInterface
     */
    public function make($query)
    {
        return $this->configure($this->connection->make($query, new OrmPreprocessor($this->repository)));
    }

    /**
     * Find entity by its primary key
     *
     * <code>
     * $queries->findById(2);
     * $queries->findById(['key1' => 1, 'key2' => 5]);
     * </code>
     *
     * @param array|string $id The entity PK. Use an array for composite PK
     *
     * @return mixed The entity or null if not found
     * @throws PrimeException When query fail
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function findById($id)

You must use "/**" style comments for a function comment

    {
        // Create a new query if cache is disabled
        if (!$this->supportsKeyValue) {
            $query = $this->builder();
        } else {
            if (!$this->findByIdQuery) {
                $this->findByIdQuery = $this->keyValue();
            }

            $query = $this->findByIdQuery;
        }

        if (is_array($id)) {
            if (!$this->isPrimaryKeyFilter($id)) {
                throw new QueryException('Only primary keys must be passed to findById()');
            }

            $query->where($id);
        } else {
            list($identifierName) = $this->metadata->primary['attributes'];
            $query->where($identifierName, $id);
        }

        return $query->first();
    }

    /**
     * Create a query for perform simple key / value search on the current repository
     *
     * /!\ Key value query cannot perform join queries (condition on relation is not allowed)
     *     And can perform only equality comparison

Doc comment long description must end with a full stop

     *
     * <code>
     * // Search by name
     * $queries->keyValue('name', 'myName')->first();
     *
     * // Get an empty key value query
     * $queries->keyValue()->where(...);
     *
     * // With criteria
     * $queries->keyValue(['name' => 'John', 'customer.id' => 5])->all();
     * </code>
     *
     * @param string|array|null $attribute The search attribute, or criteria
     * @param mixed $value The search value
     *
     * @return KeyValueQueryInterface|null The query, or null if not supported
     */
    public function keyValue($attribute = null, $value = null)
    {
        if (!$this->supportsKeyValue) {
            return null;
        }

        $query = $this->make(KeyValueQueryInterface::class);

        if ($attribute) {
            $query->where($attribute, $value);

The method where() does not exist on Bdf\Prime\Query\CommandInterface. It seems like you code against a sub-type of Bdf\Prime\Query\CommandInterface such as Bdf\Prime\Query\Contract\Query\KeyValueQueryInterface or Bdf\Prime\Query\QueryInterface or Bdf\Prime\Query\AbstractReadCommand.

        }

        return $query;
    }

    /**
     * Count rows on the current table with simple key / value search
     *
     * /!\ Key value query cannot perform join queries (condition on relation is not allowed)
     *     And can perform only equality comparison

Doc comment long description must end with a full stop

     *
     * <code>
     * // Count entities with myName as name value
     * $queries->countKeyValue('name', 'myName');
     *
     * // With criteria
     * $queries->countKeyValue(['name' => 'John', 'customer.id' => 5]);
     * </code>
     *
     * @param string|array|null $attribute The search attribute, or criteria
     * @param mixed $value The search value
     *
     * @return int
     * @throws PrimeException When query fail
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function countKeyValue($attribute = null, $value = null)

You must use "/**" style comments for a function comment

    {
        if (!$this->supportsKeyValue) {
            $query = $this->builder();
        } else {
            if (!$this->countKeyValueQuery) {
                $this->countKeyValueQuery = $this->keyValue();
            }

            $query = $this->countKeyValueQuery;
        }

        if ($attribute) {
            $query->where($attribute, $value);
        }

        return $query->count();

The method count() does not exist on Bdf\Prime\Query\QueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Query\QueryInterface.

    }

    /**
     * Create a query selecting all entities
     *
     * This method will configure query like :
     * SELECT * FROM entity WHERE pk IN (entity1.pk, entity2.pk, ...)
     *
     * /!\ All entities MUST have a valid primary key !
     *
     * <code>
     * // True if modifications occurs on database
     * $hasChanges = ($entities != $queries->entities($entities)->all());
     *
     * // Delete all entities
     * $queries->entities($entities)->delete();
     * </code>
     *
     * @param object[] $entities Array of entities to select
     *
     * @return QueryInterface
     */
    public function entities(array $entities)
    {
        $query = $this->repository->queries()->builder();

        if ($this->repository->mapper()->metadata()->isCompositePrimaryKey()) {
            foreach ($entities as $entity) {
                $query->orWhere($this->repository->mapper()->primaryCriteria($entity));
            }
        } else {
            $attribute = $this->repository->mapper()->metadata()->primary['attributes'][0];
            $keys = [];

            foreach ($entities as $entity) {
                $keys[] = $this->repository->extractOne($entity, $attribute);

The method extractOne() does not exist on Bdf\Prime\Repository\RepositoryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Repository\RepositoryInterface.

            }

            $query->where($attribute, 'in', $keys);
        }

        return $query;
    }

    /**
     * Delegates call to corresponding query
     *
     * @param string $name
     * @param string $arguments
     *
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        if (isset($this->queries[$name])) {
            return $this->queries[$name]($this->repository, ...$arguments);
        }

        return $this->builder()->$name(...$arguments);
    }

    /**
     * Configure the query for the current repository
     *
     * @param CommandInterface $query
     * @param string|null $alias The FROM table alias
     *
     * @return CommandInterface
     */
    private function configure(CommandInterface $query, ?string $alias = null)

Private method name "RepositoryQueryFactory::configure" must be prefixed with an underscore

    {
        if ($this->metadata->useQuoteIdentifier) {
            $query->useQuoteIdentifier();
        }

        $query->setCustomFilters($this->repository->mapper()->filters());
        $query->from($this->metadata->table, $alias);

        if ($query instanceof ReadCommandInterface) {
            $query->setCollectionFactory($this->repository->collectionFactory());
            $this->extension()->apply($query);
        }

        if ($query instanceof Cachable) {
            $query->setCache($this->resultCache);
        }

        return $query;
    }

    /**
     * Optimise query extension creation
     *
     * @return QueryRepositoryExtension
     */
    private function extension()

Private method name "RepositoryQueryFactory::extension" must be prefixed with an underscore

    {
        if (!$this->extension) {
            $this->extension = new QueryRepositoryExtension($this->repository);
        }

        return clone $this->extension;
    }

    /**
     * Check if the given filter exactly match with primary key attributes
     *
     * @param array $filter
     *
     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    private function isPrimaryKeyFilter(array $filter): bool

Private method name "RepositoryQueryFactory::isPrimaryKeyFilter" must be prefixed with an underscore

    {
        $pk = $this->metadata->primary['attributes'];

        if (count($filter) !== count($pk)) {
            return false;
        }

        foreach ($pk as $key) {
            if (!isset($filter[$key])) {
                return false;
            }
        }

        return true;
    }
}