LaravelFreelancerNL\Aranguent\Query\Concerns\HandlesAqlGrammar

Complexity

Total Complexity

47

Size/Duplication

Total Lines	349
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	quoteString()	0	7	2
A	isBind()	0	7	3
A	wrapSubquery()	0	3	1
A	substituteBindingsIntoRawSql()	0	16	2
A	wrap()	0	21	6
A	isJsonSelector()	0	7	2
A	parameter()	0	3	2
B	generateAqlObjectString()	0	36	8
A	wrapAttribute()	0	6	2
A	convertJsonFields()	0	15	5
A	wrapValue()	0	12	3
A	translateOperator()	0	7	2
A	convertJsonValuesToDotNotation()	0	8	3
A	convertJsonKeysToDotNotation()	0	9	3
A	generateAqlObject()	0	4	1
A	wrapTable()	0	11	2

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Illuminate\Support\Arr;
use Illuminate\Database\Query\Expression;

trait HandlesAqlGrammar
{
    /**
     * Available predicate operators.
     *
     * @var array<string, int>
     */
    protected array $comparisonOperators = [
        '=='      => 1,
        '!='      => 1,
        '<'       => 1,
        '>'       => 1,
        '<='      => 1,
        '>='      => 1,
        'IN'      => 1,
        'NOT IN'  => 1,
        'LIKE'    => 1,
        '~'       => 1,
        '!~'      => 1,
        'ALL =='  => 1,
        'ALL !='  => 1,
        'ALL <'   => 1,
        'ALL >'   => 1,
        'ALL <='  => 1,
        'ALL >='  => 1,
        'ALL IN'  => 1,
        'ANY =='  => 1,
        'ANY !='  => 1,
        'ANY <'   => 1,
        'ANY >'   => 1,
        'ANY <='  => 1,
        'ANY >='  => 1,
        'ANY IN'  => 1,
        'NONE ==' => 1,
        'NONE !=' => 1,
        'NONE <'  => 1,
        'NONE >'  => 1,
        'NONE <=' => 1,
        'NONE >=' => 1,
        'NONE IN' => 1,
    ];

    /**
     * @var array<string, int>
     */
    protected array $arithmeticOperators = [
        '+' => 1,
        '-' => 1,
        '*' => 1,
        '/' => 1,
        '%' => 1,
    ];

    /**
     * @var array|int[]
     */
    protected array $logicalOperators = [
        'AND' => 1,
        '&&'  => 1,
        'OR'  => 1,
        '||'  => 1,
        'NOT' => 1,
        '!'   => 1,
    ];

    protected string $rangeOperator = '..';

    public function isBind(mixed $value): bool
    {
        if (is_string($value) && preg_match('/^@?[0-9]{4}_[a-zA-Z0-9_$]_[0-9_]+$/', $value)) {
            return true;
        }

        return false;
    }

    /**
     * Get the appropriate query parameter place-holder for a value.
     *
     * @param  mixed  $value
     */
    public function parameter($value): string
    {
        return $this->isExpression($value) ? $this->getValue($value) : (string) $value;

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

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

    }


    /**
     * Quote the given string literal.
     *
     * @param  string|array<string>  $value
     * @return string
     */
    public function quoteString($value)
    {
        if (is_array($value)) {
            return implode(', ', array_map([$this, __FUNCTION__], $value));
        }

        return "`$value`";
    }


    /**
     * Wrap a value in keyword identifiers.
     *
     * @param  Array<mixed>|Expression|string  $value
     * @return array<mixed>|float|int|string
     *
     * @SuppressWarnings("PHPMD.BooleanArgumentFlag")
     */
    public function wrap($value)
    {
        if ($value instanceof Expression) {
            return $value->getValue($this);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\HandlesAqlGrammar is incompatible with the type Illuminate\Database\Grammar expected by parameter $grammar of Illuminate\Database\Query\Expression::getValue().

        }

        if (is_array($value)) {
            foreach ($value as $key => $subvalue) {
                $value[$key] = $this->wrap($subvalue);
            }
            return $value;
        }

        // If the value being wrapped has a column alias we will need to separate out
        // the pieces so we can wrap each of the segments of the expression on its
        // own, and then join these both back together using the "as" connector.
        if (is_string($value) && stripos($value, ' as ') !== false) {
            return $this->wrapAliasedValue($value);

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

        }

        return $this->wrapSegments(explode('.', $value));

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

    }


    /**
     * Wrap a table in keyword identifiers.
     *
     * @param Expression|string  $table
     * @return float|int|string
     */
    public function wrapTable($table, $prefix = null)
    {
        if (!$table instanceof Expression) {
            $wrappedTable = $this->wrap(($prefix ?? $this->tablePrefix) . $table);

            assert(!is_array($wrappedTable));

            return $wrappedTable;
        }

        return $table->getValue($this);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\HandlesAqlGrammar is incompatible with the type Illuminate\Database\Grammar expected by parameter $grammar of Illuminate\Database\Query\Expression::getValue().

    }

    /**
     * Wrap a single string in keyword identifiers.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapValue($value)
    {
        $postfix = '';
        if ($value === 'groupsVariable') {
            $postfix = '[*]';
        }

        if ($value === '*') {
            return $value;
        }

        return '`' . str_replace('`', '``', $value) . '`' . $postfix;
    }

    /**
     * Wrap a single string in keyword identifiers.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapAttribute($value)
    {
        if (!is_string($value)) {

The condition is_string($value) is always true.

            return $value;
        }
        return '`' . str_replace('`', '``', $value) . '`';
    }


    /**
     * Wrap a subquery single string in braces.
     */
    public function wrapSubquery(string $subquery): string
    {
        return '(' . $subquery . ')';
    }

    /**
     * @param array<mixed> $data
     * @return string
     */
    public function generateAqlObject(array $data): string
    {
        $data = Arr::undot($data);
        return $this->generateAqlObjectString($data);
    }

    /**
     * @param array<mixed> $data
     * @return string
     */
    protected function generateAqlObjectString(array $data): string
    {
        foreach ($data as $key => $value) {
            $prefix = $this->wrapAttribute($key) . ': ';

            if (is_numeric($key)) {
                $prefix = '';
            }

            if (is_bool($value)) {
                $booleanString = ($value) ? 'true' : 'false';
                $data[$key] = $prefix . $booleanString;

                continue;
            }

            if (is_array($value)) {
                $data[$key] = $prefix . $this->generateAqlObjectString($value);
                continue;
            }

            if ($value instanceof Expression) {
                $data[$key] = $prefix . $value->getValue($this);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\HandlesAqlGrammar is incompatible with the type Illuminate\Database\Grammar expected by parameter $grammar of Illuminate\Database\Query\Expression::getValue().

                continue;
            }

            $data[$key] = $prefix . $value;
        }

        $returnString = implode(', ', $data);

        if (array_is_list($data)) {
            return '[' . $returnString . ']';
        }

        return '{' . $returnString . '}';
    }

    /**
     * Substitute the given bindings into the given raw AQL query.
     *
     * @param  string  $aql
     * @param  array<mixed>  $bindings
     * @return string
     */
    public function substituteBindingsIntoRawSql($aql, $bindings)
    {
        $bindings = array_map(fn($value) => $this->escape($value), $bindings);

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

        $bindings = array_reverse($bindings);

        foreach ($bindings as $key => $value) {
            $pattern = '/(@' . $key . ')(?![^a-zA-Z_ ,\}\]])/';
            $aql = (string) preg_replace(
                $pattern,
                $value,
                $aql,
            );
        }

        return $aql;
    }

    /**
     * Determine if the given string is a JSON selector.
     *
     * @param  string  $value
     * @return bool
     */
    public function isJsonSelector($value)
    {
        if (!is_string($value)) {

The condition is_string($value) is always true.

            return false;
        }

        return str_contains($value, '->');
    }

    public function convertJsonFields(mixed $data): mixed
    {
        if (!is_array($data) && !is_string($data)) {
            return $data;
        }

        if (is_string($data)) {
            return str_replace('->', '.', $data);
        }

        if (array_is_list($data)) {
            return $this->convertJsonValuesToDotNotation($data);
        }

        return $this->convertJsonKeysToDotNotation($data);
    }

    /**
     * @param array<string> $fields
     * @return array<string>
     */
    public function convertJsonValuesToDotNotation(array $fields): array
    {
        foreach ($fields as $key => $value) {
            if ($this->isJsonSelector($value)) {
                $fields[$key] = str_replace('->', '.', $value);
            }
        }
        return $fields;
    }

    /**
     * @param array<string> $fields
     * @return array<string>
     */
    public function convertJsonKeysToDotNotation(array $fields): array
    {
        foreach ($fields as $key => $value) {
            if ($this->isJsonSelector($key)) {
                $fields[str_replace('->', '.', $key)] = $value;
                unset($fields[$key]);
            }
        }
        return $fields;
    }

    /**
     * Translate sql operators to their AQL equivalent where possible.
     *
     * @param string $operator
     *
     * @return mixed|string
     */
    protected function translateOperator(string $operator)
    {
        if (isset($this->operatorTranslations[strtolower($operator)])) {
            $operator = $this->operatorTranslations[$operator];
        }

        return $operator;
    }

}