Mpyw\EloquentHasByNonDependentSubquery\HasByNonDependentSubqueryMacro

Complexity

Total Complexity

13

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	has()	0	4	1
A	apply()	0	25	5
A	applyForCurrentRelation()	0	24	3
A	orHas()	0	4	1
A	doesntHave()	0	4	1
A	orDoesntHave()	0	4	1

<?php

namespace Mpyw\EloquentHasByNonDependentSubquery;

use DomainException;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;

/**
 * Class HasByNonDependentSubqueryMacro
 *
 * Convert has() and whereHas() constraints to non-dependent subqueries.
 */
class HasByNonDependentSubqueryMacro
{
    /**
     * @var \Illuminate\Database\Eloquent\Builder
     */
    protected $query;

    /**
     * HasByNonDependentSubqueryMacro constructor.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     */
    public function __construct(Builder $query)
    {
        $this->query = $query;
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function has($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'whereIn', ...$constraints);
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function orHas($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'orWhereIn', ...$constraints);
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function doesntHave($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'whereNotIn', ...$constraints);
    }

    /**
     * @param  string|string[]                       $relationMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function orDoesntHave($relationMethod, ?callable ...$constraints): Builder
    {
        return $this->apply($relationMethod, 'orWhereNotIn', ...$constraints);
    }

    /**
     * Parse nested constraints and iterate them to apply.
     *
     * @param  string|string[]                       $relationMethod
     * @param  string                                $whereInMethod
     * @param  callable[]|null[]                     $constraints
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function apply($relationMethod, string $whereInMethod, ?callable ...$constraints): Builder
    {
        // Extract dot-chained expressions
        $relationMethods = is_string($relationMethod) ? explode('.', $relationMethod) : array_values($relationMethod);

        // Pick the first relation if exists
        if ($currentRelationMethod = array_shift($relationMethods)) {
            $this->applyForCurrentRelation(
                $currentRelationMethod,
                $whereInMethod,
                function (Relation $query) use ($relationMethods, $whereInMethod, $constraints) {
                    // Apply optional constraints
                    if ($currentConstraints = array_shift($constraints)) {
                        $currentConstraints($query);
                    }
                    // Apply relations nested under
                    if ($relationMethods) {

The expression $relationMethods 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.

                        (new static($query->getQuery()))->apply($relationMethods, $whereInMethod, ...$constraints);
                    }
                }
            );
        }

        return $this->query;
    }

    /**
     * Apply the current relation as a non-dependent subquery.
     *
     * @param string        $relationMethod
     * @param string        $whereInMethod
     * @param null|callable $constraints
     */
    protected function applyForCurrentRelation(string $relationMethod, string $whereInMethod, callable $constraints): void
    {
        // Unlike a JOIN-based approach, you don't need give table aliases.
        // Table names are never conflicted.
        if (preg_match('/\s+as\s+/i', $relationMethod)) {
            throw new DomainException('Table aliases are not supported.');
        }

        // Create a Relation instance
        $relation = $this->query->getRelation($relationMethod);

The method getRelation() does not seem to exist on object<Illuminate\Database\Eloquent\Builder>.

        // Validate the relation and recognize key names
        $keys = new Keys($relation);

        // Apply optional constraints and relations nested under
        $constraints($relation);

        // Add an "whereIn" constraints for a non-dependent subquery
        $relation->select($keys->getQualifiedRelatedKeyName());
        if ($keys->needsPolymorphicRelatedConstraints()) {
            $relation->where($keys->getQualifiedRelatedMorphType(), $keys->getRelatedMorphClass());
        }
        $this->query->{$whereInMethod}($keys->getQualifiedSourceKeyName(), $relation->getQuery());
    }
}