Laravel Scout Bulk Actions

https://github.com/mozex/laravel-scout-bulk-actions
Admin
Import, flush, and queue-import all your Laravel Scout searchable models at once. Auto-discovers...
Tokens:23,782
Snippets:182
Trust Score:8.5
License:MIT
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### Install and publish config with scout-bulk-actions:install

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Usage examples for the install command. The first publishes the config and runs the star prompt; the second, with --no-interaction, publishes config, prints the star note, and opens the repository (suitable for CI).

```bash
# Published config/scout-bulk-actions.php and runs the star prompt
php artisan scout-bulk-actions:install

# Non-interactive (CI): publishes config, prints the star note, opens the repo
php artisan scout-bulk-actions:install --no-interaction
```

--------------------------------

### configurePackage implementation

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Configures the package: publishes config/scout-bulk-actions.php, registers the four bulk commands (scout:import-all, scout:flush-all, scout:queue-import-all, scout:refresh), and registers scout-bulk-actions:install which publishes the config and runs the star prompt.

```php
$package
    ->name('laravel-scout-bulk-actions')
    ->hasConfigFile()
    ->hasCommands([
        FlushAllCommand::class,
        ImportAllCommand::class,
        QueueImportAllCommand::class,
        RefreshCommand::class,
    ])
    ->hasInstallCommand(function (InstallCommand $command): void {
        $command
            ->publishConfigFile()
            ->endWith(fn (InstallCommand $command) => $this->askToStar($command));
    });
```

--------------------------------

### Resolving provider and commands from container

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Shows how to resolve the service provider and access registered commands from the container after package discovery. Includes the four commands via the console kernel and demonstrates calling the install command with Artisan::call().

```php
// After package discovery, all of these resolve from the container:
$provider = app()->getProvider(ScoutBulkActionsServiceProvider::class);

app('Illuminate\Contracts\Console\Kernel')->all(); // includes the four commands

// The install command exists too:
Artisan::call('scout-bulk-actions:install');
```

--------------------------------

### Install package with Composer

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Installs the package via Composer. Requires PHP 8.2+ and Laravel's package discovery auto-registers the service provider.

```bash
composer require mozex/laravel-scout-bulk-actions
```

--------------------------------

### Usage example with FindsSearchableModels trait

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Example of using the trait in a custom command. Iterates over the returned collection and prints each model FQCN. The method performs no error handling; misconfigured directories cause Finder exceptions.

```php
use Mozex\ScoutBulkActions\Commands\Concerns\FindsSearchableModels;

class CustomReindexCommand extends Command
{
    use FindsSearchableModels;

    public function handle(): int
    {
        foreach ($this->getSearchableModels() as $model) {
            // $model is a string FQCN, e.g. "App\Models\Post"
            $this->info("Found: {$model}");
        }

        return self::SUCCESS;
    }
}
```

--------------------------------

### Publish configuration with artisan scout-bulk-actions:install

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/configuration.md

Publishes the package configuration file `config/scout-bulk-actions.php`. Alternatively, `php artisan vendor:publish` can be used via spatie's `hasConfigFile()`. After changing the config in production, run `php artisan config:clear` to pick up new values.

```bash
php artisan scout-bulk-actions:install
```

--------------------------------

### Platform command selection for openInBrowser()

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Platform command selection for openInBrowser(). On Linux, xdg-open is backgrounded through sh and guarded by command -v xdg-open; on macOS 'open' runs; on Windows 'cmd /c start'. The repository URL is the $repository property.

```php
$command = match (PHP_OS_FAMILY) {
    'Darwin' => ['open', $this->repository],
    'Windows' => ['cmd', '/c', 'start', '', $this->repository],
    default => ['sh', '-c', 'command -v xdg-open > /dev/null && (xdg-open "$1" > /dev/null 2>&1 &)', 'sh', $this->repository],
};
```

--------------------------------

### scout:refresh command usage examples

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-refresh.md

Basic command-line usage of the scout:refresh Artisan command. Shows the default clean re-index, refreshing a single model, controlling the import batch size with --chunk, and skipping the production confirmation with --force.

```bash
# Clean re-index of every discovered searchable model
# (= scout:flush-all followed by scout:import-all)
php artisan scout:refresh

# Refresh a single model only
php artisan scout:refresh "App\Models\Post"

# Control the import batch size for the re-index
php artisan scout:refresh --chunk=200

# Automated / CI run — skip the production confirmation
php artisan scout:refresh --force
```

--------------------------------

### Basic scout:import-all command with options

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-import-all.md

Shows the basic command to discover and import all searchable models, with optional `--chunk` to set batch size (falls back to `scout.chunk.searchable`) and `--fresh` to flush each model before importing.

```bash
# Discover all searchable models and import each one
php artisan scout:import-all

# With an explicit batch size (falls back to scout.chunk.searchable otherwise)
php artisan scout:import-all --chunk=200

# Flush each model from the index right before importing that model
php artisan scout:import-all --fresh
```

--------------------------------

### scout:import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-import-all.md

Documentation for the scout:import-all artisan command, including its options and usage.

```APIDOC
## scout:import-all

### Description
Imports every discovered searchable model into the search index. For each discovered model the command invokes Laravel Scout's native `scout:import` command with the forwarded options.

### Method
CLI command

### Endpoint
`php artisan scout:import-all`

### Parameters
#### Options
- `--chunk` / `-c` (int) - Optional - The number of records to import at a time. Defaults to the `scout.chunk.searchable` configuration value. Forwarded to `scout:import --chunk`.
- `--fresh` (boolean flag) - Optional - Flush each model from the index before importing it. Forwarded to `scout:import --fresh`. Only supported by Laravel Scout ≥ 10.18.
- `--force` (boolean flag) - Optional - Force the operation to run when in production, skipping the confirmation prompt.

### Request Example
```bash
php artisan scout:import-all --chunk=500 --fresh --force
```

### Response
#### Success Response
No explicit response schema is documented. The command outputs standard Laravel command output.

#### Response Example
No explicit response example is provided in the source.
```

--------------------------------

### Artisan Command: scout:queue-import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-queue-import-all.md

Documentation for the artisan command scout:queue-import-all, including usage, options, error handling, and exit codes.

```APIDOC
## [ARTISAN] scout:queue-import-all

### Description
Queue chunked import jobs for every discovered model on the default queue. Supports per-job chunk size, targeting a specific queue, and ordering by ID.

### Method
Artisan command

### Endpoint
`php artisan scout:queue-import-all`

### Parameters
#### Options
- `--chunk` (int) - Optional - Per-job chunk size. Default is the Scout queue chunk size.
- `--queue` (string) - Optional - Target a specific queue. Falls back to `scout.queue.queue` otherwise.
- `--order` (string) - Optional - Order of IDs to process. Must be `asc` or `desc`. Default is `asc`.
- `--force` (bool) - Optional - Force the operation to run in production without confirmation.

### Request Example
```bash
# Basic call
php artisan scout:queue-import-all

# Per-job chunk size
php artisan scout:queue-import-all --chunk=500

# Target a specific queue
php artisan scout:queue-import-all --queue=indexing

# Index the highest IDs first
php artisan scout:queue-import-all --order=desc
```

### Response
#### Success Response (0)
- Exit code `0` when all models are queued successfully.

#### Error Response (1)
- Exit code `1` when `--order` is invalid, confirmation is declined, or any model's queue import fails.
- Error messages:
  - `The order option must be either "asc" or "desc".`
  - `Queue importing [<model>] has been failed.`
  - `InvalidArgumentException` ("Progress bar must have at least one item.") when zero models are discovered.

### Notes
- The command fails fast with exit code 1 before dispatching any jobs if `--order` is invalid.
- In production, confirmation is required unless `--force` is provided.
- If any model's `scout:queue-import` call fails, the command returns exit code 1 and prints an error message.
```

--------------------------------

### Composer commands for running checks and tests

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/CLAUDE.md

Run all checks (formatting + static analysis + tests) with `composer test`. Individual checks include `composer lint` (fix formatting with Pint), `composer test:lint` (check formatting), `composer test:types` (PHPStan level 6), and `composer test:unit` (Pest tests). Also shows how to run a single test file and a single test by name.

```bash
# Run all checks (formatting + static analysis + tests)
composer test

# Individual checks
composer lint            # Fix code formatting (Pint)
composer test:lint       # Check code formatting without fixing
composer test:types      # PHPStan static analysis (level 6)
composer test:unit       # Run Pest tests

# Run a single test file
./vendor/bin/pest tests/Commands/ImportAllCommandTest.php

# Run a single test by name
./vendor/bin/pest --filter="test name here"
```

--------------------------------

### scout:queue-import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/index.md

Artisan command to queue the import of all searchable models.

```APIDOC
## scout:queue-import-all

### Description
Queues the import of all Eloquent models that use Laravel Scout's Searchable trait into the search index.

### Command
`php artisan scout:queue-import-all`

### Class
`Mozex\ScoutBulkActions\Commands\QueueImportAllCommand`

### Options
No options are documented in the source.

### Example
```bash
php artisan scout:queue-import-all
```
```

--------------------------------

### scout:queue-import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-queue-import-all.md

Command-line interface for dispatching queued, chunked import jobs for all searchable models.

```APIDOC
## scout:queue-import-all

### Description
Dispatches queued, chunked import jobs for every discovered searchable model instead of importing synchronously. For each discovered model the command invokes Laravel Scout's native `scout:queue-import` command with the forwarded options.

### Method
CLI

### Command
`scout:queue-import-all`

### Parameters
#### Options
- **--chunk** (`-c`) (int) - Optional - Number of records queued per job. Defaults to `scout.chunk.searchable` config value. Forwarded to `scout:queue-import --chunk`.
- **--order** (string: `asc`|`desc`) - Optional - Direction in which each model's ID ranges are queued. `asc` queues lowest IDs first; `desc` highest IDs first. Requires Laravel Scout ≥ 11.4. Forwarded to `scout:queue-import --order`.
- **--queue** (string) - Optional - Name of the queue the import jobs are dispatched to. Defaults to `scout.queue.queue` config value. Forwarded to `scout:queue-import --queue`.
- **--force** (boolean flag) - Optional - Skip the production confirmation prompt.

### Example
```bash
php artisan scout:queue-import-all --chunk=500 --order=asc --queue=imports --force
```
```

--------------------------------

### Basic scout:queue-import-all command usage

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-queue-import-all.md

Shows the basic command invocations for the scout:queue-import-all Artisan command. The --chunk option sets the per-job chunk size, --queue targets a specific queue (falling back to scout.queue.queue otherwise), and --order=desc indexes highest IDs first so recent records appear early in search.

```bash
# Queue chunked import jobs for every discovered model on the default queue
php artisan scout:queue-import-all

# Per-job chunk size
php artisan scout:queue-import-all --chunk=500

# Target a specific queue (falls back to scout.queue.queue otherwise)
php artisan scout:queue-import-all --queue=indexing

# Index the highest IDs first, so recent records appear in search early
php artisan scout:queue-import-all --order=desc
```

--------------------------------

### Run scout:import-all to import all searchable models

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Imports all discovered searchable models into the search index. The chunk size for each batch can be controlled with the --chunk option. If --chunk is omitted, the scout.chunk.searchable config value is used.

```bash
php artisan scout:import-all
```

--------------------------------

### configurePackage method signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Method signature for the single extension point of the package wiring. Called by the framework.

```php
public function configurePackage(Package $package): void
```

--------------------------------

### scout:import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/index.md

Artisan command to import all searchable models into the search index.

```APIDOC
## scout:import-all

### Description
Imports all Eloquent models that use Laravel Scout's Searchable trait into the search index.

### Command
`php artisan scout:import-all`

### Class
`Mozex\ScoutBulkActions\Commands\ImportAllCommand`

### Options
No options are documented in the source.

### Example
```bash
php artisan scout:import-all
```
```

--------------------------------

### Run all commands with --force in production

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Skip the confirmation prompt in production by passing --force. Useful for CI pipelines or automated scripts.

```bash
php artisan scout:import-all --force
php artisan scout:flush-all --force
php artisan scout:queue-import-all --force
php artisan scout:refresh --force
```

--------------------------------

### scout:import-all command

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Bulk imports all searchable models. Options: --chunk=N (-c N) sets records per batch (falls back to scout.chunk.searchable config), --fresh flushes each model before importing it, and --force skips the production confirmation prompt.

```bash
php artisan scout:import-all
php artisan scout:import-all --chunk=500
php artisan scout:import-all --fresh
php artisan scout:import-all --force
```

--------------------------------

### Run scout:import-all with --chunk=200

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Imports all searchable models with a custom chunk size of 200 records per batch. Use this to tune performance for large datasets.

```bash
php artisan scout:import-all --chunk=200
```

--------------------------------

### handle() method signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-flush-all.md

Entry point called by the Artisan console. Returns an integer status code.

```php
public function handle(): int
```

--------------------------------

### getSearchableModels() implementation

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Implementation of getSearchableModels(). Finder->files() yields SplFileInfo objects; ->keys() collects file paths, map converts each path to a namespace, filter applies model checks (isSearchableModel used as truthy predicate), and values() re-indexes the result.

```php
return collect($this->getSpecifiedFiles())
    ->keys()
    ->map($this->makeNamespaceFromPath(...))
    ->filter($this->isSearchableModel(...))
    ->values();
```

--------------------------------

### Run scout:refresh for clean re-index

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Flushes then imports all models in one step for a clean re-index. When no model is specified, it runs scout:flush-all followed by scout:import-all under the hood.

```bash
php artisan scout:refresh
```

--------------------------------

### CI pipeline command with --force

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-import-all.md

For CI pipelines, use `--force` to avoid the confirmation prompt blocking. Combines `--chunk=500` and `--fresh` for a non-interactive import.

```bash
php artisan scout:import-all --chunk=500 --fresh --force
```

--------------------------------

### Error handling with Artisan::call and --force

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-import-all.md

Shows how to call the command programmatically in production, where a confirmation prompt appears unless `--force` is passed. Exit code 0 means all models imported; 1 means confirmation declined or a model failed, stopping at the first failing model.

```php
use Illuminate\Support\Facades\Artisan;

// In production (APP_ENV=production) this prompts unless --force is passed.
$exitCode = Artisan::call('scout:import-all', ['--force' => true]);

// 0 = every model imported, 1 = confirmation declined or a model failed.
if ($exitCode !== 0) {
    // The command stopped at the first failing model; remaining models were not imported.
    report('Scout bulk import failed with exit code '.$exitCode);
}
```

--------------------------------

### scout:queue-import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Same as scout:import-all, but dispatches queued jobs instead of running synchronously. Use this for large datasets. Supports chunk size, order direction, queue name, and force.

```APIDOC
## scout:queue-import-all

### Description
Same as `scout:import-all`, but dispatches queued jobs instead of running synchronously. Use this for large datasets.

### Method
Artisan Command

### Command
php artisan scout:queue-import-all

### Options
- `--chunk=N` (`-c N`) (integer) - Optional - Records per queued job. Falls back to `scout.chunk.searchable` config if omitted.
- `--order=asc|desc` (string) - Optional - Direction each model's ID range is queued in. Defaults to `asc` (oldest rows first) on Scout's side. Use `desc` to index the highest IDs first so recent content becomes searchable early in a long rebuild. Any other value fails the command before anything is dispatched. Requires Laravel Scout 11.4+.
- `--queue=NAME` (string) - Optional - Target queue name. Falls back to `scout.queue.queue` config if omitted.
- `--force` (boolean) - Optional - Skips the production confirmation prompt.

### Usage Examples
```bash
php artisan scout:queue-import-all
php artisan scout:queue-import-all --chunk=500 --queue=scout
php artisan scout:queue-import-all --order=desc
```
```

--------------------------------

### Command signature and description for scout:import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-import-all.md

Declares the command's signature and description as public properties. The signature defines the `--chunk`, `--fresh`, and `--force` options. The `--chunk` option defaults to the `scout.chunk.searchable` config value, `--fresh` flushes each model before importing (requires Laravel Scout >= 10.18), and `--force` skips the production confirmation prompt.

```php
public $signature = 'scout:import-all
        {--c|chunk= : The number of records to import at a time (Defaults to configuration value: `scout.chunk.searchable`)}
        {--fresh : Flush each model from the index before importing it}
        {--force : Force the operation to run when in production}';

public $description = 'Import all models into the search index.';
```

--------------------------------

### Run scout:queue-import-all for queued index rebuild

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Dispatches queued jobs that split each model's records into chunks by ID range, applying Scout's native queue-import approach across all models at once. This is the fastest way to rebuild indexes for projects with many models and millions of rows.

```bash
php artisan scout:queue-import-all
```

--------------------------------

### scout:import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Discovers all searchable models and imports each one into the search index. Supports chunk size, fresh flush before import, and force to skip production confirmation.

```APIDOC
## scout:import-all

### Description
Discovers all searchable models and imports each one into the search index.

### Method
Artisan Command

### Command
php artisan scout:import-all

### Options
- `--chunk=N` (`-c N`) (integer) - Optional - Records per batch. Falls back to `scout.chunk.searchable` config if omitted.
- `--fresh` (boolean) - Optional - Flushes each model from the index immediately before importing that model. Unlike `scout:refresh`, which flushes every model first and then imports, a model is only missing from the index for the duration of its own import.
- `--force` (boolean) - Optional - Skips the production confirmation prompt.

### Usage Examples
```bash
php artisan scout:import-all
php artisan scout:import-all --chunk=500
php artisan scout:import-all --fresh
php artisan scout:import-all --force
```
```

--------------------------------

### Command signature and description properties

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-flush-all.md

Declares the command's signature and description as public properties. The `--force` option skips the production confirmation prompt.

```php
public $signature = 'scout:flush-all {--force : Force the operation to run when in production}';

public $description = 'Flush the records of all models from the index.';
```

--------------------------------

### Default config/scout-bulk-actions.php with model_directories

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/configuration.md

Default published configuration for `config/scout-bulk-actions.php`. The `model_directories` key is required and defaults to `[app_path('Models')]`. Each entry may be a directory path or a glob pattern (Symfony Finder expands it), e.g. `base_path('Modules/*/Models')`. An empty array makes Symfony Finder's `in([])` throw `InvalidArgumentException` ("At least one path must be provided."). Consumed by `getSpecifiedFiles()` in `src/Commands/Concerns/FindsSearchableModels.php:33`.

```php
return [
    'model_directories' => [
        app_path('Models'),
        // base_path('Modules/*/Models'),
    ],
];
```

--------------------------------

### Define scout:queue-import-all signature and description

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-queue-import-all.md

Declares the command signature and description as public properties. The signature defines the `scout:queue-import-all` command with options `--chunk`/`-c`, `--order`, `--queue`, and `--force`. The `--order` option requires Laravel Scout 11.4+ and is validated by the command because Scout reports an invalid order with a zero exit code.

```php
public $signature = 'scout:queue-import-all
        {--c|chunk= : The number of records to queue in a single job (Defaults to configuration value: `scout.chunk.searchable`)}
        {--order= : The order in which ranges should be queued, `asc` or `desc` (Requires Laravel Scout 11.4+)}
        {--queue= : The queue that should be used (Defaults to configuration value: `scout.queue.queue`)}
        {--force : Force the operation to run when in production}';

public $description = 'Queue import all models into the search index via chunked, queued jobs.';
```

--------------------------------

### openInBrowser() method signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Declared at src/ScoutBulkActionsServiceProvider.php:87. Protected method that attempts to open the repository URL in the default browser. Returns true when the OS opener command runs successfully, false when Process::run() successful() is false or an exception (Throwable) is thrown.

```php
protected function openInBrowser(): bool
```

--------------------------------

### Publish config and configure model directories

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Publishes the configuration file `config/scout-bulk-actions.php`. The `model_directories` array specifies where to scan for searchable models; default is `app/Models`, and glob patterns like `base_path('Modules/*/Models')` work for modular architectures. After changing config in production, run `php artisan config:clear`.

```bash
php artisan scout-bulk-actions:install
```

```php
return [
    'model_directories' => [
        app_path('Models'),
        // base_path('Modules/*/Models'),
    ],
];
```

--------------------------------

### scout:queue-import-all command

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Dispatches queued jobs for bulk import. --chunk=N (-c N) sets records per queued job (falls back to scout.chunk.searchable config), --order=asc|desc controls ID range direction (defaults to asc, requires Scout 11.4+), --queue=NAME targets a queue (falls back to scout.queue.queue config), and --force skips the production confirmation prompt.

```bash
php artisan scout:queue-import-all
php artisan scout:queue-import-all --chunk=500 --queue=scout
php artisan scout:queue-import-all --order=desc
```

--------------------------------

### Show scout:queue-import-all options

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Show the options for scout:queue-import-all: --chunk sets the chunk size per job, --queue specifies the queue to dispatch jobs to, and --order can be asc (default) or desc. The --order option requires Laravel Scout 11.4 or newer.

```bash
# Set the chunk size per job
php artisan scout:queue-import-all --chunk=500

# Specify which queue to dispatch jobs to
php artisan scout:queue-import-all --queue=indexing

# Queue the highest IDs first
php artisan scout:queue-import-all --order=desc
```

--------------------------------

### Configure Model Directories

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Define the directories where the package should scan for models in config/scout-bulk-actions.php. Glob patterns are supported for modular application structures.

```php
// config/scout-bulk-actions.php
return [
    'model_directories' => [
        app_path('Models'),
        // base_path('Modules/*/Models'),
    ],
];
```

--------------------------------

### Programmatic call with error handling for scout:queue-import-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-queue-import-all.md

Shows how to call the command programmatically via Artisan::call. An invalid --order value fails fast with exit code 1 and prints 'The order option must be either "asc" or "desc".' before any jobs are queued. The correct production rebuild uses --chunk, --order, --queue, and --force; a non-zero exit code indicates confirmation was declined or a model's scout:queue-import call failed, printing 'Queue importing [App\Models\Post] has been failed.' for a failing model.

```php
use Illuminate\Support\Facades\Artisan;

// Invalid --order fails fast with exit code 1, before anything is dispatched:
$exitCode = Artisan::call('scout:queue-import-all', ['order' => 'sideways']);
// -> Prints: The order option must be either "asc" or "desc".
// -> Returns 1; no jobs were queued.

// Correct combination for a production rebuild:
$exitCode = Artisan::call('scout:queue-import-all', [
    '--chunk' => 500,
    '--order' => 'desc',
    '--queue' => 'indexing',
    '--force' => true,
]);

if ($exitCode !== 0) {
    // Confirmation declined, or a model's scout:queue-import call failed.
    // A failing model prints: Queue importing [App\Models\Post] has been failed.
    report('Scout bulk queue import failed with exit code '.$exitCode);
}
```

--------------------------------

### handleAll() method signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-refresh.md

Signature of the protected method that refreshes every discovered searchable model. It returns the exit code of the flush-all step when non-zero, otherwise Command::SUCCESS.

```php
protected function handleAll(): int
```

--------------------------------

### Basic scout:flush-all artisan commands

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-flush-all.md

Flush every discovered searchable model from the index. The --force flag skips the production confirmation prompt for CI or automated runs.

```bash
# Flush every discovered searchable model from the index
php artisan scout:flush-all

# Skip the production confirmation prompt (CI / automated runs)
php artisan scout:flush-all --force
```

--------------------------------

### makeNamespaceFromPath behavior implementation

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Behavior of makeNamespaceFromPath. Strips the base path, removes .php, converts separators to namespace separators, ucfirst each segment, prepends config('scout-bulk-actions.namespace'), filters empty segments, and joins with backslashes. Note: the config key is not present in the published config file.

```php
return str($path)
    ->after(realpath(base_path()).DIRECTORY_SEPARATOR)
    ->replace(['/', '.php'], ['\\', ''])
    ->explode('\\')
    ->map(fn (string $dir) => ucfirst($dir))
    ->prepend(config('scout-bulk-actions.namespace'))
    ->filter()
    ->implode('\\');
```

--------------------------------

### Handle command failures with exit codes and exceptions

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/errors.md

Shows how to handle failures from the scout:import-all and scout:flush-all commands. The import command returns exit codes (0 for success, 1 for confirmation declined or model failure) while the flush command throws InvalidArgumentException for discovery failures. Use this pattern to detect and respond to command failures in consumer code.

```php
use Illuminate\Support\Facades\Artisan;

// Exit-code based handling (covers cases 1, 2, 3, 6):
$exitCode = Artisan::call('scout:import-all', ['--force' => true]);
match ($exitCode) {
    0 => report('ok'),
    1 => report('confirmation declined or a model failed; stopped at first failure'),
    default => report("unexpected exit code $exitCode"),
};

// Exception-based handling (covers cases 4 and 5):
try {
    $exitCode = Artisan::call('scout:flush-all', ['--force' => true]);
} catch (\InvalidArgumentException $e) {
    // "Progress bar must have at least one item." — no models discovered.
    // "At least one path must be provided." — model_directories is empty.
}
```

--------------------------------

### scout:flush-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/index.md

Artisan command to flush all searchable models from the search index.

```APIDOC
## scout:flush-all

### Description
Flushes (clears) the search index for all Eloquent models that use Laravel Scout's Searchable trait.

### Command
`php artisan scout:flush-all`

### Class
`Mozex\ScoutBulkActions\Commands\FlushAllCommand`

### Options
No options are documented in the source.

### Example
```bash
php artisan scout:flush-all
```
```

--------------------------------

### Run scout:import-all with --fresh flag

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Flushes each model from the index immediately before that model is imported. Unlike scout:refresh, which empties every index first, this keeps other models searchable while the rebuild runs.

```bash
php artisan scout:import-all --fresh
```

--------------------------------

### scout:refresh command

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Flushes then imports for a clean re-index. Optional model argument is a fully qualified class name; if omitted, it calls scout:flush-all then scout:import-all internally. --chunk=N (-c N) is passed to the import step, and --force skips the production confirmation prompt (passed automatically when refreshing all models).

```bash
# All models
php artisan scout:refresh

# Single model
php artisan scout:refresh "App\Models\Post"

# With chunk size
php artisan scout:refresh --chunk=500
```

--------------------------------

### scout:flush-all command

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Removes all records from the search index for every discovered model. --force skips the production confirmation prompt.

```bash
php artisan scout:flush-all
php artisan scout:flush-all --force
```

--------------------------------

### scout:refresh

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-refresh.md

Documentation for the scout:refresh artisan command, including its arguments and options.

```APIDOC
## [COMMAND] scout:refresh

### Description
Flushes models from the search index, then imports them back — a clean re-index in one step. Works for a single named model or for every discovered model.

### Command
`scout:refresh`

### Arguments
- **model** (string) - Optional - Fully qualified class name of a single model to refresh, e.g. `App\Models\Post`. When omitted, every discovered searchable model is refreshed. Note: the value is forwarded verbatim to `scout:flush` / `scout:import`; it is **not** validated against model discovery.

### Options
- **--chunk** / **-c** (int) - Optional - Number of records to import per batch. Only applies to the import step. Defaults to the `scout.chunk.searchable` configuration value.
- **--force** (boolean flag) - Optional - Skip the production confirmation prompt.

### Description Property
Flush models then Import them into the search index.
```

--------------------------------

### getSearchableModels() signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Public method signature with docblock. Returns a 0-indexed collection of fully qualified class names (e.g. App\Models\Post) ordered by Symfony Finder file iteration, with non-model/non-searchable files filtered out. Could be empty when no directories are configured or no files pass the checks.

```php
/**
 * Get all searchable models that should be used for flushing and importing.
 *
 * @return Collection<int, string>
 */
public function getSearchableModels(): Collection
```

--------------------------------

### Run scout:refresh for a specific model

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Refreshes a single model by passing its class name. The --chunk option works here too.

```bash
php artisan scout:refresh "App\Models\Post"
```

--------------------------------

### Run scout:flush-all to clear search indexes

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/README.md

Removes all records from the search index for every discovered model. Useful for clearing the index before a full re-import.

```bash
php artisan scout:flush-all
```

--------------------------------

### $repository property declaration

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Declared at src/ScoutBulkActionsServiceProvider.php:17. Protected property holding the repository URL used by askToStar() and openInBrowser().

```php
protected string $repository = 'https://github.com/mozex/laravel-scout-bulk-actions';
```

--------------------------------

### Error handling for scout:refresh with Artisan::call

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-refresh.md

Programmatic invocation of scout:refresh via the Artisan facade. A non-zero exit code indicates the flush step failed and the import was skipped; a rejected production confirmation also yields 1 when --force is omitted.

```php
use Illuminate\Support\Facades\Artisan;

$exitCode = Artisan::call('scout:refresh', ['--force' => true]);

if ($exitCode !== 0) {
    // 1 (or the wrapped scout:flush / scout:flush-all exit code) means the
    // flush step failed and the import step was never executed. A rejected
    // production confirmation also yields 1 when --force is omitted.
    report('Scout refresh aborted before importing: exit code '.$exitCode);
}
```

--------------------------------

### getSearchableModels(): Collection

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Returns a collection of fully qualified class names for all searchable models, ordered by file iteration order. Filters out non-model and non-searchable files.

```APIDOC
## getSearchableModels(): Collection

### Description
Returns a collection of fully qualified class names for all searchable models, ordered by file iteration order. Filters out non-model and non-searchable files.

### Method
GET

### Endpoint
`getSearchableModels()`

### Parameters
#### Path Parameters
- *(none)*

#### Query Parameters
- *(none)*

#### Request Body
- *(none)*

### Request Example
```php
use Mozex\ScoutBulkActions\Commands\Concerns\FindsSearchableModels;

class CustomReindexCommand extends Command
{
    use FindsSearchableModels;

    public function handle(): int
    {
        foreach ($this->getSearchableModels() as $model) {
            // $model is a string FQCN, e.g. "App\Models\Post"
            $this->info("Found: {$model}");
        }

        return self::SUCCESS;
    }
}
```

### Response
#### Success Response (200)
- **Return type** (`Illuminate\Support\Collection<int, string>`) - A 0-indexed collection of fully qualified class names (e.g. `App\Models\Post`), ordered by file iteration order.

#### Response Example
```php
collect([
    'App\Models\Post',
    'App\Models\Comment',
])
```

### Error Handling
- **InvalidArgumentException** - Thrown when `config('scout-bulk-actions.model_directories')` is an empty array, causing Symfony Finder to throw "At least one path must be provided."
- **Finder exceptions** - Misconfigured or nonexistent directories surface as Finder exceptions rather than empty results.
- No custom exception is defined for discovery failures.
```

--------------------------------

### Error handling with Artisan::call

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-flush-all.md

Calls the command programmatically. In production, it prompts with 'Are you sure you want to run this command?' — declining returns 1. A non-zero exit code indicates either declined confirmation or a failure in a scout:flush call, which prints 'Flushing [App\Models\Post] has been failed.'.

```php
use Illuminate\Support\Facades\Artisan;

// Plain call: in production this prompts with
// "Are you sure you want to run this command?" — declining returns 1.
$exitCode = Artisan::call('scout:flush-all');

if ($exitCode !== 0) {
    // Either the confirmation was declined, or flushing already stopped at
    // the first model whose scout:flush call failed.
    // A non-zero exit from the underling scout:flush prints:
    //   Flushing [App\Models\Post] has been failed.
    report('Scout bulk flush failed with exit code '.$exitCode);
}
```

--------------------------------

### scout:refresh

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Flushes then imports for a clean re-index. Works for one model or all of them. Accepts an optional model argument and chunk size option.

```APIDOC
## scout:refresh

### Description
Flushes then imports for a clean re-index. Works for one model or all of them.

### Method
Artisan Command

### Command
php artisan scout:refresh [model]

### Arguments
- `model` (string) - Optional - Fully qualified class name. If omitted, it calls `scout:flush-all` then `scout:import-all` internally.

### Options
- `--chunk=N` (`-c N`) (integer) - Optional - Passed through to the import step.
- `--force` (boolean) - Optional - Skips the production confirmation prompt.

### Usage Examples
```bash
# All models
php artisan scout:refresh

# Single model
php artisan scout:refresh "App\Models\Post"

# With chunk size
php artisan scout:refresh --chunk=500
```

### Notes
When refreshing all models, the command passes `--force` to the sub-commands automatically so you won't get prompted twice.
```

--------------------------------

### scout:refresh

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/index.md

Artisan command to refresh the search index for all searchable models.

```APIDOC
## scout:refresh

### Description
Refreshes the search index for all Eloquent models that use Laravel Scout's Searchable trait by flushing and re-importing them.

### Command
`php artisan scout:refresh`

### Class
`Mozex\ScoutBulkActions\Commands\RefreshCommand`

### Options
No options are documented in the source.

### Example
```bash
php artisan scout:refresh
```
```

--------------------------------

### getSpecifiedFiles(): Finder signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Protected method declared in FindsSearchableModels.php:30. Returns a Symfony Finder configured with ->in(config('scout-bulk-actions.model_directories'))->files(). Supports glob patterns in directory paths.

```php
protected function getSpecifiedFiles(): Finder
```

--------------------------------

### isSearchableModel() implementation

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Implementation of the isSearchableModel() predicate. Returns true only if the class exists, is not abstract, extends Eloquent Model, and directly uses the Searchable trait.

```php
return class_exists($namespace)
    && ! (new ReflectionClass($namespace))->isAbstract()
    && is_subclass_of($namespace, Model::class)
    && in_array(Searchable::class, class_uses($namespace));
```

--------------------------------

### scout:flush-all

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/resources/boost/skills/scout-bulk-actions/SKILL.md

Removes all records from the search index for every discovered model. Supports force to skip production confirmation.

```APIDOC
## scout:flush-all

### Description
Removes all records from the search index for every discovered model.

### Method
Artisan Command

### Command
php artisan scout:flush-all

### Options
- `--force` (boolean) - Optional - Skips the production confirmation prompt.

### Usage Examples
```bash
php artisan scout:flush-all
php artisan scout:flush-all --force
```
```

--------------------------------

### composer.json provider declaration

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-bulk-actions-service-provider.md

Declares the service provider for Laravel package discovery in composer.json. No manual registration is required after composer require.

```json
"extra": {
    "laravel": {
        "providers": [
            "Mozex\\ScoutBulkActions\\ScoutBulkActionsServiceProvider"
        ]
    }
}
```

--------------------------------

### makeNamespaceFromPath(string $path): string signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Protected method declared in FindsSearchableModels.php:38. Takes an absolute file path and returns the fully qualified class name derived from it.

```php
protected function makeNamespaceFromPath(string $path): string
```

--------------------------------

### flushModel method signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/scout-flush-all.md

Protected method that flushes a single model. Returns true on success, false when the wrapped scout:flush call returns a non-zero exit code. On failure it prints 'Flushing [<model>] has been failed.' and returns false.

```php
protected function flushModel(string $model): bool
```

--------------------------------

### isSearchableModel() method signature

Source: https://github.com/mozex/laravel-scout-bulk-actions/blob/main/_autodocs/api-reference/finds-searchable-models.md

Signature of the protected predicate method that checks whether a fully qualified class name is a searchable model.

```php
protected function isSearchableModel(string $namespace): bool
```
Tokens:
Raw