LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsJoins

Complexity

Total Complexity

12

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Test Coverage

Coverage

85.37%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	join()	0	24	4
A	rightJoin()	0	3	1
A	leftJoinSub()	0	4	1
A	rightJoinWhere()	0	3	1
A	leftJoin()	0	10	1
A	joinSub()	0	11	1
A	newJoinClause()	0	4	1
A	rightJoinSub()	0	3	1
A	joinLateral()	0	15	1

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Closure;
use Illuminate\Database\Eloquent\Builder as IlluminateEloquentBuilder;
use Illuminate\Database\Query\Builder as IlluminateQueryBuilder;
use Illuminate\Database\Query\Expression;
use LaravelFreelancerNL\Aranguent\Query\Builder;
use LaravelFreelancerNL\Aranguent\Query\JoinClause;
use LogicException;

trait BuildsJoins
{
    /**
     * Add a right join to the query.
     *
     * @param  \Illuminate\Contracts\Database\Query\Expression|string  $table
     * @param Closure|string  $first
     * @param  string|null  $operator
     * @param  \Illuminate\Contracts\Database\Query\Expression|string|null  $second
     * @return $this
     *
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function rightJoin($table, $first, $operator = null, $second = null)
    {
        throw new LogicException('This database driver does not support the rightJoin method.');
    }

    /**
     * Add a subquery right join to the query.
     *
     * @param Closure|IlluminateQueryBuilder|IlluminateEloquentBuilder|string  $query
     * @param  string  $as
     * @param Closure|string  $first
     * @param  string|null  $operator
     * @param  \Illuminate\Contracts\Database\Query\Expression|string|null  $second
     * @return $this
     *
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function rightJoinSub($query, $as, $first, $operator = null, $second = null)
    {
        throw new LogicException('This database driver does not support the rightJoinSub method.');
    }

    /**
     * Add a "right join where" clause to the query.
     *
     * @param  \Illuminate\Contracts\Database\Query\Expression|string  $table
     * @param Closure|string  $first
     * @param  string  $operator
     * @param  \Illuminate\Contracts\Database\Query\Expression|string  $second
     * @return $this
     *
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     */
    public function rightJoinWhere($table, $first, $operator, $second)
    {
        throw new LogicException('This database driver does not support the rightJoinWhere method.');
    }


    /**
     * Add a join clause to the query.
     *
     * The boolean argument flag is part of this method's API in Laravel.
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     *
     * @param  mixed  $table
     * @param Closure|string  $first
     * @param  string|null  $operator
     * @param  float|int|string|null  $second
     * @param  string  $type
     * @param  bool  $where
     */
    public function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false): IlluminateQueryBuilder
    {
        $join = $this->newJoinClause($this, $type, $table);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsJoins is incompatible with the type Illuminate\Database\Query\Builder expected by parameter $parentQuery of LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsJoins::newJoinClause().

        // If the first "column" of the join is really a Closure instance the developer
        // is trying to build a join with a complex "on" clause containing more than
        // one condition, so we'll add the join and call a Closure with the query.
        if ($first instanceof Closure) {
            $first($join);

            $this->joins[] = $join;

The property joins does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }
        if (!$first instanceof Closure) {
            // If the column is simply a string, we can assume the join simply has a basic
            // "on" clause with a single condition. So we will just build the join with
            // this simple join clauses attached to it. There is not a join callback.

            //where and on are the same for aql
            $method = $where ? 'where' : 'on';

            $this->joins[] = $join->$method($first, $operator, $second);
        }

        return $this;

The expression return $this returns the type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsJoins which is incompatible with the type-hinted return Illuminate\Database\Query\Builder.

    }

    /**
     * Add a subquery join clause to the query.
     *
     * @param Closure|IlluminateQueryBuilder|IlluminateEloquentBuilder|string  $query
     * @param  string  $as
     * @param Closure|string  $first
     * @param  string|null  $operator
     * @param  float|int|string|null  $second
     * @param  string  $type
     * @param  bool  $where
     *
     * @throws \InvalidArgumentException
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false): IlluminateQueryBuilder
    {
        assert($query instanceof Builder);

        $query->importTableAliases($this);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsJoins is incompatible with the type Illuminate\Database\Query\Builder|array expected by parameter $aliases of LaravelFreelancerNL\Aranguent\Query\Builder::importTableAliases().

        $query->importTableAliases([$as => $as]);
        $this->importTableAliases($query);

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

        [$query] = $this->createSub($query);

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

        return  $this->join(new Expression($query . ' as ' . $as), $first, $operator, $second, $type, $where);
    }


    /**
     * Add a left join to the query.
     *
     * @param  \Illuminate\Contracts\Database\Query\Expression|string  $table
     * @param Closure|string  $first
     * @param  string|null  $operator
     * @param  \Illuminate\Contracts\Database\Query\Expression|string|null  $second
     */
    public function leftJoin($table, $first, $operator = null, $second = null): IlluminateQueryBuilder
    {

        return $this->join(
            $table,
            $first,
            $operator,
            /** @phpstan-ignore-next-line  */
            $this->grammar->getValue($second),
            'left',
        );
    }

    /**
     * Add a subquery left join to the query.
     *
     * @param Closure|IlluminateQueryBuilder|IlluminateEloquentBuilder|string  $query
     * @param  string  $as
     * @param Closure|string  $first
     * @param  string|null  $operator
     * @param  \Illuminate\Contracts\Database\Query\Expression|string|null  $second
     */
    public function leftJoinSub($query, $as, $first, $operator = null, $second = null): IlluminateQueryBuilder
    {
        /** @phpstan-ignore-next-line  */
        return $this->joinSub($query, $as, $first, $operator, $this->grammar->getValue($second), 'left');
    }


    /**
     * Get a new join clause.
     *
     * @param  string  $type
     * @param  string  $table
     */
    protected function newJoinClause(IlluminateQueryBuilder $parentQuery, $type, $table)
    {
        // @phpstan-ignore-next-line
        return new JoinClause($parentQuery, $type, $table);
    }

    /**
     * Add a lateral join clause to the query.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string  $query
     * @param  string  $as
     * @param  string  $type
     * @return $this
     */
    public function joinLateral($query, string $as, string $type = 'inner')
    {
        assert($query instanceof Builder);

        $query->importTableAliases($this);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsJoins is incompatible with the type Illuminate\Database\Query\Builder|array expected by parameter $aliases of LaravelFreelancerNL\Aranguent\Query\Builder::importTableAliases().

        $query->importTableAliases([$as => $as]);
        $this->importTableAliases($query);

        [$query] = $this->createSub($query);

        $expression = $query . ' as ' . $this->grammar->wrapTable($as);

        $this->joins[] = $this->newJoinLateralClause($this, $type, new Expression($expression));

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

The property joins does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        return $this;
    }
}