LaravelFreelancerNL\Aranguent\Query\Concerns\HandlesAliases

Complexity

Total Complexity

40

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	extractAlias()	0	19	6
A	generateTableAlias()	0	6	2
A	convertColumnId()	0	8	2
A	getTableAlias()	0	15	4
A	getTableAliases()	0	3	1
A	exchangeTableAliases()	0	6	1
A	registerColumnAlias()	0	13	4
A	getColumnAlias()	0	7	2
A	isTableAlias()	0	3	1
B	registerTableAlias()	0	29	10
A	importTableAliases()	0	8	2
A	replaceTableForAlias()	0	12	2
A	isTable()	0	3	1
A	prefixAlias()	0	10	2

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Exception;
use Illuminate\Database\Eloquent\Builder as IlluminateEloquentBuilder;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\Expression;
use Illuminate\Support\Str;
use Illuminate\Database\Query\Builder as IlluminateQueryBuilder;
use LaravelFreelancerNL\Aranguent\Query\Builder;

trait HandlesAliases
{
    /**
     * @var array<string, Expression|string>
     */
    public array $tableAliases = [];

    /**
     * @var array<string, Expression|string>
     */
    public array $columnAliases = [];

    /**
     * @param  array<mixed>|string  $column
     * @return array<mixed>|string
     */
    public function convertColumnId(array|string|Expression $column): array|string|Expression
    {

        if ($column instanceof Expression) {

$column is never a sub-type of Illuminate\Database\Query\Expression.

            return $column;
        }

        return $this->convertIdToKey($column);

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

    }

    /**
     * Extract table and alias from sql alias notation (entity AS `alias`)
     *
     * @return array<int|string, Expression|string>
     *
     * @throws Exception
     */
    public function extractAlias(string $entity, int|null|string $key = null): array
    {
        $results = preg_split("/\sas\s/i", $entity);

        if ($results === false) {
            throw new Exception('Column splitting failed');
        }

        if (isset($results[1])) {
            $results[1] = trim($results[1], '`');
        }
        if (!isset($results[1]) && is_string($key)) {
            $results[1] = $key;
        }
        if (!isset($results[1])) {
            $results[1] = $results[0];
        }

        return $results;
    }

    public function generateTableAlias(string|Expression $table, string $postfix = 'Doc'): string
    {
        if ($table instanceof Expression) {
            return 'Expression' . spl_object_id($table);
        }
        return Str::camel(Str::singular($table)) . $postfix;
    }

    public function getTableAlias(string|Expression $table): float|int|null|string
    {
        if ($table instanceof Expression) {
            $table = 'Expression' . spl_object_id($table);
        }

        if ($this->isTableAlias($table)) {
            return $table;
        }

        if (!isset($this->tableAliases[$table])) {
            return null;
        }

        return $this->grammar->getValue($this->tableAliases[$table]);
    }

    public function getColumnAlias(string $column): Expression|null|string
    {
        if (isset($this->columnAliases[$column])) {
            return $this->columnAliases[$column];
        }

        return null;
    }

    /**
     * @return array<string, Expression|string>
     */
    public function getTableAliases(): array
    {
        return $this->tableAliases;
    }

    /**
     * @param array<string, Expression|string>|IlluminateQueryBuilder $aliases
     * @return void
     */
    public function importTableAliases(array|IlluminateQueryBuilder $aliases): void
    {
        if ($aliases instanceof IlluminateQueryBuilder) {

$aliases is never a sub-type of Illuminate\Database\Query\Builder.

            assert($aliases instanceof Builder);
            $aliases = $aliases->getTableAliases();
        }

        $this->tableAliases = array_merge($this->tableAliases, $aliases);
    }

    /**
     * @param IlluminateEloquentBuilder|IlluminateQueryBuilder|Relation $query
     * @return void
     */
    public function exchangeTableAliases($query): void
    {
        assert($query instanceof Builder);

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

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

    }

    public function isTableAlias(string $value): bool
    {
        return in_array($value, $this->tableAliases);
    }

    public function isTable(string $value): bool
    {
        return array_key_exists($value, $this->tableAliases);
    }

    public function prefixAlias(string $target, string $value): string
    {
        /** @phpstan-ignore-next-line */
        $alias =  $this->grammar->getValue($this->getTableAlias($target));

        if (Str::startsWith($value, $alias . '.')) {
            return $value;
        }

        return $alias . '.' . $value;
    }

    /**
     * @throws Exception
     */
    public function registerColumnAlias(string $column, ?string $alias = null): bool
    {
        if (preg_match("/\sas\s/i", $column)) {
            [$column, $alias] = $this->extractAlias($column);
        }

        if (isset($alias) && !$column instanceof Expression) {
            $this->columnAliases[$column] = $alias;

            return true;
        }

        return false;
    }

    /**
     * @SuppressWarnings("PHPMD.CyclomaticComplexity")
     */
    public function registerTableAlias(string|Expression $table, ?string $alias = null): string
    {
        if ($table instanceof Expression  && $alias !== null) {
            $table = 'Expression' . spl_object_id($table);
        }

        if ($table instanceof Expression && $alias === null) {
            $table = 'Expression' . spl_object_id($table);
            $alias = $table;
        }

        /** @phpstan-ignore-next-line  */
        if ($alias == null && is_string($table) && stripos($table, ' as ') !== false) {

It seems like you are loosely comparing $alias of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $tableParts = [];

            if (preg_match("/(^.*) as (.*?)$/", $table, $tableParts)) {
                $table = $tableParts[1];
                $alias = $tableParts[2];
            }
        }

        if ($alias == null) {
            $alias = $this->generateTableAlias($table);
        }

        /** @phpstan-ignore-next-line  */
        $this->tableAliases[$table] = $alias;

        return $alias;
    }

    public function replaceTableForAlias(string $reference): string
    {
        $referenceParts = explode('.', $reference);
        $first = array_shift($referenceParts);
        /** @phpstan-ignore-next-line */
        $alias = $this->grammar->getValue($this->getTableAlias($first));
        if ($alias == null) {
            $alias = $first;
        }
        array_unshift($referenceParts, $alias);

        return implode('.', $referenceParts);
    }
}