Happyr\DoctrineSpecification\Repository\EntitySpecificationRepositoryTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	match()	0	6	1
A	matchSingleResult()	0	12	3
A	matchOneOrNullResult()	0	8	2
A	matchSingleScalarResult()	0	10	2
A	matchScalarResult()	0	6	1
A	getQuery()	0	10	2
A	getQueryBuilder()	0	7	2
A	iterate()	0	6	2
A	setAlias()	0	4	1
A	getAlias()	0	4	1
A	applySpecification()	0	18	6

<?php
declare(strict_types=1);

/**
 * This file is part of the Happyr Doctrine Specification package.
 *
 * (c) Tobias Nyholm <tobias@happyr.com>
 *     Kacper Gunia <kacper@gunia.me>
 *     Peter Gribanov <info@peter-gribanov.ru>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Happyr\DoctrineSpecification\Repository;

use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\NonUniqueResultException as DoctrineNonUniqueResultException;
use Doctrine\ORM\NoResultException as DoctrineNoResultException;
use Doctrine\ORM\Query;
use Doctrine\ORM\QueryBuilder;
use Happyr\DoctrineSpecification\Exception\NonUniqueResultException;
use Happyr\DoctrineSpecification\Exception\NoResultException;
use Happyr\DoctrineSpecification\Filter\Filter;
use Happyr\DoctrineSpecification\Query\QueryModifier;
use Happyr\DoctrineSpecification\Result\ResultModifier;

/**
 * This trait should be used by a class extending \Doctrine\ORM\EntityRepository.
 */
trait EntitySpecificationRepositoryTrait
{
    /**
     * @var string
     */
    private $alias = 'root';

    /**
     * Get results when you match with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @return mixed
     */
    public function match($specification, ?ResultModifier $modifier = null)
    {
        $query = $this->getQuery($specification, $modifier);

        return $query->execute();
    }

    /**
     * Get single result when you match with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @throw Exception\NonUniqueException  If more than one result is found
     * @throw Exception\NoResultException   If no results found
     *
     * @return mixed
     */
    public function matchSingleResult($specification, ?ResultModifier $modifier = null)
    {
        $query = $this->getQuery($specification, $modifier);

        try {
            return $query->getSingleResult();
        } catch (DoctrineNonUniqueResultException $e) {
            throw new NonUniqueResultException($e->getMessage(), $e->getCode(), $e);
        } catch (DoctrineNoResultException $e) {
            throw new NoResultException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * Get single result or null when you match with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @throw Exception\NonUniqueException  If more than one result is found
     *
     * @return mixed|null
     */
    public function matchOneOrNullResult($specification, ?ResultModifier $modifier = null)
    {
        try {
            return $this->matchSingleResult($specification, $modifier);
        } catch (NoResultException $e) {
            return null;
        }
    }

    /**
     * Get single scalar result when you match with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @throw Exception\NonUniqueException  If more than one result is found
     * @throw Exception\NoResultException   If no results found
     *
     * @return mixed
     */
    public function matchSingleScalarResult($specification, ?ResultModifier $modifier = null)
    {
        $query = $this->getQuery($specification, $modifier);

        try {
            return $query->getSingleScalarResult();
        } catch (DoctrineNonUniqueResultException $e) {
            throw new NonUniqueResultException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * Get scalar result when you match with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @throw Exception\NonUniqueException  If more than one result is found
     * @throw Exception\NoResultException   If no results found
     *
     * @return mixed
     */
    public function matchScalarResult($specification, ?ResultModifier $modifier = null)
    {
        $query = $this->getQuery($specification, $modifier);

        return $query->getScalarResult();
    }

    /**
     * Prepare a Query with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @return Query
     */
    public function getQuery($specification, ?ResultModifier $modifier = null): AbstractQuery
    {
        $query = $this->getQueryBuilder($specification)->getQuery();

        if (null !== $modifier) {
            $modifier->modify($query);
        }

        return $query;
    }

    /**
     * @param Filter|QueryModifier $specification
     * @param string|null          $alias
     *
     * @return QueryBuilder
     */
    public function getQueryBuilder($specification, ?string $alias = null): QueryBuilder
    {
        $qb = $this->createQueryBuilder($alias ?: $this->getAlias());

It seems like createQueryBuilder() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->applySpecification($qb, $specification, $alias);

        return $qb;
    }

    /**
     * Iterate results when you match with a Specification.
     *
     * @param Filter|QueryModifier $specification
     * @param ResultModifier|null  $modifier
     *
     * @return \Traversable<mixed>

The doc-type \Traversable<mixed> could not be parsed: Expected "|" or "end of type", but got "<" at position 12. (view supported doc-types)

     */
    public function iterate($specification, ?ResultModifier $modifier = null): \Traversable
    {
        foreach ($this->getQuery($specification, $modifier)->iterate() as $row) {
            yield current($row);
        }
    }

    /**
     * @param string $alias
     */
    public function setAlias(string $alias): void
    {
        $this->alias = $alias;
    }

    /**
     * @return string
     */
    public function getAlias(): string
    {
        return $this->alias;
    }

    /**
     * @param QueryBuilder         $queryBuilder
     * @param Filter|QueryModifier $specification
     * @param string|null          $alias
     *
     * @throws \InvalidArgumentException
     */
    protected function applySpecification(
        QueryBuilder $queryBuilder,
        $specification = null,
        ?string $alias = null
    ): void {
        if ($specification instanceof QueryModifier) {
            $specification->modify($queryBuilder, $alias ?: $this->getAlias());
        }

        if ($specification instanceof Filter) {
            $filter = $specification->getFilter($queryBuilder, $alias ?: $this->getAlias());
            $filter = trim($filter);

            if ('' !== $filter) {
                $queryBuilder->andWhere($filter);
            }
        }
    }
}