Sushi

https://github.com/calebporzio/sushi
Admin
Sushi is Laravel's missing array driver that enables using Eloquent models with array-based fixture...
Tokens:20,128
Snippets:156
Trust Score:10
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Usage example: get column listing via resolveConnection

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Shows how to use resolveConnection() to get the schema builder and list columns for the 'states' table.

```php
$columns = State::resolveConnection()->getSchemaBuilder()->getColumnListing('states');
```

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

### Install Sushi via Composer

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Install the package using Composer. Requires the pdo-sqlite PHP extension.

```bash
composer require calebporzio/sushi
```

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

### Define a Role model with Sushi

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Example of a Role model using Sushi with an array of rows including id and label.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['id' => 1, 'label' => 'admin'],
        ['id' => 2, 'label' => 'manager'],
        ['id' => 3, 'label' => 'user'],
    ];
}
```

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

### Model with type inference example

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Shows a Sushi model with rows that infer column types: name→string, price→float, starts_at→dateTime, plus an auto-incrementing id.

```php
class Event extends Model
{
    use \Sushi\Sushi;

    protected $rows = [['name' => 'Launch', 'price' => 99.99, 'starts_at' => new DateTime('2024-01-01')]];
}
// name→string, price→float, starts_at→dateTime, plus an auto-incrementing id.
```

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

### Model with custom schema

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Example model defining a custom schema to override type auto-detection.

```php
class Products extends Model
{
    use \Sushi\Sushi;

    protected $rows = [['name' => 'Lawn Mower', 'price' => '226.99']];

    protected $schema = ['price' => 'float'];
}
```

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

### Query a Sushi model

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Use the model like a normal Eloquent model. This example retrieves the name of the state with abbreviation 'NY'.

```php
$stateName = State::whereAbbr('NY')->first()->name;
```

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

### Currency model with empty getRows() and schema

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/errors.md

Example of a Sushi model declaring a full $schema and returning an empty array from getRows(), the safe approach for empty datasets.

```php
class Currency extends Model
{
    use \Sushi\Sushi;

    protected $schema = [
        'id' => 'integer',
        'name' => 'string',
        'symbol' => 'string',
        'precision' => 'float',
    ];

    public function getRows()
    {
        return [];
    }
}
```

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

### Override getRows() for runtime data

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Example overriding getRows() to fetch data from an API at runtime.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public function getRows()
    {
        return Http::get('https://example.com/roles.json')->json(); // Runtime data source.
    }
}
```

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

### Implement getRows() method for dynamic rows

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Override getRows() to determine rows at runtime, e.g., from an external API. This example returns a static array.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public function getRows()
    {
        return [
            ['id' => 1, 'label' => 'admin'],
            ['id' => 2, 'label' => 'manager'],
            ['id' => 3, 'label' => 'user'],
        ];
    }
}
```

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

### Customize Sushi schema with $schema

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Override Sushi's auto-detected schema using the $schema property. This example sets the 'price' column to float.

```php
class Products extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['name' => 'Lawn Mower', 'price' => '226.99'],
        ['name' => 'Leaf Blower', 'price' => '134.99'],
        ['name' => 'Rake', 'price' => '9.99'],
    ];

    protected $schema = [
        'price' => 'float',
    ];
}
```

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

### Add a relationship to a Sushi model

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Define a belongsTo relationship to a Sushi model just like a normal model. This example shows a User model with a role() method.

```php
class User extends Model
{
    ...

    public function role()
    {
        return $this->belongsTo(Role::class);
    }
}
```

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

### Override sushiShouldCache() to force caching

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Example of overriding sushiShouldCache() to always return true, forcing caching even when using a custom getRows() method without a $rows property.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    protected function sushiShouldCache() { return true; }
}
```

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

### Override sushiCacheReferencePath() to use external CSV

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Example of overriding sushiCacheReferencePath() to return a path to an external CSV file. The cache is only rebuilt when the CSV file changes, not when the model file changes.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['id' => 1, 'label' => 'admin'],
    ];

    public function sushiCacheReferencePath()
    {
        return __DIR__.'/roles.csv';
    }
}
```

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

### String primary key model with $incrementing = false and $keyType = 'string'

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/types.md

For string-based primary keys, the model must declare Eloquent's `public $incrementing = false;` and `protected $keyType = 'string';`. This example shows a Role model using Sushi with rows that have string IDs.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public $incrementing = false;

    protected $keyType = 'string';

    protected $rows = [
        ['id' => 'admin', 'label' => 'Admin'],
        ['id' => 'manager', 'label' => 'Manager'],
        ['id' => 'user', 'label' => 'User'],
    ];
}
```

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

### Lower Sushi insert chunk size to fix SQLite 'too many SQL variables'

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/errors.md

Set the public $sushiInsertChunkSize property on the model to a lower value (e.g., 50) to avoid exceeding SQLite's per-statement variable limit. The default chunk size is 100. This example shows a Role model using the Sushi trait with the property set.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public $sushiInsertChunkSize = 50;

    protected $rows = [ /* ... */ ];
}
```

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

### migrate() method implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Creates the model's table from the first row (or empty schema) and bulk-inserts all rows in chunks of getSushiInsertChunkSize() via static::insert(). Called automatically at boot; public so it can be called to force a rebuild.

```php
public function migrate()
{
    $rows = $this->getRows();
    $tableName = $this->getTable();

    if (count($rows)) {
        $this->createTable($tableName, $rows[0]);
    } else {
        $this->createTableWithNoData($tableName);
    }

    foreach (array_chunk($rows, $this->getSushiInsertChunkSize()) ?? [] as $inserts) {
        if (! empty($inserts)) {
            static::insert($inserts);
        }
    }
}
```

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

### migrate()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Creates the model's table (from the first row, else $schema) and bulk-inserts all rows in chunks of getSushiInsertChunkSize() via static::insert(). Called automatically at boot; public so it can be called to force a rebuild.

```APIDOC
## migrate()

### Description
Creates the model's table (from the first row, else $schema) and bulk-inserts all rows in chunks of getSushiInsertChunkSize() via static::insert(). Called automatically at boot; public so it can be called to force a rebuild.

### Method
migrate()

### Parameters
No parameters.

### Returns
void

### Example
```php
(new State)->migrate();
```
```

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

### Runtime configuration of sushi.cache-path and sushi.cache-prefix

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/configuration.md

Set the cache directory and prefix at runtime using the config() helper. Overrides the defaults storage_path('framework/cache') and 'sushi'.

```php
config([
    'sushi.cache-path' => storage_path('app/sushi-cache'),
    'sushi.cache-prefix' => 'fixtures',
]);
```

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

### createTable() method implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Creates the table safely, adding an auto-incrementing primary key if needed, inferring column types from the first row's values, applying schema overrides, adding timestamps when missing, and running afterMigrate().

```php
public function createTable(string $tableName, $firstRow)
{
    $this->createTableSafely($tableName, function ($table) use ($firstRow) {
        // Add the "id" column if it doesn't already exist in the rows.
        if ($this->incrementing && ! array_key_exists($this->primaryKey, $firstRow)) {
            $table->increments($this->primaryKey);
        }

        foreach ($firstRow as $column => $value) {
            switch (true) {
                case is_int($value):
                    $type = 'integer';
                    break;
                case is_numeric($value):
                    $type = 'float';
                    break;
                case is_string($value):
                    $type = 'string';
                    break;
                case is_object($value) && $value instanceof \DateTime:
                    $type = 'dateTime';
                    break;
                default:
                    $type = 'string';
            }

            if ($column === $this->primaryKey && $type == 'integer') {
                $table->increments($this->primaryKey);
                continue;
            }

            $schema = $this->getSchema();

            $type = $schema[$column] ?? $type;

            $table->{$type}($column)->nullable();
        }

        if ($this->usesTimestamps() && (! in_array('updated_at', array_keys($firstRow)) || ! in_array('created_at', array_keys($firstRow)))) {
            $table->timestamps();
        }

        $this->afterMigrate($table);
    });
}
```

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

### sushiCacheFileName() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Builds the cache file name using the config key 'sushi.cache-prefix' (default 'sushi'), the kebab-cased model class name, and the .sqlite extension.

```php
protected function sushiCacheFileName()
{
    return config('sushi.cache-prefix', 'sushi').'-'.Str::kebab(str_replace('\\', '', static::class)).'.sqlite';
}
```

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

### createTableSafely() catches QueryException race

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/errors.md

Wraps the Blueprint-based create() call in a try/catch. If the exception message contains 'already exists (SQL: create table' or the sprintf-built 'table "<tableName>" already exists', the failure is treated as a benign concurrent-request race and silently ignored. Any other QueryException is re-thrown.

```php
try {
    $schemaBuilder->create($tableName, $callback);
} catch (QueryException $e) {
    if (Str::contains($e->getMessage(), [
        'already exists (SQL: create table',
        sprintf('table "%s" already exists', $tableName),
    ])) {
        return;
    }

    throw $e;
}
```

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

### migrate() branch on count($rows)

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/errors.md

Shows the conditional logic in migrate() that creates a table with data or without data based on whether getRows() returns any rows.

```php
if (count($rows)) {
    $this->createTable($tableName, $rows[0]);
} else {
    $this->createTableWithNoData($tableName);
}
```

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

### Catching QueryException in consumer code

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/errors.md

Shows how to catch the standard Illuminate\Database\QueryException around a query that triggers the migration. The 'already exists' race is swallowed internally; any other exception surfaces here.

```php
use Illuminate\Database\QueryException;

try {
    State::first();
} catch (QueryException $e) {
    report($e);
    // The "already exists" race is swallowed internally; anything else surfaces here.
}
```

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

### Basic lookups and validation with CountryExample

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/country-example.md

Shows how to query the model like a normal Eloquent model and use it in validation rules with the FQCN. The first row has no id key, so Sushi adds an auto-incrementing id. The number field is a string, not an integer.

```php
// Basic lookups behave exactly like a database-backed model.
$usa = CountryExample::where('code', 'US')->first();
echo $usa->name; // United States of America (the)

$byAlpha3 = CountryExample::where('code3', 'JPN')->first();

// Fixture data works with validation rules using the FQCN instead of a table name.
$data = request()->validate([
    'country' => ['required', 'exists:App\Models\CountryExample,code'],
]);
```

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

### Force rebuild with migrate()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Forces a rebuild of the model's table and rows by calling migrate() on a new State instance.

```php
// Force a rebuild of the model's table & rows.
(new State)->migrate();
```

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

### afterMigrate(BluePrint $table)

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Hook invoked at the end of createTable() to allow adding indexes or columns. This method is protected and can be overridden.

```APIDOC
## afterMigrate(BluePrint $table)

### Description
Hook invoked at the end of `createTable()`. Override to add indexes or columns. The type hint `BluePrint` (capital P) resolves to `Illuminate\Database\Schema\Blueprint` because PHP class names are case-insensitive.

### Method
PHP method (protected)

### Endpoint
`Sushi::afterMigrate(BluePrint $table)`

### Parameters
- `$table` (BluePrint) - Required - The `Illuminate\Database\Schema\Blueprint` after all inferred columns have been added.

### Returns
`void`

### Example
```php
class Products extends Model
{
    use \Sushi\Sushi;

    protected $rows = [['name' => 'Lawn Mower', 'price' => '226.99']];

    protected function afterMigrate(Blueprint $table)
    {
        $table->index('name');
    }
}
```
```

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

### Customize table after migration with afterMigrate()

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Implement afterMigrate(Blueprint $table) to customize the table after creation, e.g., adding indexes. The $rows property defines the model data.

```php
class Products extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['name' => 'Lawn Mower', 'price' => '226.99'],
        ['name' => 'Leaf Blower', 'price' => '134.99'],
        ['name' => 'Rake', 'price' => '9.99'],
    ];

    protected function afterMigrate(Blueprint $table)
    {
        $table->index('name');
    }
}
```

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

### sushiCacheDirectory() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the real path of the config value 'sushi.cache-path', defaulting to storage_path('framework/cache'). Returns false if the directory is absent, triggering the :memory: fallback.

```php
protected function sushiCacheDirectory()
{
    return realpath(config('sushi.cache-path', storage_path('framework/cache')));
}
```

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

### createTableSafely(string $tableName, Closure $callback)

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Creates a table using the schema builder, swallowing the 'already exists' race condition. This method is protected but can be overridden by subclasses.

```APIDOC
## createTableSafely(string $tableName, Closure $callback)

### Description
Creates a table using the schema builder, catching `QueryException` for the 'already exists' race condition. Any other `QueryException` is re-thrown.

### Method
PHP method (protected)

### Endpoint
`Sushi::createTableSafely(string $tableName, Closure $callback)`

### Parameters
- `$tableName` (string) - Required - Name of the table to create.
- `$callback` (Closure) - Required - Receives the `Illuminate\Database\Schema\Blueprint` and defines the columns.

### Returns
`void`

### Throws
- `Illuminate\Database\QueryException` - Re-thrown when table creation fails for any reason other than the 'already exists' race. If the message contains `already exists (SQL: create table` or `table "<tableName>" already exists`, creation is silently ignored.
```

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

### sushiCachePath() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the full path to the model's .sqlite cache file by joining sushiCacheDirectory() and sushiCacheFileName() with DIRECTORY_SEPARATOR.

```php
protected function sushiCachePath()
{
    return implode(DIRECTORY_SEPARATOR, [
        $this->sushiCacheDirectory(),
        $this->sushiCacheFileName(),
    ]);
}
```

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

### createTable(string $tableName, $firstRow)

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Creates a database table based on the given table name and first row of data. Column types are inferred from the values in the first row, with optional schema overrides. Handles primary key and timestamp columns.

```APIDOC
## createTable(string $tableName, $firstRow)

### Description
Creates a database table based on the given table name and first row of data. Column types are inferred from the values in the first row, with optional schema overrides. Handles primary key and timestamp columns.

### Method
createTable(string $tableName, $firstRow)

### Parameters
- **$tableName** (string) - Required - Name of the table to create (the model's $table).
- **$firstRow** (array) - Required - The first row of the dataset; its column keys and value types drive schema inference.

### Returns
void

### Example
```php
class Event extends Model
{
    use \Sushi\Sushi;

    protected $rows = [['name' => 'Launch', 'price' => 99.99, 'starts_at' => new DateTime('2024-01-01')]];
}
// name→string, price→float, starts_at→dateTime, plus an auto-incrementing id.
```
```

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

### Define schema for empty datasets with $schema

Source: https://github.com/calebporzio/sushi/blob/main/README.md

When getRows() returns an empty array, Sushi would throw an error because it cannot infer the schema. Define the schema in the optional $schema property to allow Sushi to work with empty datasets.

```php
class Currency extends Model
{
    use \Sushi\Sushi;

    protected $schema = [
        'id' => 'integer',
        'name' => 'string',
        'symbol' => 'string',
        'precision' => 'float'
    ];

    public function getRows()
    {
        return [];
    }
}
```

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

### Import Sushi trait

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Import the Sushi trait into an Eloquent model.

```php
use \Sushi\Sushi;
```

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

### sushiShouldCache() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns true when the model class declares a $rows property, indicating a static dataset. When false, Sushi uses in-memory SQLite and rebuilds rows per request.

```php
protected function sushiShouldCache()
{
    return property_exists(static::class, 'rows');
}
```

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

### createTableWithNoData: Empty dataset model with schema

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Use this model when getRows() returns an empty array. The table is still created from the $schema property, so queries and relationships work even though the table has no rows.

```php
class Currency extends Model
{
    use \Sushi\Sushi;

    protected $schema = ['id' => 'integer', 'name' => 'string', 'symbol' => 'string'];

    public function getRows()
    {
        return []; // Empty dataset — table is still created from $schema.
    }
}

// Currency::count() === 0, but queries and relationships still work.
```

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

### Use Sushi model relationships

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Associate, access, and eager load relationships on Sushi models. Note: whereHas will not work because models are on separate databases.

```php
// Grab a User.
$user = User::first();
// Grab a Role.
$role = Role::whereLabel('admin')->first();

// Associate them.
$user->role()->associate($role);

// Access like normal.
$user->role;

// Eager load.
$user->load('role');
User::with('role')->first();
```

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

### afterMigrate: Add index to model table

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Override afterMigrate to add indexes or columns after the table is created. The type hint is spelled 'BluePrint' in the source but resolves to Illuminate\Database\Schema\Blueprint.

```php
class Products extends Model
{
    use \Sushi\Sushi;

    protected $rows = [['name' => 'Lawn Mower', 'price' => '226.99']];

    protected function afterMigrate(Blueprint $table)
    {
        $table->index('name');
    }
}
```

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

### setSqliteConnection method signature

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Protected method that builds a SQLite connection config, resolves it via ConnectionFactory, stores it in static::$sushiConnection, and registers it in config under database.connections.<ModelClass>. Internal, called by configureSushiConnection().

```php
protected static function setSqliteConnection($database)
```

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

### sushiCachePath()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the full path to the model's SQLite cache file, combining the cache directory and file name.

```APIDOC
## sushiCachePath()

### Description
Returns the full path to the model's `.sqlite` cache file, constructed by joining the cache directory and file name with `DIRECTORY_SEPARATOR`.

### Method
Protected method

### Signature
```php
protected function sushiCachePath()
```

### Parameters
None

### Returns
- **string** - Full path to the cache file (e.g., `/path/to/cache/sushi-model.sqlite`).
```

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

### Cache getRows() dataset with sushiShouldCache()

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Force Sushi to cache the dataset returned by getRows() by implementing sushiShouldCache() to return true. Without this, rows are not cached between requests.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public function getRows()
    {
        return [
            ['id' => 1, 'label' => 'admin'],
            ['id' => 2, 'label' => 'manager'],
            ['id' => 3, 'label' => 'user'],
        ];
    }

    protected function sushiShouldCache()
    {
        return true;
    }
}
```

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

### createTableSafely: Method signature

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Signature for the protected createTableSafely method. It creates a table safely, swallowing 'already exists' errors from concurrent requests.

```php
protected function createTableSafely(string $tableName, Closure $callback)
```

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

### sushiCacheFileName()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Generates the cache file name based on the config prefix and the model class name.

```APIDOC
## sushiCacheFileName()

### Description
Returns the cache file name for the model, built from the config key `sushi.cache-prefix` (default `'sushi'`), a hyphen, the model class name with backslashes removed and kebab-cased, and the `.sqlite` extension.

### Method
Protected method

### Signature
```php
protected function sushiCacheFileName()
```

### Parameters
None

### Returns
- **string** - Cache file name (e.g., `sushi-tests-foo.sqlite`).
```

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

### Relationship to a regular model and eager loading

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/country-example.md

Defines a belongsTo relationship from a regular model to CountryExample and shows eager loading across the two separate SQLite databases. Note that whereHas() will not work for such cross-database relationships.

```php
// Relationship to a regular database model: same as any Eloquent model.
class User extends Model
{
    public function country()
    {
        return $this->belongsTo(CountryExample::class, 'country_code', 'code');
    }
}

// Eager loading works across the two separate SQLite databases.
$user = User::with('country')->first();
```

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

### createTableWithNoData(string $tableName)

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Creates a database table from the model's $schema when getRows() returns an empty array. This method is called internally but can be invoked directly if needed.

```APIDOC
## createTableWithNoData(string $tableName)

### Description
Creates a table from the model's `$schema` when `getRows()` returns an empty array. The table is built with the same primary-key and timestamps logic as `createTable()`. If no schema is defined, the table gets just an auto-incrementing `id`.

### Method
PHP method (public)

### Endpoint
`Sushi::createTableWithNoData(string $tableName)`

### Parameters
- `$tableName` (string) - Required - Name of the table to create.

### Returns
`void`

### Example
```php
class Currency extends Model
{
    use \Sushi\Sushi;

    protected $schema = ['id' => 'integer', 'name' => 'string', 'symbol' => 'string'];

    public function getRows()
    {
        return []; // Empty dataset — table is still created from $schema.
    }
}

// Currency::count() === 0, but queries and relationships still work.
```
```

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

### sushiCacheReferencePath() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the absolute file path of the model's PHP file, used to determine cache staleness by comparing file modification times. Override this method to point to an external data file.

```php
protected function sushiCacheReferencePath()
{
    return (new \ReflectionClass(static::class))->getFileName();
}
```

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

### getSchema() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Default implementation of getSchema() returns the model's protected $schema property or an empty array.

```php
public function getSchema()
{
    return $this->schema ?? [];
}
```

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

### Composer PSR-4 autoload mapping for Sushi

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/index.md

Defines the PSR-4 autoload mapping for the Sushi package, mapping the 'Sushi\' namespace to the 'src/' directory.

```json
{
    "autoload": {
        "psr-4": {
            "Sushi\\": "src/"
        }
    }
}
```

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

### sushiCacheDirectory()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the real path of the cache directory, defaulting to the Laravel framework cache path.

```APIDOC
## sushiCacheDirectory()

### Description
Returns the real path of the directory where Sushi stores cache files. It uses the config value `sushi.cache-path`, defaulting to `storage_path('framework/cache')`. If the directory does not exist, `realpath()` returns `false`, which triggers the in-memory fallback.

### Method
Protected method

### Signature
```php
protected function sushiCacheDirectory()
```

### Parameters
None

### Returns
- **string|false** - Real path to the cache directory, or `false` if the directory does not exist.
```

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

### sushiCacheReferencePath()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the absolute file path used to determine cache staleness. Override to point to an external data file.

```APIDOC
## sushiCacheReferencePath()

### Description
Returns the absolute file path whose modification time is compared against the cache file to determine staleness. By default, it returns the model's own PHP file. Override to point to an external data file (e.g., CSV).

### Method
Protected method

### Signature
```php
protected function sushiCacheReferencePath()
```

### Parameters
None

### Returns
- **string** - Absolute file path used for cache staleness comparison.

### Example Override
```php
class Role extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['id' => 1, 'label' => 'admin'],
    ];

    public function sushiCacheReferencePath()
    {
        return __DIR__.'/roles.csv';
    }
}
```

### Notes
The cache is only rebuilt when the referenced file changes.
```

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

### Reference external file for cache invalidation with sushiCacheReferencePath()

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Use sushiCacheReferencePath() to make Sushi check an external file (e.g., roles.csv) instead of the model file to determine if the cache is stale. Combined with sushiShouldCache() to enable caching.

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public function getRows()
    {
        return CSV::fromFile(__DIR__.'/roles.csv')->toArray();
    }

    protected function sushiShouldCache()
    {
        return true;
    }

    protected function sushiCacheReferencePath()
    {
        return __DIR__.'/roles.csv';
    }
}
```

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

### resolveConnection method signature

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Overrides Eloquent's resolveConnection to always return the static Sushi connection. The $connection parameter is ignored. Returns null before bootSushi() configures the connection.

```php
public static function resolveConnection($connection = null)
{
    return static::$sushiConnection;
}
```

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

### sushiShouldCache()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Determines whether Sushi should cache the model's rows in a SQLite file. Returns true when the model has a $rows property.

```APIDOC
## sushiShouldCache()

### Description
Returns a boolean indicating whether Sushi should cache the model's data. It returns `true` when the model class declares a `$rows` property (static dataset), and `false` otherwise (custom `getRows()`).

### Method
Protected method

### Signature
```php
protected function sushiShouldCache()
```

### Parameters
None

### Returns
- **bool** - `true` if the model has a `$rows` property, `false` otherwise.

### Example Override
```php
class Role extends Model
{
    use \Sushi\Sushi;

    protected function sushiShouldCache() { return true; }
}
```

### Notes
When `false`, Sushi uses in-memory SQLite and rebuilds rows per request.
```

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

### Using the Sushi trait in an Eloquent model

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/index.md

Shows how to add the Sushi trait to an Eloquent model and define the $rows property with array data. The model will use a SQLite database built from the rows.

```php
use Illuminate\Database\Eloquent\Model;

class State extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['abbr' => 'NY', 'name' => 'New York'],
        ['abbr' => 'CA', 'name' => 'California'],
    ];
}
```

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

### CountryExample model definition with Sushi trait and $rows

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/country-example.md

A bare Eloquent model using the Sushi trait with a static $rows property. Not namespaced and not autoloaded; copy into your application. The rows are associative arrays with string values for code, code3, name, and number.

```php
class CountryExample extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['code' => 'AF', 'code3' => 'AFG', 'name' => 'Afghanistan', 'number' => '004'],
        ['code' => 'AL', 'code3' => 'ALB', 'name' => 'Albania', 'number' => '008'],
        // ... 245 more rows ...
        ['code' => 'ZW', 'code3' => 'ZWE', 'name' => 'Zimbabwe', 'number' => '716'],
    ];
}
```

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

### Define a Sushi model with $rows

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Add the Sushi trait and a $rows property to a model to use array data as a table. The model behaves as if a table was created with the provided rows.

```php
class State extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        [
            'abbr' => 'NY',
            'name' => 'New York',
        ],
        [
            'abbr' => 'CA',
            'name' => 'California',
        ],
    ];
}
```

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

### Define static rows with $rows property

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/types.md

Declares a static dataset as an array of associative arrays. Each row maps column names to values, and the first row's values drive SQLite column type inference. When $rows is present, sushiShouldCache() returns true and the dataset is cached to disk.

```php
protected $rows = [
    ['id' => 1, 'label' => 'admin'],
    ['id' => 2, 'label' => 'manager'],
    ['id' => 3, 'label' => 'user'],
];
```

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

### getSushiInsertChunkSize()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the model's sushi insert chunk size, defaulting to 100. This value is used to chunk rows during insertion to avoid SQLite variable limits.

```APIDOC
## getSushiInsertChunkSize()

### Description
Returns the model's `public $sushiInsertChunkSize` property, or `100` if not set. This value determines the chunk size used when inserting rows via `array_chunk($rows, getSushiInsertChunkSize())`. Lower it if SQLite reports `too many SQL variables`.

### Method
PHP Method

### Endpoint
`getSushiInsertChunkSize()`

### Parameters
No parameters.

### Returns
- **int** - The chunk size value.

### Example
```php
class Role extends Model
{
    use \Sushi\Sushi;

    public $sushiInsertChunkSize = 50;

    protected $rows = [ /* ... */ ];
}
```
```

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

### getRows() default implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Default implementation of getRows() returns the model's protected $rows property.

```php
public function getRows()
{
    return $this->rows;
}
```

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

### Define custom column schema with $schema property

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/types.md

Maps column names to SQLite column types. Entries override the types inferred from the first row. A full $schema is required when getRows() may return an empty array, because createTableWithNoData() builds the table from $schema alone.

```php
protected $schema = [
    'id' => 'integer',
    'name' => 'string',
    'price' => 'float',
    'starts_at' => 'dateTime',
];
```

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

### getSchema()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the model's schema as a map of column names to SQLite column types. Override this method to provide a custom schema, which overrides auto-detection and allows working with empty datasets.

```APIDOC
## getSchema()

### Description
Returns the model's schema as a map of column names to SQLite column types. Override this method to provide a custom schema, which overrides auto-detection and allows working with empty datasets.

### Method
PHP method

### Endpoint
`Sushi\Sushi::getSchema()`

### Parameters
None

### Returns
- **array** - A map of `columnName => schemaType`, or `[]` when the model declares no `$schema` property.

### Example
```php
class Products extends Model
{
    use \Sushi\Sushi;

    protected $rows = [['name' => 'Lawn Mower', 'price' => '226.99']];

    protected $schema = ['price' => 'float'];
}
```
```

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

### getSushiInsertChunkSize() method implementation

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the model's public $sushiInsertChunkSize property, or 100 if not set. Used internally to chunk row inserts via array_chunk().

```php
public function getSushiInsertChunkSize() {
    return $this->sushiInsertChunkSize ?? 100;
}
```

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

### getRows()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the model's rows as an array of associative arrays. Override this method to compute rows at runtime from external sources like APIs or CSV files.

```APIDOC
## getRows()

### Description
Returns the model's rows as an array of associative arrays. Override this method to compute rows at runtime from external sources like APIs or CSV files.

### Method
PHP method

### Endpoint
`Sushi\Sushi::getRows()`

### Parameters
None

### Returns
- **array** - An array of associative row arrays; each row is `[columnName => value]`.

### Example
```php
class State extends Model
{
    use \Sushi\Sushi;

    protected $rows = [
        ['abbr' => 'NY', 'name' => 'New York'],
        ['abbr' => 'CA', 'name' => 'California'],
    ];
}
```

```php
class Role extends Model
{
    use \Sushi\Sushi;

    public function getRows()
    {
        return Http::get('https://example.com/roles.json')->json(); // Runtime data source.
    }
}
```
```

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

### Inference switch in createTable()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/types.md

The switch statement inside createTable() that infers the schema column type from a PHP value. It checks is_int, is_numeric, is_string, and DateTime instance, defaulting to string. The resulting type is used as the Blueprint method name.

```php
switch (true) {
    case is_int($value):
        $type = 'integer';
        break;
    case is_numeric($value):
        $type = 'float';
        break;
    case is_string($value):
        $type = 'string';
        break;
    case is_object($value) && $value instanceof \DateTime:
        $type = 'dateTime';
        break;
    default:
        $type = 'string';
}
```

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

### getConnectionName method signature

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Returns the model class name as the connection name, allowing Eloquent to resolve the model against its dedicated SQLite connection.

```php
public function getConnectionName()
{
    return static::class;
}
```

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

### Use exists validation rule with Sushi model

Source: https://github.com/calebporzio/sushi/blob/main/README.md

Use Laravel's exists validation rule with a Sushi model. Must use the fully-qualified namespace instead of a table name.

```php
$data = request()->validate([
    'state' => ['required', 'exists:App\Models\State,abbr'],
]);
```

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

### newRelatedInstance method signature

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Protected method that creates a new related model instance and sets its connection to the default if it has none, enabling relationships between Sushi models and regular Eloquent models.

```php
protected function newRelatedInstance($class)
```

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

### usesTimestamps()

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

Determines whether the model uses timestamps. Returns true only when the concrete model class declares a $timestamps property and its value is true.

```APIDOC
## usesTimestamps()

### Description
Determines whether the model uses timestamps. Returns `true` only when the concrete model class itself declares a `$timestamps` property and its own (Eloquent) value is `true`; otherwise `false`. Because Laravel defaults `$timestamps = true` but a Sushi model has no migrations, timestamp columns are only added when the model explicitly declares `public $timestamps = true;`.

### Method
PHP method (public)

### Endpoint
`Sushi::usesTimestamps()`

### Parameters
None.

### Returns
`bool` - `true` only when the concrete model class declares a `$timestamps` property and its value is `true`; otherwise `false`.

### Example
```php
class AuditLog extends Model
{
    use \Sushi\Sushi;

    public $timestamps = true; // Adds created_at / updated_at columns.

    protected $rows = [['action' => 'created']];
}
```
```

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

### usesTimestamps: Override to respect explicit $timestamps

Source: https://github.com/calebporzio/sushi/blob/main/_autodocs/api-reference/sushi-trait.md

This method returns true only when the model class explicitly declares a $timestamps property and its value is true. Timestamp columns are added only when the model declares public $timestamps = true;.

```php
public function usesTimestamps()
{
    // Override the Laravel default value of $timestamps = true; Unless otherwise set.
    return (new \ReflectionClass($this))->getProperty('timestamps')->class === static::class
        ? parent::usesTimestamps()
        : false;
}
```

```php
class AuditLog extends Model
{
    use \Sushi\Sushi;

    public $timestamps = true; // Adds created_at / updated_at columns.

    protected $rows = [['action' => 'created']];
}
```
Tokens:
Raw