Staudenmeir\LaravelAdjacencyList\Eloquent\Traits\HasGraphRelationshipScopes

Complexity

Total Complexity

35

Size/Duplication

Total Lines	418
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	scopeWhereDepth()	0	5	1
A	scopeDepthFirst()	0	5	1
A	scopeBreadthFirst()	0	3	1
A	scopeSubgraph()	0	3	1
A	getInitialQuery()	0	40	2
A	addInitialQueryCustomPaths()	0	7	3
A	addRecursiveQueryJoinsAndConstraints()	0	27	3
A	getRecursiveQuery()	0	53	3
A	addRecursiveQueryPivotColumns()	0	6	2
A	addInitialQueryCycleDetection()	0	6	3
A	addRecursiveQueryCustomPaths()	0	10	3
A	addRecursiveQueryCycleDetection()	0	28	3
A	addInitialQueryJoins()	0	15	3
A	addInitialQueryPivotColumns()	0	22	4
A	scopeWithRelationshipExpression()	0	23	2

<?php

namespace Staudenmeir\LaravelAdjacencyList\Eloquent\Traits;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Collection;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar;

trait HasGraphRelationshipScopes
{
    /**
     * Add a recursive expression for a custom subgraph to the query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param callable $constraint
     * @param int|null $maxDepth
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeSubgraph(Builder $query, callable $constraint, ?int $maxDepth = null): Builder
    {
        return $query->withRelationshipExpression('desc', $constraint, 0, null, $maxDepth);
    }

    /**
     * Limit the query by depth.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed $operator
     * @param mixed|null $value
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWhereDepth(Builder $query, mixed $operator, mixed $value = null): Builder
    {
        $arguments = array_slice(func_get_args(), 1);

        return $query->where($this->getDepthName(), ...$arguments);

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

    }

    /**
     * Order the query breadth-first.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeBreadthFirst(Builder $query): Builder
    {
        return $query->orderBy($this->getDepthName());

The expression return $query->orderBy($this->getDepthName()) 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.

    }

    /**
     * Order the query depth-first.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeDepthFirst(Builder $query): Builder
    {
        $sql = $query->getExpressionGrammar()->compileOrderByPath();

        return $query->orderByRaw($sql);

The expression return $query->orderByRaw($sql) 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.

    }

    /**
     * Add a recursive expression for the relationship to the query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $direction
     * @param callable $constraint
     * @param int $initialDepth
     * @param string|null $from
     * @param int|null $maxDepth
     * @param string $union
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWithRelationshipExpression(
        Builder $query,
        string $direction,
        callable $constraint,
        int $initialDepth,
        ?string $from = null,
        ?int $maxDepth = null,
        string $union = 'unionAll'
    ): Builder {
        $from = $from ?: $this->getTable();

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

        $grammar = $query->getExpressionGrammar();

        $expression = $this->getInitialQuery($grammar, $constraint, $initialDepth, $from)

It seems like $grammar can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $grammar of Staudenmeir\LaravelAdjacencyList\Eloquent\Traits\HasGraphRelationshipScopes::getInitialQuery() does only seem to accept Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar, maybe add an additional type check?

            ->$union(
                $this->getRecursiveQuery($grammar, $direction, $from, $maxDepth)

It seems like $grammar can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $grammar of Staudenmeir\LaravelAdjacencyList\Eloquent\Traits\HasGraphRelationshipScopes::getRecursiveQuery() does only seem to accept Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar, maybe add an additional type check?

            );

        $name = $this->getExpressionName();

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

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

        return $query->withRecursiveExpression($name, $expression)->from($name);

The expression return $query->withRecursiveExpression($name, $expression)->from($name) 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.

    }

    /**
     * Get the initial query for a relationship expression.
     *
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @param callable $constraint
     * @param int $initialDepth
     * @param array $pivotColumns
     * @param string $from
     * @return \Illuminate\Database\Eloquent\Builder $query
     */
    protected function getInitialQuery(
        ExpressionGrammar $grammar,
        callable $constraint,
        int $initialDepth,
        string $from
    ): Builder {
        $table = explode(' as ', $from)[1] ?? $from;

        $pivotTable = $this->getPivotTableName();

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

        $depth = $grammar->wrap(

The method wrap() does not exist on Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar. It seems like you code against a sub-type of said class. However, the method does not exist in Staudenmeir\LaravelAdjacencyList\Query\Grammars\FirebirdGrammar. Are you sure you never get one of those?

            $this->getDepthName()
        );

        $initialPath = $grammar->compileInitialPath(
            $this->getQualifiedLocalKeyName(),

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

            $this->getPathName()

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

        );

        $query = $this->newModelQuery()

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

            ->select("$table.*")
            ->selectRaw($initialDepth . ' as ' . $depth)
            ->selectRaw($initialPath)
            ->from($from);

        $this->addInitialQueryCustomPaths($query, $grammar);

        $this->addInitialQueryPivotColumns($query, $grammar, $pivotTable, $initialDepth);

        $this->addInitialQueryCycleDetection($query, $grammar);

        $this->addInitialQueryJoins($query, $pivotTable, $initialDepth);

        $constraint($query);

        if (static::$initialQueryConstraint) {
            (static::$initialQueryConstraint)($query);
        }

        return $query;
    }

    /**
     * Add custom paths to the initial query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @return void
     */
    protected function addInitialQueryCustomPaths(Builder $query, ExpressionGrammar $grammar): void
    {
        foreach ($this->getCustomPaths() as $path) {

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

            $query->selectRaw(
                $grammar->compileInitialPath(
                    is_string($path['column']) ? $this->qualifyColumn($path['column']) : $path['column'],

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

                    $path['name']
                )
            );
        }
    }

    /**
     * Add pivot columns to the initial query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @param string $pivotTable
     * @param int $initialDepth
     * @return void
     */
    protected function addInitialQueryPivotColumns(
        Builder $query,
        ExpressionGrammar $grammar,
        string $pivotTable,
        int $initialDepth
    ): void {
        $columns = [$this->getParentKeyName(), $this->getChildKeyName(), ...$this->getPivotColumns()];

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

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

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

        if ($initialDepth === 0) {
            $columnDefinitions = (new Collection($query->getConnection()->getSchemaBuilder()->getColumns($pivotTable)))
                ->keyBy('name');

            foreach ($columns as $column) {
                $columnDefinition = $columnDefinitions[$column];

                $null = $grammar->compilePivotColumnNullValue($columnDefinition['type_name'], $columnDefinition['type']);

                $query->selectRaw("$null as " . $grammar->wrap("pivot_$column"));
            }
        } else {
            foreach ($columns as $column) {
                $query->addSelect("$pivotTable.$column as pivot_$column");
            }
        }
    }

    /**
     * Add cycle detection to the initial query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @return void
     */
    protected function addInitialQueryCycleDetection(Builder $query, ExpressionGrammar $grammar): void
    {
        if ($this->enableCycleDetection() && $this->includeCycleStart()) {

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

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

            $query->selectRaw(
                $grammar->compileCycleDetectionInitialSelect(
                    $this->getCycleDetectionColumnName()

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

                )
            );
        }
    }

    /**
     * Add join clauses to the initial query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $pivotTable
     * @param int $initialDepth
     * @return void
     */
    protected function addInitialQueryJoins(Builder $query, string $pivotTable, int $initialDepth): void
    {
        if ($initialDepth < 0) {
            $query->join(
                $pivotTable,
                $this->getQualifiedLocalKeyName(),
                '=',
                $this->getQualifiedParentKeyName()

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

            );
        } elseif ($initialDepth > 0) {
            $query->join(
                $pivotTable,
                $this->getQualifiedLocalKeyName(),
                '=',
                $this->getQualifiedChildKeyName()

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

            );
        }
    }

    /**
     * Get the recursive query for a relationship expression.
     *
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @param string $direction
     * @param string $from
     * @param int|null $maxDepth
     * @return \Illuminate\Database\Eloquent\Builder $query
     */
    protected function getRecursiveQuery(
        ExpressionGrammar $grammar,
        string $direction,
        string $from,
        ?int $maxDepth = null
    ): Builder {
        $name = $this->getExpressionName();

        $table = explode(' as ', $from)[1] ?? $from;

        $pivotTable = $this->getPivotTableName();

        $depth = $grammar->wrap($this->getDepthName());

        $joinColumns = [
            'asc' => [
                $name . '.' . $this->getLocalKeyName(),

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

                $this->getQualifiedChildKeyName(),
            ],
            'desc' => [
                $name . '.' . $this->getLocalKeyName(),
                $this->getQualifiedParentKeyName(),
            ],
        ];

        $recursiveDepth = $depth . ' ' . ($direction === 'asc' ? '-' : '+') . ' 1';

        $recursivePath = $grammar->compileRecursivePath(
            $this->getQualifiedLocalKeyName(),
            $this->getPathName()
        );

        $recursivePathBindings = $grammar->getRecursivePathBindings($this->getPathSeparator());

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

        $query = $this->newModelQuery()
            ->select($table . '.*')
            ->selectRaw($recursiveDepth . ' as ' . $depth)
            ->selectRaw($recursivePath, $recursivePathBindings)
            ->from($from);

        $this->addRecursiveQueryCustomPaths($query, $grammar);

        $this->addRecursiveQueryPivotColumns($query, $pivotTable);

        $this->addRecursiveQueryCycleDetection($query, $grammar);

        $this->addRecursiveQueryJoinsAndConstraints($query, $pivotTable, $direction, $name, $joinColumns);

        if (!is_null($maxDepth)) {
            $query->where($this->getDepthName(), '<', $maxDepth);
        }

        return $query;
    }

    /**
     * Add customs path to the recursive query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @return void
     */
    protected function addRecursiveQueryCustomPaths(Builder $query, ExpressionGrammar $grammar): void
    {
        foreach ($this->getCustomPaths() as $path) {
            $query->selectRaw(
                $grammar->compileRecursivePath(
                    is_string($path['column']) ? $this->qualifyColumn($path['column']) : $path['column'],
                    $path['name'],
                    $path['reverse'] ?? false
                ),
                $grammar->getRecursivePathBindings($path['separator'])
            );
        }
    }

    /**
     * Add pivot columns to the recursive query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $pivotTable
     * @return void
     */
    protected function addRecursiveQueryPivotColumns(Builder $query, string $pivotTable): void
    {
        $columns = [$this->getParentKeyName(), $this->getChildKeyName(), ...$this->getPivotColumns()];

        foreach ($columns as $column) {
            $query->addSelect("$pivotTable.$column as pivot_$column");
        }
    }

    /**
     * Add cycle detection to the recursive query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar $grammar
     * @return void
     */
    protected function addRecursiveQueryCycleDetection(Builder $query, ExpressionGrammar $grammar): void
    {
        if (!$this->enableCycleDetection()) {
            return;
        }

        $sql = $grammar->compileCycleDetection(
            $this->getQualifiedLocalKeyName(),
            $this->getPathName()
        );

        $bindings = $grammar->getCycleDetectionBindings(
            $this->getPathSeparator()
        );

        if ($this->includeCycleStart()) {
            $cycleDetectionColumn = $this->getCycleDetectionColumnName();

            $query->selectRaw(
                $grammar->compileCycleDetectionRecursiveSelect($sql, $cycleDetectionColumn),
                $bindings
            );

            $query->whereRaw(
                $grammar->compileCycleDetectionStopConstraint($cycleDetectionColumn)
            );
        } else {
            $query->whereRaw("not($sql)", $bindings);
        }
    }

    /**
     * Add join and where clauses to the recursive query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $pivotTable
     * @param string $direction
     * @param string $name
     * @param array $joinColumns
     * @return void
     */
    protected function addRecursiveQueryJoinsAndConstraints(
        Builder $query,
        string $pivotTable,
        string $direction,
        string $name,
        array $joinColumns
    ): void {
        if ($direction === 'desc') {
            $query->join(
                $pivotTable,
                $this->getQualifiedLocalKeyName(),
                '=',
                $this->getQualifiedChildKeyName()
            );
        } else {
            $query->join(
                $pivotTable,
                $this->getQualifiedLocalKeyName(),
                '=',
                $this->getQualifiedParentKeyName()
            );
        }

        $query->join($name, $joinColumns[$direction][0], '=', $joinColumns[$direction][1]);

        if (static::$recursiveQueryConstraint) {
            (static::$recursiveQueryConstraint)($query);
        }
    }
}