LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsUpdates

Complexity

Total Complexity

25

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	decrementEach()	0	13	4
A	incrementEach()	0	13	4
A	updateOrInsert()	0	12	3
B	upsert()	0	47	9
A	prepareValuesForUpdate()	0	18	4
A	update()	0	13	1

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Illuminate\Database\Query\Expression;
use Illuminate\Support\Arr;
use InvalidArgumentException;
use LaravelFreelancerNL\Aranguent\Query\Grammar;
use LaravelFreelancerNL\FluentAQL\Exceptions\BindException;

/**
 * @method applyBeforeQueryCallbacks()
 */
trait BuildsUpdates
{
    protected function prepareValuesForUpdate(array $values)
    {
        foreach($values as $key => $value) {
            if ($value instanceof Expression) {
                $values[$key] = $value->getValue($this->grammar);

                continue;
            }

            if (is_array($value)) {
                $values[$key] = $this->prepareValuesForUpdate($value);
                continue;
            }

            $values[$key]  = $this->bindValue($value, 'update');

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

        }

        return $values;
    }

    /**
     * Update records in the database.
     *
     * @param  array  $values
     * @return int
     */
    public function update(array $values)
    {
        assert($this->grammar instanceof Grammar);

        $this->applyBeforeQueryCallbacks();

        $values = Arr::undot($this->grammar->convertJsonFields($values));

        $values = $this->prepareValuesForUpdate($values);

        $aql = $this->grammar->compileUpdate($this, $values);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsUpdates is incompatible with the type Illuminate\Database\Query\Builder expected by parameter $query of LaravelFreelancerNL\Aranguent\Query\Grammar::compileUpdate().

        return $this->connection->update($aql, $this->getBindings());

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

    }

    /**
     * Insert or update a record matching the attributes, and fill it with values.
     *
     * @param array $attributes
     * @param array $values
     * @return bool
     * @throws BindException
     */
    public function updateOrInsert(array $attributes, array $values = [])
    {
        if (!$this->where($attributes)->exists()) {

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

            $this->bindings['where'] = [];

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

            return $this->insert(array_merge($attributes, $values));

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

        }

        if (empty($values)) {
            return true;
        }

        return (bool) $this->limit(1)->update($values);

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

    }

    /**
     * Increment the given column's values by the given amounts.
     *
     * @param  array<string, float|int|numeric-string>  $columns

The doc comment array<string, float|int|numeric-string> at position 8 could not be parsed: Unknown type name 'numeric-string' at position 8 in array<string, float|int|numeric-string>.

     * @param  array<string, mixed>  $extra
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    public function incrementEach(array $columns, array $extra = [])
    {
        foreach ($columns as $column => $amount) {
            if (!is_numeric($amount)) {
                throw new InvalidArgumentException("Non-numeric value passed as increment amount for column: '$column'.");
            } elseif (!is_string($column)) {
                throw new InvalidArgumentException('Non-associative array passed to incrementEach method.');
            }

            $columns[$column] = new Expression($this->getTableAlias($this->from) . '.' . $column . ' + ' . $amount);

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

        }

        return $this->update(array_merge($columns, $extra));
    }

    /**
     * Decrement the given column's values by the given amounts.
     *
     * @param  array<string, float|int|numeric-string>  $columns

The doc comment array<string, float|int|numeric-string> at position 8 could not be parsed: Unknown type name 'numeric-string' at position 8 in array<string, float|int|numeric-string>.

     * @param  array<string, mixed>  $extra
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    public function decrementEach(array $columns, array $extra = [])
    {
        foreach ($columns as $column => $amount) {
            if (!is_numeric($amount)) {
                throw new InvalidArgumentException("Non-numeric value passed as decrement amount for column: '$column'.");
            } elseif (!is_string($column)) {
                throw new InvalidArgumentException('Non-associative array passed to decrementEach method.');
            }

            $columns[$column] = new Expression($this->getTableAlias($this->from) . '.' . $column . ' - ' . $amount);
        }

        return $this->update(array_merge($columns, $extra));
    }

    /**
     * Insert new records or update the existing ones.
     *
     * @param array $values
     * @param array|string $uniqueBy
     * @param array|null $update
     * @return int
     * @throws BindException
     */
    public function upsert(array $values, $uniqueBy, $update = null)
    {
        assert($this->grammar instanceof Grammar);

        if (empty($values)) {
            return 0;
        } elseif ($update === []) {
            return (int) $this->insert($values);
        }

        if (!is_array(reset($values))) {
            $values = [$values];
        }

        foreach($values as $key => $value) {
            $values[$key] = $this->grammar->convertJsonFields($value);
            $values[$key] = $this->convertIdToKey($values[$key]);

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

            $values[$key] = Arr::undot($values[$key]);
        }

        foreach($values as $key => $value) {
            foreach ($value as $dataKey => $data) {
                $values[$key][$dataKey] = $this->bindValue($data, 'upsert');
            }
        }

        $uniqueBy = $this->grammar->convertJsonFields($uniqueBy);

        if (is_null($update)) {
            $update = array_keys(reset($values));
        }

        foreach ($update as $key => $value) {
            $update[$key] = $this->convertIdToKey($value);
        }

        $update = $this->grammar->convertJsonFields($update);

        $this->applyBeforeQueryCallbacks();

        $bindings = $this->bindings['upsert'];

        $aql = $this->grammar->compileUpsert($this, $values, (array) $uniqueBy, $update);

$this of type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsUpdates is incompatible with the type Illuminate\Database\Query\Builder expected by parameter $query of LaravelFreelancerNL\Aranguent\Query\Grammar::compileUpsert().

        return $this->connection->affectingStatement(
            $aql,
            $bindings
        );
    }
}