BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin

Complexity

Total Complexity

11

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Importance

Changes	13
Bugs	5	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	getRelationWhereInKey()	0	8	1
C	getRelationExistenceInQuery()	0	119	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 {

The parameter $columns is not used and could be removed.

            $relation = function (Builder $query, Builder $parentQuery, $columns = ['*']): Builder {
                return $query->select($columns);

The method select() does not exist on Illuminate\Database\Eloquent\Builder.

            };
            // basic builder
            $belongsTo = function (Builder $query, Builder $parentQuery) use ($relation): Builder {
                $columns = $query->qualifyColumn($this->ownerKey);

The property ownerKey does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

The method qualifyColumn() does not exist on Illuminate\Database\Eloquent\Builder.

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

                if ($parentQuery->getQuery()->from == $query->getQuery()->from) {

The method getQuery() does not exist on Illuminate\Database\Eloquent\Builder.

                    $relationQuery->from(
                        $query->getModel()->getTable().' as '.$hash = $this->getRelationCountHash()

The method getModel() does not exist on Illuminate\Database\Eloquent\Builder.

The method getRelationCountHash() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                    );

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

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

The method getExistenceCompareKey() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                if ($parentQuery->getQuery()->from == $query->getQuery()->from) {
                    $query->select($columns);

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

The method from() does not exist on Illuminate\Database\Eloquent\Builder.

The property related does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

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

                $this->performJoin($query);

The method performJoin() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                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();

The method getQualifiedFirstKeyName() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                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);

The method getQualifiedParentKeyName() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

The method join() does not exist on Illuminate\Database\Eloquent\Builder.

The property secondKey does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

The property throughParent does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

                    if ($this->throughParentSoftDeletes()) {

The method throughParentSoftDeletes() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                        $query->whereNull($this->throughParent->getQualifiedDeletedAtColumn());

The method whereNull() does not exist on Illuminate\Database\Eloquent\Builder.

                    }

                    $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());

The method getQualifiedFarKeyName() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

The property secondLocalKey does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

                    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()) {

The method isOneOfMany() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                    $this->mergeOneOfManyJoinsTo($query);

The method mergeOneOfManyJoinsTo() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                }

                return $hasOneOrMany($query, $parentQuery);
            };
            $morphOneOrMany = function (Builder $query, Builder $parentQuery) use ($hasOneOrMany): Builder {
                return $hasOneOrMany($query, $parentQuery)->where(
                    $query->qualifyColumn($this->getMorphType()),

The method getMorphType() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                    $this->morphClass

The property morphClass does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

                );
            };
            $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),

The property morphType does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

The method qualifyPivotColumn() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

                    $this->morphClass

The property morphClass does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin. Did you maybe forget to declare it?

                );
            };

            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(),

The method getQualifiedForeignKeyName() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

            $this instanceof HasOneOrMany, $this instanceof BelongsToMany => $this->getQualifiedParentKeyName(),
            $this instanceof HasManyThrough => $this->getQualifiedLocalKeyName(),

The method getQualifiedLocalKeyName() does not exist on BiiiiiigMonster\Hasin\Database\Eloquent\RelationMixin.

            default => throw new LogicException(
                sprintf('%s must be a relationship instance.', $this::class)
            )
        };
    }
}