LaravelFreelancerNL\Aranguent\Schema\Concerns\IndexCommands

Complexity

Total Complexity

31

Size/Duplication

Total Lines	276
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	multiDimensionalIndex()	0	7	1
A	dropMultiDimensionalIndex()	0	3	1
A	dropSpatialIndex()	0	3	1
A	spatialIndex()	0	3	1
A	mapIndexAlgorithm()	0	12	2
A	dropPersistentIndex()	0	3	1
A	primary()	0	5	1
A	dropUnique()	0	3	1
A	geoIndex()	0	3	1
A	dropIndex()	0	9	1
A	unique()	0	8	1
A	invertedIndex()	0	3	1
A	executeDropIndexCommand()	0	12	2
A	dropPrimary()	0	3	1
A	ttlIndex()	0	4	1
A	index()	0	5	1
A	persistentIndex()	0	3	1
A	dropInvertedIndex()	0	3	1
A	indexCommand()	0	19	4
B	executeIndexCommand()	0	29	7

<?php

namespace LaravelFreelancerNL\Aranguent\Schema\Concerns;

use ArangoClient\Exceptions\ArangoException;
use Illuminate\Support\Fluent;

trait IndexCommands
{
    use HandlesIndexNaming;

    /**
     * Add a new index command to the blueprint.
     *
     * @param  string|array<string>|null  $columns
     */
    protected function indexCommand(
        string $type,
        array|null|string $columns = null,
        string $name = null,
        array $indexOptions = [],
    ): Fluent {
        if ($columns === null) {
            $columns = end($this->columns);
        }

        if (is_string($columns)) {
            $columns = [$columns];
        }

        $columns = $this->renameIdField($columns);

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

        $indexOptions['name'] = $name ?: $this->createIndexName($type, $columns, $indexOptions);

        return $this->addCommand('index', compact('type', 'columns', 'indexOptions'));

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

    }

    /**
     * Specify an index for the table.
     *
     * @param array|null|string $columns
     * @param null|string $name
     * @param null|string $algorithm
     * @param array<mixed> $indexOptions
     * @return Fluent
     */
    public function index($columns = null, $name = null, $algorithm = null, $indexOptions = [])
    {
        $type = $this->mapIndexAlgorithm($algorithm);

        return $this->indexCommand($type, $columns, $name, $indexOptions);
    }

    /**
     * Specify a spatial index for the table.
     *
     * @param string|array $columns
     * @param null|string $name
     * @param array<mixed> $indexOptions
     * @return Fluent
     */
    public function spatialIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('geo', $columns, $name, $indexOptions);
    }

    /**
     *  Specify a spatial index for the table.
     *
     * @param  array<mixed>|null|string  $columns
     * @param  null|string  $name
     * @param  array<mixed>  $indexOptions
     * @return Fluent
     */
    public function geoIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->spatialIndex($columns, $name, $indexOptions);
    }

    /**
     *  Specify a inverted index for the table.
     *
     * @param  array<mixed>|null|string  $columns
     * @param  null|string  $name
     * @param  array<mixed>  $indexOptions
     * @return Fluent
     */
    public function invertedIndex($columns = null, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('inverted', $columns, $name, $indexOptions);
    }


    public function multiDimensionalIndex(array $columns = null, string $name = null, array $indexOptions = [], string $type = 'mdi'): Fluent
    {
        return $this->indexCommand(
            $type,
            $columns,
            $name,
            $indexOptions,
        );
    }

    public function persistentIndex(array $columns = null, string $name = null, array $indexOptions = []): Fluent
    {
        return $this->indexCommand('persistent', $columns, $name, $indexOptions);
    }

    /**
     * @param array<string>|null|string $columns
     * @param string|null $name
     * @param array<mixed> $indexOptions
     * @return Fluent
     */
    public function primary($columns = null, $name = null, $indexOptions = []): Fluent
    {
        $indexOptions['unique'] = true;

        return $this->indexCommand('persistent', $columns, $name, $indexOptions);
    }

    /**
     * Create a TTL index for the table.
     *
     * @param string $columns
     * @param int $expireAfter
     * @param null $name

Are you sure the doc-type for parameter $name is correct as it would always require null to be passed?

     * @param array $indexOptions
     * @return Fluent
     */
    public function ttlIndex($columns, $expireAfter, $name = null, $indexOptions = []): Fluent
    {
        $indexOptions['expireAfter'] = $expireAfter;
        return $this->indexCommand('ttl', $columns, $name, $indexOptions);
    }

    /**
     * Specify a unique index for the table.
     *
     * @param  string|array  $columns
     * @param  string  $name
     * @param  string|null  $algorithm
     */
    public function unique($columns = null, $name = null, $algorithm = null): Fluent
    {
        $type = $this->mapIndexAlgorithm($algorithm);

        $indexOptions = [];
        $indexOptions['unique'] = true;

        return $this->indexCommand($type, $columns, $name, $indexOptions);
    }

    /**
     * @throws ArangoException
     */
    public function executeIndexCommand(Fluent $command)
    {
        if ($this->connection->pretending()) {
            $this->connection->logQuery('/* ' . $command->explanation . " */\n", []);

            return;
        }

        // Skip persistent indexes set solely on id - ArangoDB already sets a unique index on _key.
        if (
            $command->type === 'persistent'

The condition $command->type === 'persistent' is always false.

            && count($command->columns) === 1
            && $command->columns[0] === '_key'
        ) {
            return;
        }

        $options = [
            'type' => $command->type,
            'fields' => $command->columns,
            'unique' => $command->unique,
            'options' => $command->indexOptions,
        ];

        if (isset($command->indexOptions) && is_array($command->indexOptions)) {

The condition is_array($command->indexOptions) is always false.

            $options = array_merge($options, $command->indexOptions);
        }

        $this->schemaManager->createIndex($this->table, $options);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropIndex(string $name): Fluent
    {
        $parameters = [];
        $parameters['name'] = 'dropIndex';
        $parameters['index'] = $name;
        $parameters['explanation'] = "Drop the '" . $name . "' index on the {$this->table} table.";
        $parameters['handler'] = 'collection';

        return $this->addCommand('dropIndex', $parameters);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropPersistentIndex(string $name): Fluent
    {
        return $this->dropIndex($name);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropPrimary(string $name): Fluent
    {
        return $this->dropIndex($name);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropUnique(string $name): Fluent
    {
        return $this->dropIndex($name);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropSpatialIndex(string $name): Fluent
    {
        return $this->dropIndex($name);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropInvertedIndex(string $name): Fluent
    {
        return $this->dropIndex($name);
    }

    /**
     * Indicate that the given index should be dropped.
     */
    public function dropMultiDimensionalIndex(string $name): Fluent
    {
        return $this->dropIndex($name);
    }

    /**
     * Drop the index by first getting all the indexes on the table; then selecting the matching one
     * by name.
     */
    public function executeDropIndexCommand(Fluent $command)
    {
        if ($this->connection->pretending()) {
            $this->connection->logQuery('/* ' . $command->explanation . " */\n", []); // @phpstan-ignore-line

            return;
        }
        $indexes = $this->schemaManager->getIndexes($this->table);
        $arrayIndex = array_search($command->index, array_column($indexes, 'name'), true);
        $indexId = $indexes[$arrayIndex]->id;

        $this->schemaManager->deleteIndex($indexId);
    }

    /**
     * @param  string|null  $algorithm
     * @return mixed|string
     */
    protected function mapIndexAlgorithm($algorithm): mixed
    {
        $algorithm = strtoupper($algorithm);

It seems like $algorithm can also be of type null; however, parameter $string of strtoupper() does only seem to accept string, maybe add an additional type check?

        $algorithmConversion = [
            'HASH' => 'hash',
            'BTREE' => 'persistent',
            'RTREE' => 'geo',
            'TTL' => 'ttl',
        ];

        return (isset($algorithmConversion[$algorithm])) ? $algorithmConversion[$algorithm] : 'persistent';
    }

}