LaravelFreelancerNL\Aranguent\Query\Concerns\HandlesBindings

Complexity

Total Complexity

15

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Test Coverage

Coverage

81.58%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	generateBindVariable()	0	3	1
A	cleanBindings()	0	8	1
A	getLastBindVariable()	0	3	1
A	addBinding()	0	10	2
A	bindValue()	0	13	4
A	replaceValueWithBindVariable()	0	3	1
A	importBindings()	0	7	2
A	setBindings()	0	13	3

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Illuminate\Database\Query\Expression;
use Illuminate\Database\Query\Builder as IlluminateQueryBuilder;
use InvalidArgumentException;
use LaravelFreelancerNL\Aranguent\Query\Grammar;

trait HandlesBindings
{
    /**
     * Add a binding to the query.
     *
     * @param mixed $value
     * @param string $type
     * @return IlluminateQueryBuilder
     *
     * @throws \InvalidArgumentException
     */
    public function addBinding($value, $type = 'where')
    {
        if (!array_key_exists($type, $this->bindings)) {
            throw new InvalidArgumentException("Invalid binding type: {$type}.");
        }

        $bindVariable = $this->generateBindVariable($type);
        $this->bindings[$type][$bindVariable] = $this->castBinding($value);

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

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

        return $this;

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

    }

    protected function bindValue(mixed $value, string $type = 'where'): mixed
    {
        assert($this->grammar instanceof Grammar);

        if ($this->grammar->isBind($value)) {
            return $value;
        }
        if (!$value instanceof Expression && !$this->isReference($value)) {

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

            $this->addBinding($value, $type);
            $value = $this->replaceValueWithBindVariable($type);
        }

        return $value;
    }

    /**
     * Remove all of the expressions from a list of bindings.
     *
     * @param array<mixed> $bindings
     * @return array<mixed>
     */
    public function cleanBindings(array $bindings)
    {
        return collect($bindings)

$bindings of type array<mixed,mixed> is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->reject(function ($binding) {
                return $binding instanceof Expression;
            })
            ->map([$this, 'castBinding'])
            ->all();
    }

    protected function generateBindVariable(string $type = 'where'): string
    {
        return $this->queryId . '_' . $type . '_' . (count($this->bindings[$type]) + 1);
    }

    protected function getLastBindVariable(string $type = 'where'): string
    {
        return array_key_last($this->bindings[$type]);

The expression return array_key_last($this->bindings[$type]) could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param IlluminateQueryBuilder $query
     * @param string|null $type
     * @return void
     */
    public function importBindings($query, ?string $type = null): void
    {
        if ($type) {
            $this->bindings[$type] = array_merge($this->bindings[$type], $query->bindings[$type]);

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

            return;
        }
        $this->bindings = array_merge_recursive($this->bindings, $query->bindings);
    }

    /**
     * Set the bindings on the query builder.
     *
     * @param  array<mixed>  $bindings
     * @param  string  $type
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function setBindings(array $bindings, $type = 'where')
    {
        if (!array_key_exists($type, $this->bindings)) {
            throw new InvalidArgumentException("Invalid binding type: {$type}.");
        }

        if (empty($bindings)) {
            return $this;
        }

        $this->bindings[$type] = array_merge($this->bindings[$type], $bindings);

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

        return $this;
    }

    protected function replaceValueWithBindVariable(string $type = 'where'): string
    {
        return '@' . $this->getLastBindVariable($type);
    }
}