Algolia\ScoutExtended\Searchable\Aggregator

Complexity

Total Complexity

1

Size/Duplication

Total Lines	239
Duplicated Lines	0 %

Test Coverage

Coverage

77.59%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	makeAllSearchable()	0	18	3
A	searchable()	0	3	1
A	getModel()	0	7	2
A	unsearchable()	0	3	1
A	create()	0	3	1
A	newCollection()	0	3	1
A	bootSearchable()	0	8	2
	__call()	0	6	?
A	setModel()	0	5	1
A	hp$0 ➔ __call()	0	6	1
A	getRelations()	0	3	1
A	getScoutKey()	0	7	3
A	getModels()	0	3	1
A	getSearchableCount()	0	14	3
A	toSearchableArray()	0	8	3
A	searchableAs()	0	3	1

<?php

declare(strict_types=1);

/**
 * This file is part of Scout Extended.
 *
 * (c) Algolia Team <contact@algolia.com>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 */

namespace Algolia\ScoutExtended\Searchable;

use function in_array;
use Illuminate\Support\Str;
use Laravel\Scout\Searchable;
use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Events\ModelsImported;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\SoftDeletes;
use Algolia\ScoutExtended\Contracts\SearchableCountableContract;
use Algolia\ScoutExtended\Exceptions\ModelNotDefinedInAggregatorException;

abstract class Aggregator implements SearchableCountableContract
{
    use Searchable;

The trait Laravel\Scout\Searchable requires the property $queryCallback which is not provided by Algolia\ScoutExtended\Searchable\Aggregator.

    /**
     * The names of the models that should be aggregated.
     *
     * @var string[]
     */
    protected $models = [];

    /**
     * The model being queried, if any.
     *
     * @var \Illuminate\Database\Eloquent\Model|null
     */
    protected $model;

    /**
     * Map of model relations to load.
     *
     * @var string[]
     */
    protected $relations = [];

    /**
     * Returns the index name.
     *
     * @var string
     */
    protected $indexName;

    /**
     * Boot the aggregator.
     *
     * @return void
     */
    public static function bootSearchable(): void
    {
        ($self = new static)->registerSearchableMacros();

        $observer = tap(resolve(AggregatorObserver::class))->setAggregator(static::class, $models = $self->getModels());

        foreach ($models as $model) {
            $model::observe($observer);
        }
    }

    /**
     * Creates an instance of the aggregator.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     *
     * @return \Algolia\ScoutExtended\Searchable\Aggregator
     */
    public static function create(Model $model): Aggregator
    {
        return (new static)->setModel($model);
    }

    /**
     * Get the names of the models that should be aggregated.
     *
     * @return string[]
     */
    public function getModels(): array
    {
        return $this->models;
    }

    /**
     * Get the model instance being queried.
     *
     * @return \Illuminate\Database\Eloquent\Model
     *
     * @throws \Algolia\ScoutExtended\Exceptions\ModelNotDefinedInAggregatorException
     */
    public function getModel(): Model
    {
        if ($this->model === null) {
            throw new ModelNotDefinedInAggregatorException();
        }

        return $this->model;
    }

    /**
     * Set a model instance for the model being queried.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     *
     * @return \Algolia\ScoutExtended\Searchable\Aggregator
     */
    public function setModel(Model $model): Aggregator
    {
        $this->model = $model;

        return $this;
    }

    /**
     * Get the relations to load.
     * 
     * @param  string  $modelClass
     * 
     * @return  array
     */
    public function getRelations($modelClass): array
    {
        return $this->relations[$modelClass] ?? [];

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

    }

    /**
     * Get the value used to index the model.
     *
     * @return mixed
     */
    public function getScoutKey()
    {
        if ($this->model === null) {
            throw new ModelNotDefinedInAggregatorException();
        }

        return method_exists($this->model, 'getScoutKey') ? $this->model->getScoutKey() : $this->model->getKey();
    }

    /**
     * Get the index name for the searchable.
     *
     * @return string
     */
    public function searchableAs(): string
    {
        return config('scout.prefix').str_replace('\\', '', Str::snake(class_basename(static::class)));
    }

    /**
     * Get the searchable array of the searchable.
     *
     * @return array
     */
    public function toSearchableArray(): array
    {
        if ($this->model === null) {
            throw new ModelNotDefinedInAggregatorException();
        }

        return method_exists($this->model, 'toSearchableArray') ? $this->model->toSearchableArray() :

The expression return method_exists($this->model, 'toSearchableArray') ? $this->model->toSearchableArray() : $this->model->toArray() could return the type Illuminate\Database\Eloquent\Builder which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

            $this->model->toArray();
    }

    /**
     * Make all instances of the model searchable.
     *
     * @return void
     */
    public static function makeAllSearchable()
    {
        foreach ((new static)->getModels() as $model) {
            $instance = new $model;

            $softDeletes =
                in_array(SoftDeletes::class, class_uses_recursive($model)) && config('scout.soft_delete', false);

            $instance->newQuery()->when($softDeletes, function ($query) {
                $query->withTrashed();
            })->orderBy($instance->getKeyName())->chunk(config('scout.chunk.searchable', 500), function ($models) {
                $models = $models->map(function ($model) {
                    return static::create($model);
                })->filter->shouldBeSearchable();

                $models->searchable();

                event(new ModelsImported($models));
            });
        }
    }

    /**
     * {@inheritdoc}
     */
    public function searchable(): void
    {
        AggregatorCollection::make([$this])->searchable();
    }

    /**
     * {@inheritdoc}
     */
    public function unsearchable(): void
    {
        AggregatorCollection::make([$this])->unsearchable();
    }

    /**
     * {@inheritdoc}
     */
    public function getSearchableCount(): int
    {
        $count = 0;

        foreach ($this->getModels() as $model) {
            $softDeletes =
                in_array(SoftDeletes::class, class_uses_recursive($model), true) && config('scout.soft_delete', false);

            $count += $model::query()->when($softDeletes, function ($query) {
                $query->withTrashed();
            })->count();
        }

        return (int) $count;
    }

    /**
     * Create a new Eloquent Collection instance.
     *
     * @param  array  $searchables
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function newCollection(array $searchables = []): Collection
    {
        return new Collection($searchables);
    }

    /**
     * Handle dynamic method calls into the model.
     *
     * @param  string $method
     * @param  array $parameters
     *
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        $model = $this->model ?? new class extends Model {
        };

        return $model->$method(...$parameters);
    }
}