RelationMixin::getRelationWhereInKey() - Code Metrics - biiiiiigmonster/hasin - Measure and Improve Code Quality continuously with Scrutinizer

RelationMixin::getRelationWhereInKey() A
last analyzed 2024-03-16 14:38 UTC

↳ Parent: RelationMixin
Complexity

Conditions	1
Paths	1
Size

Total Lines	8
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
cc	1
eloc	6
c	3
b	0
f	0
nc	1
nop	0
dl	0
loc	8
rs	10
<?php

namespace BiiiiiigMonster\Hasin\Database\Eloquent;

use Closure;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\HasOneOrMany;
use Illuminate\Database\Eloquent\Relations\MorphOne;
use Illuminate\Database\Eloquent\Relations\MorphOneOrMany;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use LogicException;

class RelationMixin
{
    public function getRelationExistenceInQuery(): Closure
    {
        return function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
        return function (Builder $query, Builder $parentQuery, /** @scrutinizer ignore-unused */ $columns = ['*']): Builder {
            $relation = function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
                return $query->select($columns);
                return $query->/** @scrutinizer ignore-call */ select($columns);
            };
            // basic builder
            $belongsTo = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
                $columns = $query->qualifyColumn($this->ownerKey);
                $columns = $query->qualifyColumn($this->ownerKey);

                $relationQuery = $relation($query, $parentQuery, $columns);

                if ($parentQuery->getQuery()->from == $query->getQuery()->from) {
                if ($parentQuery->/** @scrutinizer ignore-call */ getQuery()->from == $query->getQuery()->from) {
                    $relationQuery->from(
                        $query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash()
                        $query->getModel()->getTable().' as '.$hash = $this->/** @scrutinizer ignore-call */ getRelationCountHash()
                    );

                    $relationQuery->getModel()->setTable($hash);
                }

                return $relationQuery;
            };
            $belongsToMany = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
                $columns = $this->getExistenceCompareKey();
                $columns = $this->getExistenceCompareKey();
                if ($parentQuery->getQuery()->from == $query->getQuery()->from) {
                    $query->select($columns);

                    $query->from($this->related->getTable().' as '.$hash = $this->getRelationCountHash());
                            from($this->related->getTable().' as '.$hash = $this->getRelationCountHash());

                    $this->related->setTable($hash);
                }

                $this->performJoin($query);
                       performJoin($query);

                return $relation($query, $parentQuery, $columns);
            };
            $hasOneOrMany = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
                $columns = $this->getExistenceCompareKey();
                if ($query->getQuery()->from == $parentQuery->getQuery()->from) {
                    $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());

                    $query->getModel()->setTable($hash);
                }

                return $relation($query, $parentQuery, $columns);
            };
            $hasManyThrough = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
                $columns = $this->getQualifiedFirstKeyName();
                $columns = $this->getQualifiedFirstKeyName();
                if ($parentQuery->getQuery()->from === $query->getQuery()->from) {
                    $query->from($query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash());

                    $query->join($this->throughParent->getTable(), $this->getQualifiedParentKeyName(), '=', $hash.'.'.$this->secondKey);
                            join($this->throughParent->getTable(), $this->getQualifiedParentKeyName(), '=', $hash.'.'.$this->secondKey);

                    if ($this->throughParentSoftDeletes()) {
                    if ($this->/** @scrutinizer ignore-call */ throughParentSoftDeletes()) {
                        $query->whereNull($this->throughParent->getQualifiedDeletedAtColumn());
                                whereNull($this->throughParent->getQualifiedDeletedAtColumn());
                    }

                    $query->getModel()->setTable($hash);

                    return $relation($query, $parentQuery, $columns);
                }

                if ($parentQuery->getQuery()->from === $this->throughParent->getTable()) {
                    $table = $this->throughParent->getTable().' as '.$hash = $this->getRelationCountHash();

                    $query->join($table, $hash.'.'.$this->secondLocalKey, '=', $this->getQualifiedFarKeyName());
                    $query->join($table, $hash.'.'.$this->secondLocalKey, '=', $this->/** @scrutinizer ignore-call */ getQualifiedFarKeyName());

                    if ($this->throughParentSoftDeletes()) {
                        $query->whereNull($hash.'.'.$this->throughParent->getDeletedAtColumn());
                    }

                    return $relation($query, $parentQuery, $columns);
                }

                $this->performJoin($query);

                return $relation($query, $parentQuery, $columns);
            };
            // extended builder
            $hasOne = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
                if ($this->isOneOfMany()) {
                if ($this->/** @scrutinizer ignore-call */ isOneOfMany()) {
                    $this->mergeOneOfManyJoinsTo($query);
                           mergeOneOfManyJoinsTo($query);
                }

                return $hasOneOrMany($query, $parentQuery);
            };
            $morphOneOrMany = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
                return $hasOneOrMany($query, $parentQuery)->where(
                    $query->qualifyColumn($this->getMorphType()),
                    $query->qualifyColumn($this->/** @scrutinizer ignore-call */ getMorphType()),
                    $this->morphClass

                );
            };
            $morphOne = function (Builder $query, Builder $parentQuery) use ($morphOneOrMany): Builder {
                if ($this->isOneOfMany()) {
                    $this->mergeOneOfManyJoinsTo($query);
                }

                return $morphOneOrMany($query, $parentQuery);
            };
            $morphToMany = function (Builder $query, Builder $parentQuery) use ($belongsToMany): Builder {
                return $belongsToMany($query, $parentQuery)->where(
                    $this->qualifyPivotColumn($this->morphType),
                           qualifyPivotColumn($this->morphType),
                    $this->morphClass

                );
            };

            return match (true) {
                // extended relation
                $this instanceof HasOne => $hasOne($query, $parentQuery),
                $this instanceof MorphOne => $morphOne($query, $parentQuery),
                $this instanceof MorphOneOrMany => $morphOneOrMany($query, $parentQuery),
                $this instanceof MorphToMany => $morphToMany($query, $parentQuery),
                // basic relation
                $this instanceof BelongsTo => $belongsTo($query, $parentQuery),
                $this instanceof BelongsToMany => $belongsToMany($query, $parentQuery),
                $this instanceof HasOneOrMany => $hasOneOrMany($query, $parentQuery),
                $this instanceof HasManyThrough => $hasManyThrough($query, $parentQuery),
                default => throw new LogicException(
                    sprintf('%s must be a relationship instance.', $this::class)
                )
            };
        };
    }

    public function getRelationWhereInKey(): Closure
    {
        return fn (): string => match (true) {
            $this instanceof BelongsTo => $this->getQualifiedForeignKeyName(),
            $this instanceof BelongsTo => $this->/** @scrutinizer ignore-call */ getQualifiedForeignKeyName(),
            $this instanceof HasOneOrMany, $this instanceof BelongsToMany => $this->getQualifiedParentKeyName(),
            $this instanceof HasManyThrough => $this->getQualifiedLocalKeyName(),
            $this instanceof HasManyThrough => $this->/** @scrutinizer ignore-call */ getQualifiedLocalKeyName(),
            default => throw new LogicException(
                sprintf('%s must be a relationship instance.', $this::class)
            )
        };
    }
}

biiiiiigmonster / hasin

RelationMixin::getRelationWhereInKey() A last analyzed 2024-03-16 14:38 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RelationMixin::getRelationWhereInKey() A
last analyzed 2024-03-16 14:38 UTC
