Zing\QueryBuilder\Filters\ExactFilter

Complexity

Total Complexity

11

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	apply()	0	11	4
A	withPropertyConstraint()	0	7	2
A	isRelationProperty()	0	11	3
A	withRelationConstraint()	0	12	1

<?php

declare(strict_types=1);

namespace Zing\QueryBuilder\Filters;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Query\Expression;
use Illuminate\Support\Str;
use Zing\QueryBuilder\Concerns\NestedRelation;
use Zing\QueryBuilder\Contracts\Filter;

class ExactFilter implements Filter
{
    use NestedRelation;

    /**
     * @var string[]
     */
    protected $relationConstraints = [];

    /**
     * @var bool
     */
    protected $autoRelationConstraints = true;

    public function __construct(bool $autoRelationConstraints = true)
    {
        $this->autoRelationConstraints = $autoRelationConstraints;
    }

    /**
     * @param mixed $value
     * @param string|\Illuminate\Database\Query\Expression $property
     */
    public function apply(Builder $query, $value, $property): Builder
    {
        if ($property instanceof Expression) {
            return $this->withPropertyConstraint($query, $value, $property);
        }

        if ($this->autoRelationConstraints && $this->isRelationProperty($query, $property)) {
            return $this->withRelationConstraint($query, $value, $property);
        }

        return $this->withPropertyConstraint($query, $value, $property);
    }

    /**
     * @param mixed $value
     * @param \Illuminate\Database\Query\Expression|string $property
     */
    protected function withPropertyConstraint(Builder $query, $value, $property): Builder
    {
        if (\is_array($value)) {
            return $query->whereIn($property, $value);

The expression return $query->whereIn($property, $value) could return the type Illuminate\Database\Query\Builder which is incompatible with the type-hinted return Illuminate\Database\Eloquent\Builder. Consider adding an additional type-check to rule them out.

        }

        return $query->where($property, '=', $value);
    }

    protected function isRelationProperty(Builder $query, string $property): bool
    {
        if (! Str::contains($property, '.')) {
            return false;
        }

        if (\in_array($property, $this->relationConstraints, true)) {
            return false;
        }

        return ! Str::startsWith($property, $query->getModel()->getTable() . '.');
    }

    /**
     * @param mixed $value
     */
    protected function withRelationConstraint(Builder $query, $value, string $property): Builder
    {
        [$relation, $property] = $this->resolveNestedRelation($property);

        return $query->whereHas(
            $relation,
            function ($query) use ($value, $property): void {
                $property = $query->getModel()
                    ->getTable() . '.' . $property;
                $this->relationConstraints[] = $property;

                $this->apply($query, $value, $property);
            }
        );
    }
}