Spatie Laravel Schemaless Attributes

https://github.com/spatie/laravel-schemaless-attributes
Admin
A Laravel package that provides a trait for Eloquent models, allowing you to store arbitrary,...
Tokens:27,056
Snippets:359
Trust Score:10
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Key Parameter Notation Examples

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Examples of string and array formats for key parameters.

```php
'simple_key'           // Top-level key
'nested.deep.key'      // Nested with dot notation
'array->json->path'    // Arrow notation in queries
```

```php
['key1', 'key2', 'key3']     // forget() - array of keys
['key1' => 'val1', 'key2' => 'val2']  // set() - key-value pairs
```

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

### Install the package via Composer

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Use this command to add the package to your Laravel project.

```bash
composer require spatie/laravel-schemaless-attributes
```

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

### Builder Usage Example

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Demonstrates chaining the withExtraAttributes scope method on an Eloquent model.

```php
Model::withExtraAttributes('key', 'value')  // Returns Builder
     ->where('other_field', true)
     ->get();
```

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

### Use schemalessAttributes in migrations

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Example of applying the macro within a database migration schema table definition.

```php
use Illuminate	ypes\Schema\
use Illuminate\
use Illuminate\

Schema::table('users', function (Blueprint $table) {
    $table->schemalessAttributes('extra_attributes');
    // This is equivalent to: $table->json('extra_attributes')->nullable();
});
```

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

### Using get and set with dot notation

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Utilize the set and get methods for nested attribute manipulation using dot notation.

```php
$yourModel->extra_attributes = [
   'rey' => ['side' => 'light'],
   'snoke' => ['side' => 'dark'],
];
$yourModel->extra_attributes->set('rey.side', 'dark');

$yourModel->extra_attributes->get('rey.side'); // Returns 'dark
```

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

### Retrieve attributes with get()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Use dot notation to access nested attributes and provide an optional default value.

```php
$name = $model->extra_attributes->get('name');
$side = $model->extra_attributes->get('character.side', 'unknown');
```

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

### get(string|array $key, mixed $default = null)

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Retrieve a schemaless attribute using dot notation.

```APIDOC
## get(string|array $key, mixed $default = null)

### Description
Retrieve a schemaless attribute using dot notation.

### Parameters
- **$key** (string|array) - Required - The attribute key, supports dot notation for nested values.
- **$default** (mixed) - Optional - Default value if the key does not exist.

### Return Type
mixed - The attribute value or the default.
```

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

### Schemaless Attributes Array Structures

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Examples of flat and nested array structures used to represent schemaless attributes.

```php
// Simple flat structure
[
    'name' => 'John',
    'email' => 'john@example.com',
    'active' => true,
]

// Nested structure (using dot notation)
[
    'user' => [
        'name' => 'John',
        'profile' => [
            'bio' => 'Developer',
            'avatar' => 'url',
        ],
    ],
    'settings' => [
        'theme' => 'dark',
        'notifications' => true,
    ],
]
```

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

### Retrieving attributes with default values

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Provide a second argument to the get method to return a default value if the key does not exist.

```php
$yourModel->extra_attributes->get('non_existing', 'default'); // Returns 'default'
```

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

### Provide magic property access

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/architecture.md

Enables property-style access by delegating magic methods to internal get and set methods.

```php
public function __get($name)
{
    return $this->get($name);  // Delegate to get() with dot notation
}

public function __set($name, $value): void
{
    $this->set($name, $value);  // Delegate to set() with dot notation
}
```

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

### Read Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Retrieve attributes using property access, array access, or the get() method with optional default values and dot notation.

```php
$user = User::find(1);

// Access using property notation
$name = $user->extra_attributes->name;

// Or array notation
$email = $user->extra_attributes['email'];

// Or get() method with default
$phone = $user->extra_attributes->get('phone', '000-0000');

// Get with dot notation
$user->extra_attributes->set('address.city', 'Amsterdam');
$city = $user->extra_attributes->get('address.city');
```

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

### Run Migration Command

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Execute the migration to apply changes to the database schema.

```bash
php artisan migrate
```

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

### Navigation Entry Points

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/00-START-HERE.md

Recommended reading paths for different user goals.

```text
README.md → Usage Patterns → API Reference
```

```text
Configuration → Usage Patterns → API Reference
```

```text
Architecture → Migration Guide → Advanced Patterns
```

```text
Architecture → Advanced Patterns → API Reference
```

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

### getIterator()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Get an iterator for the schemaless attributes.

```APIDOC
## getIterator()

### Description
Get an iterator for the schemaless attributes.

### Return Type
Traversable
```

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

### count()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Get the total number of schemaless attributes.

```APIDOC
## count()

### Description
Get the total number of schemaless attributes.

### Return Type
int
```

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

### Backup Schemaless Data via CLI

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Standard database backup tools include JSON columns automatically; verify contents using grep.

```bash
# Standard backup includes JSON columns
mysqldump -u root -p database_name > backup.sql

# Verify backup contains JSON data
grep -i 'extra_attributes' backup.sql
```

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

### Documentation File Manifest

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/00-START-HERE.md

A summary of the documentation files and their respective line counts.

```text
INDEX.md ................... 391 lines (Navigation)
README.md .................. 315 lines (Overview)
api-reference.md ........... 605 lines (Methods)
usage-patterns.md .......... 564 lines (Examples)
types.md ................... 481 lines (Types)
configuration.md .......... 558 lines (Setup)
architecture.md ........... 518 lines (Design)
migration-guide.md ........ 665 lines (Database)
advanced-patterns.md ...... 743 lines (Advanced)
MANIFEST.txt ............... 177 lines (Manifest)

TOTAL ...................... 5,017 lines
```

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

### Configure Multiple Attribute Sets for Products

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Demonstrates managing multiple distinct schemaless attribute columns on a single model using the SchemalessAttributesTrait.

```php
// Migration
Schema::table('products', function (Blueprint $table) {
    $table->schemalessAttributes('variants');
    $table->schemalessAttributes('seo');
    $table->schemalessAttributes('analytics');
});

// Model
class Product extends Model
{
    use SchemalessAttributesTrait;

    protected $schemalessAttributes = [
        'variants',
        'seo',
        'analytics',
    ];

    public function scopeWithVariants(): Builder
    {
        return $this->variants->modelScope();
    }

    public function scopeWithSeo(): Builder
    {
        return $this->seo->modelScope();
    }

    public function scopeWithAnalytics(): Builder
    {
        return $this->analytics->modelScope();
    }
}

// Usage
$product->variants->set('S', ['color' => 'red']);
$product->seo->set('title', 'Product Name');
$product->analytics->set('views', 100);
$product->save();
```

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

### Get attribute using array syntax

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Accesses an attribute value using the ArrayAccess interface.

```php
$value = $model->extra_attributes['name']; // Uses offsetGet()
```

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

### Run tests with Composer

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Executes the package test suite using the composer test command.

```bash
composer test
```

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

### Configuring Schemaless Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/00-START-HERE.md

Illustrates how to cast attributes and define multiple schemaless columns in a model.

```php
// Single column
$casts = ['extra_attributes' => SchemalessAttributes::class];

// Multiple columns
use SchemalessAttributesTrait;
protected $schemalessAttributes = ['col1', 'col2'];
```

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

### Create instance via factory method

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Use the static factory method to create a new instance bound to a model.

```php
$attrs = SchemalessAttributes::createForModel($user, 'extra_attributes');
```

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

### Fluent Method Chaining

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Shows how to chain multiple attribute manipulation methods that return the instance.

```php
$model->extra_attributes
    ->set('field1', 'value1')
    ->set('field2', 'value2')
    ->forget('field3');
```

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

### Macro Registration and Equivalent Implementation

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

The macro is registered on the Blueprint class and functions as a wrapper for a nullable JSON column.

```php
public function registeringPackage(): void
{
    Blueprint::macro('schemalessAttributes', function (string $columnName = 'schemaless_attributes') {
        return $this->json($columnName)->nullable();
    });
}
```

```php
$table->json('extra_attributes')->nullable();
```

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

### Initialize SchemalessAttributes instance

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Instantiate the class by providing the Eloquent model and the target column name.

```php
use Spatie\SchemalessAttributes\SchemalessAttributes;

$schemalessAttrs = new SchemalessAttributes($model, 'extra_attributes');
$schemalessAttrs->set('name', 'John');
```

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

### ArrayAccess Implementation

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Demonstrates array-style access supported by the SchemalessAttributes instance.

```php
// Allows:
$model->extra_attributes['key'] = 'value';
$value = $model->extra_attributes['key'];
isset($model->extra_attributes['key']);
unset($model->extra_attributes['key']);
```

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

### Configure Simple User Preferences

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Implements a single schemaless attribute column for user preferences with custom model scoping.

```php
// Migration
Schema::table('users', function (Blueprint $table) {
    $table->schemalessAttributes('preferences');
});

// Model
class User extends Model
{
    public $casts = [
        'preferences' => SchemalessAttributes::class,
    ];

    public function scopeWithPreferences(): Builder
    {
        return $this->preferences->modelScope();
    }
}

// Usage
$user->preferences->set('theme', 'dark');
$user->preferences->set('language', 'en');
$user->save();

User::withPreferences('theme', 'dark')->get();
```

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

### Accessing schemaless attributes via object syntax

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Use object property access to get or set values within the schemaless attributes container.

```php
$yourModel->extra_attributes->name = 'value';

$yourModel->extra_attributes->name; // Returns 'value'
```

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

### Implement interfaces for flexible access

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/architecture.md

Supports multiple access patterns by implementing standard PHP and Laravel interfaces.

```php
class SchemalessAttributes implements 
    ArrayAccess,           // Array-style: $attrs['key']
    Arrayable,             // Array conversion: toArray()
    Countable,             // Count: count($attrs)
    IteratorAggregate,     // Iteration: foreach ($attrs)
    Jsonable,              // JSON: toJson()
    JsonSerializable       // json_encode(): jsonSerialize()
```

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

### Prepare model with schemaless attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Configure the model by adding the custom cast and a scope for the schemaless column.

```php
use Illuminate	ypesuilderuilder;
use Illuminate	ypesuilderuilder;
use Spatie	ypesuilderuilder;

class TestModel extends Model
{
    // ...

    public $casts = [
        'extra_attributes' => SchemalessAttributes::class,
    ];

    public function scopeWithExtraAttributes(): Builder
    {
        return $this->extra_attributes->modelScope();
    }

    // ...
}
```

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

### Handle NULL Values

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Demonstrates setting, retrieving, and checking the existence of null values in schemaless attributes.

```php
// Setting to null
$model->extra_attributes->set('field', null);

// Null is stored and retrievable
$value = $model->extra_attributes->get('field');
// Returns: null

// Check existence with isset
isset($model->extra_attributes->field);
// Returns: false (isset treats null as not existing)
```

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

### Create and Set Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Set attributes using property, array, or set() method notation before saving the model.

```php
$user = User::create(['name' => 'John']);

// Set using property notation
$user->extra_attributes->name = 'John Doe';
$user->extra_attributes->email = 'john@example.com';

// Or array notation
$user->extra_attributes['phone'] = '555-1234';

// Or set() method
$user->extra_attributes->set('role', 'admin');

$user->save();
```

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

### Declare SchemalessAttributesServiceProvider class

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Class definition for the service provider extending PackageServiceProvider.

```php
class SchemalessAttributesServiceProvider extends PackageServiceProvider
```

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

### Configure multiple schemaless columns

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Define multiple schemaless columns in the model and create separate scope methods for each.

```php
class Product extends Model
{
    use SchemalessAttributesTrait;

    protected $schemalessAttributes = [
        'extra_attributes',
        'seo_data',
    ];

    public function scopeWithExtraAttributes(): Builder
    {
        return $this->extra_attributes->modelScope();
    }

    public function scopeWithSeoData(): Builder
    {
        return $this->seo_data->modelScope();
    }
}
```

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

### __get(string $key)

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Magic method override to access schemaless attribute columns as SchemalessAttributes instances.

```APIDOC
## __get(string $key)

### Description
Overrides the model's magic getter to return a SchemalessAttributes instance when accessing a registered schemaless column.

### Parameters
- **$key** (string) - Required - The property name being accessed

### Return Type
mixed|SchemalessAttributes

### Example
$attrs = $user->extra_attributes; // Returns SchemalessAttributes instance
```

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

### Manually Register Service Provider

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Add the service provider to the providers array in config/app.php if auto-discovery is disabled.

```php
// config/app.php
'providers' => [
    // ...
    Spatie\\SchemalessAttributes\\SchemalessAttributesServiceProvider::class,
],
```

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

### Managing Feature Flags

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Toggle features per user and query users based on their enabled features.

```php
$user = User::find(1);

// Enable/disable features per user
$user->extra_attributes->set('features', [
    'dark_mode' => true,
    'beta_ui' => false,
    'advanced_analytics' => true,
]);

$user->save();

// Query by feature
User::withExtraAttributes('features->dark_mode', true)->get();
```

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

### Configure Model for Multiple Schemaless Columns

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Register multiple schemaless columns in the model by defining the $schemalessAttributes property.

```php
use Illuminate\Database\Eloquent\Model;
use Spatie\SchemalessAttributes\SchemalessAttributesTrait;

class Product extends Model
{
    use SchemalessAttributesTrait;

    protected $schemalessAttributes = [
        'attributes',
        'seo_data',
        'inventory',
        'metadata',
    ];
}
```

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

### Verify Type Preservation

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Demonstrates how the package maintains data types for integers, booleans, floats, and arrays after saving and refreshing a model.

```php
// Integer
$model->extra_attributes->set('count', 42);
$model->save();
$model->refresh();
echo gettype($model->extra_attributes->get('count')); // 'integer'

// Boolean
$model->extra_attributes->set('active', true);
$model->save();
$model->refresh();
echo gettype($model->extra_attributes->get('active')); // 'boolean'

// Float
$model->extra_attributes->set('rating', 3.14);
$model->save();
$model->refresh();
echo gettype($model->extra_attributes->get('rating')); // 'double'

// Array
$model->extra_attributes->set('tags', ['a', 'b']);
$model->save();
$model->refresh();
echo gettype($model->extra_attributes->get('tags')); // 'array'
```

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

### Register schemalessAttributes macro

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Registers the macro on the Blueprint class to create a nullable JSON column.

```php
Blueprint::macro('schemalessAttributes', function (string $columnName = 'schemaless_attributes') {
    return $this->json($columnName)->nullable();
});
```

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

### Migrate from schemaless attributes to traditional columns

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Uses a migration class to create new columns, extract data from the schemaless attribute, and drop the schemaless column.

```php
return new class extends Migration
{
    public function up()
    {
        // 1. Create new traditional columns
        Schema::table('users', function (Blueprint $table) {
            $table->string('phone')->nullable();
            $table->text('address')->nullable();
        });

        // 2. Copy data from schemaless
        User::chunk(1000, function ($users) {
            foreach ($users as $user) {
                $user->phone = $user->metadata->get('phone');
                $user->address = $user->metadata->get('address');
                $user->save();
            }
        });

        // 3. Drop schemaless column
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('metadata');
        });
    }

    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->schemalessAttributes('metadata');
        });

        User::chunk(1000, function ($users) {
            foreach ($users as $user) {
                $user->metadata->set([
                    'phone' => $user->phone,
                    'address' => $user->address,
                ]);
                $user->save();
            }
        });

        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn(['phone', 'address']);
        });
    }
};
```

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

### Register Migration Macro

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

The internal implementation of the schemalessAttributes migration macro used to add JSON columns.

```php
public function registeringPackage(): void
{
    Blueprint::macro('schemalessAttributes', function (string $columnName = 'schemaless_attributes') {
        return $this->json($columnName)->nullable();
    });
}
```

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

### Index JSON attributes in PostgreSQL

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Use DB::statement to execute raw SQL for creating GIN indexes on JSONB operators.

```php
Schema::table('users', function (Blueprint $table) {
    // Index with JSONB operator
    DB::statement(
        "CREATE INDEX idx_metadata_role ON users USING GIN ((metadata->>'role'))"
    );
});
```

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

### Handling Product Variants

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Store product variant data and query products based on specific variant attributes.

```php
$product = Product::find(1);

$product->extra_attributes->set('variants', [
    'S' => ['color' => 'red', 'sku' => 'PROD-S-RED'],
    'M' => ['color' => 'blue', 'sku' => 'PROD-M-BLU'],
    'L' => ['color' => 'green', 'sku' => 'PROD-L-GRN'],
]);

$product->save();

// Find products with specific variant
Product::withExtraAttributes('variants->S->color', 'red')->get();

// Access variant data
$smallRed = $product->extra_attributes->get('variants.S');
```

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

### Implement Advanced Query Patterns in UserRepository

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/advanced-patterns.md

Provides methods for filtering by single or multiple preferences, pattern matching, and executing custom query callbacks on models with schemaless attributes.

```php
class UserRepository
{
    public function findByPreference(string $key, mixed $value): \Illuminate\Database\Eloquent\Collection
    {
        return User::withPreferences($key, $value)->get();
    }

    public function findByMultiplePreferences(array $preferences): \Illuminate\Database\Eloquent\Collection
    {
        return User::withPreferences($preferences)->get();
    }

    public function findWithin(string $key, array $values): \Illuminate\Database\Eloquent\Collection
    {
        $query = User::query();

        foreach ($values as $value) {
            $query->withPreferences($key, $value);
        }

        return $query->get();
    }

    public function findLike(string $key, string $pattern): \Illuminate\Database\Eloquent\Collection
    {
        return User::withPreferences($key, 'LIKE', "{$pattern}%")->get();
    }

    public function advanced(callable $callback): \Illuminate\Database\Eloquent\Collection
    {
        $query = User::query();
        $callback($query);
        return $query->get();
    }
}

// Usage
$repo = new UserRepository();

// Simple preference search
$admins = $repo->findByPreference('role', 'admin');

// Multiple preferences (all must match)
$darkAdmins = $repo->findByMultiplePreferences([
    'role' => 'admin',
    'theme' => 'dark',
]);

// Multiple values for one key
$members = $repo->findWithin('status', ['active', 'pending']);

// Pattern matching
$emailDomain = $repo->findLike('email', 'john%');

// Advanced custom logic
$special = $repo->advanced(function ($query) {
    $query->withPreferences('role', 'admin')
          ->orWhereBetween('created_at', [now()->subYear(), now()]);
});
```

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

### Combine Schemaless Queries with Standard Eloquent

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Chain withExtraAttributes with standard Eloquent query builder methods.

```php
User::withExtraAttributes('role', 'admin')
    ->where('active', true)
    ->orderBy('created_at', 'desc')
    ->get();
```

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

### Handle Empty Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Shows how to handle empty arrays or null values assigned to the schemaless column.

```php
// Empty array
$model->extra_attributes = [];
$model->extra_attributes->count();
// Returns: 0

// Empty schemaless column (NULL)
$model->extra_attributes = null;
// Column is null but SchemalessAttributes instance still works
```

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

### Create JSON columns without the macro

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Manually define JSON columns using standard Laravel schema methods if the macro is not desired.

```php
Schema::table('users', function (Blueprint $table) {
    $table->json('extra_attributes')->nullable();
    
    // Or with default value
    $table->json('extra_attributes')->default('{}');
    
    // Or non-nullable
    $table->json('extra_attributes');
});
```

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

### Delegate method calls with synchronization

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/architecture.md

Wraps a Collection and synchronizes changes back to the model after delegating method calls.

```php
public function __call($name, $arguments)
{
    $result = call_user_func_array([$this->collection, $name], $arguments);
    
    // Keep model in sync
    $this->override($this->collection->toArray());
    
    return $result;
}
```

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

### Create Multiple Schemaless Columns in Migration

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Define multiple schemaless columns within a single migration file using the schemalessAttributes method.

```php
return new class extends Migration
{
    public function up()
    {
        Schema::table('products', function (Blueprint $table) {
            $table->schemalessAttributes('attributes');
            $table->schemalessAttributes('seo_data');
            $table->schemalessAttributes('inventory');
            $table->schemalessAttributes('metadata');
        });
    }

    public function down()
    {
        Schema::table('products', function (Blueprint $table) {
            $table->dropColumn([
                'attributes',
                'seo_data',
                'inventory',
                'metadata'
            ]);
        });
    }
};
```

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

### Managing User Preferences

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Store and query complex user preference objects using schemaless attributes.

```php
$user = User::find(1);

// Store user preferences
$user->extra_attributes->set('preferences', [
    'theme' => 'dark',
    'notifications' => [
        'email' => true,
        'sms' => false,
        'push' => true,
    ],
    'language' => 'en',
]);

$user->save();

// Query users by preference
User::withExtraAttributes('preferences->theme', 'dark')->get();

// Access nested preference
$emailNotif = $user->extra_attributes->get('preferences.notifications.email');
```

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

### Query and Index JSON in MySQL/MariaDB

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Utilize the ->> operator for text extraction and define stored generated columns for indexing specific JSON keys.

```php
// Use ->> operator for text extraction
Model::withExtraAttributes('role', 'LIKE', 'admin%')->get();

// Index generated columns for frequent queries
Schema::table('users', function (Blueprint $table) {
    $table->string('role')->storedAs("JSON_UNQUOTE(JSON_EXTRACT(extra_attributes, '$.role'))")->index();
});
```

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

### Migrate from traditional columns to schemaless attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Uses a migration class to add a schemaless column, transfer existing data, and remove the old columns.

```php
return new class extends Migration
{
    public function up()
    {
        // 1. Create the new schemaless column
        Schema::table('users', function (Blueprint $table) {
            $table->schemalessAttributes('metadata');
        });

        // 2. Copy data from traditional columns
        User::all()->each(function ($user) {
            $user->metadata->set([
                'phone' => $user->phone,
                'address' => $user->address,
                'postal_code' => $user->postal_code,
            ]);
            $user->save();
        });

        // 3. Drop old columns
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn(['phone', 'address', 'postal_code']);
        });
    }

    public function down()
    {
        // Reverse: create columns and restore data
        Schema::table('users', function (Blueprint $table) {
            $table->string('phone')->nullable();
            $table->text('address')->nullable();
            $table->string('postal_code')->nullable();
        });

        User::all()->each(function ($user) {
            $user->phone = $user->metadata->get('phone');
            $user->address = $user->metadata->get('address');
            $user->postal_code = $user->metadata->get('postal_code');
            $user->save();
        });

        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('metadata');
        });
    }
};
```

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

### Configure Model and Migration

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/README.md

Add the schemaless attributes column to your migration and cast the attribute in your Eloquent model.

```php
// Migration
Schema::table('users', function (Blueprint $table) {
    $table->schemalessAttributes('extra_attributes');
});

// Model
class User extends Model
{
    public $casts = [
        'extra_attributes' => \Spatie\SchemalessAttributes\Casts\SchemalessAttributes::class,
    ];

    public function scopeWithExtraAttributes(): Builder
    {
        return $this->extra_attributes->modelScope();
    }
}

// Usage
$user = User::find(1);
$user->extra_attributes->set('name', 'John');
$user->save();

$user->extra_attributes->get('name'); // 'John'
User::withExtraAttributes('name', 'John')->get();
```

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

### Use Initialization Hooks

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/architecture.md

Automatically register casts for schemaless attributes during model initialization using the trait's hook.

```php
public function initializeSchemalessAttributesTrait(): void
{
    foreach ($this->getSchemalessAttributes() as $attribute) {
        $this->casts[$attribute] = SchemalessAttributesCast::class;
    }
}
```

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

### Accessing Schemaless Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/00-START-HERE.md

Demonstrates various ways to read and write data within the extra_attributes field.

```php
$model->extra_attributes->name = 'value';           // Property
$model->extra_attributes['name'] = 'value';         // Array
$model->extra_attributes->set('name', 'value');     // Method
$model->extra_attributes->get('name.nested');       // Dot notation
```

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

### Implementing an Audit Trail

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Maintain a history of actions by appending data to an array stored within attributes.

```php
$user = User::find(1);

// Build audit trail over time
$audits = $user->extra_attributes->get('audit_trail', []);

$audits[] = [
    'action' => 'login',
    'timestamp' => now()->toIso8601String(),
    'ip' => '192.168.1.1',
];

$user->extra_attributes->set('audit_trail', $audits);
$user->save();
```

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

### Set attributes as properties

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Assigns an attribute value using magic property access.

```php
$model->extra_attributes->name = 'John'; // Calls __set('name', 'John')
```

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

### Query performance impact of indexes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Demonstrates the performance difference between querying indexed versus non-indexed JSON attributes.

```php
// Fast if you have an index on role
User::withExtraAttributes('role', 'admin')->get();

// Slower without index - scans entire table
User::withExtraAttributes('obscure_field', 'value')->get();
```

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

### SchemalessAttributes::__construct

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Initializes a new instance of SchemalessAttributes bound to a specific Eloquent model and a source attribute column.

```APIDOC
## __construct(Model $model, string $sourceAttributeName)

### Description
Initializes a SchemalessAttributes instance bound to a model and column name.

### Parameters
- **$model** (Illuminate\Database\Eloquent\Model) - Required - The Eloquent model instance that owns these schemaless attributes
- **$sourceAttributeName** (string) - Required - The database column name storing the JSON data

### Example
```php
use Spatie\SchemalessAttributes\SchemalessAttributes;

$schemalessAttrs = new SchemalessAttributes($model, 'extra_attributes');
$schemalessAttrs->set('name', 'John');
```
```

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

### Arrayable Interface Usage

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Converts the schemaless attributes into a standard PHP array.

```php
// Provided method:
public function toArray(): array
```

```php
$array = $model->extra_attributes->toArray();
// Returns: ['key' => 'value', 'nested' => ['field' => 'value']]
```

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

### Querying Schemaless Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/00-START-HERE.md

Shows how to filter Eloquent models based on values stored in schemaless attributes.

```php
Model::withExtraAttributes('name', 'John')->get();
Model::withExtraAttributes(['role' => 'admin'])->get();
Model::withExtraAttributes('name', 'LIKE', 'John%')->get();
Model::withExtraAttributes('address->city', 'Amsterdam')->get();
```

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

### Convert attributes to array with toArray()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Retrieve all schemaless attributes as a standard PHP array.

```php
$attributes = $model->extra_attributes->toArray();
// Returns: ['name' => 'John', 'role' => 'admin']
```

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

### Query and Define JSONB in PostgreSQL

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Use the jsonb column type for better performance and the @> operator for containment queries.

```php
// JSONB is recommended over JSON
$table->jsonb('metadata')->nullable();

// Use @> operator for contains queries
DB::where(DB::raw("metadata @> ?"), [json_encode(['role' => 'admin'])]);
```

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

### Check Attribute Existence

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/usage-patterns.md

Verify if an attribute exists using standard PHP isset, offsetExists, or array_key_exists.

```php
$user = User::find(1);

// Using isset
if (isset($user->extra_attributes->name)) {
    echo $user->extra_attributes->name;
}

// Using offsetExists
if (isset($user->extra_attributes['name'])) {
    echo $user->extra_attributes['name'];
}

// Using array key
if (array_key_exists('name', $user->extra_attributes->toArray())) {
    // ...
```

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

### Support multiple schemaless columns

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Use the SchemalessAttributesTrait to handle multiple JSON columns on a single model.

```php
use Illuminate	ypesuilderuilder;
use Illuminate	ypesuilderuilder;
use Spatie	ypesuilderuilder;
use Spatie	ypesuilderuilder;

class TestModel extends Model
{
    use SchemalessAttributesTrait;

    // ...
    
    /**
     * @var array
     */
    protected $schemalessAttributes = [
        'extra_attributes',
        'other_extra_attributes',
    ];

    public function scopeWithExtraAttributes(): Builder
    {
        return $this->extra_attributes->modelScope();
    }
    
    public function scopeWithOtherExtraAttributes(): Builder
    {
        return $this->other_extra_attributes->modelScope();
    }

    // ...
}
```

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

### Querying multiple schemaless columns

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Chain multiple scope methods to filter by different schemaless columns simultaneously.

```php
Product::withExtraAttributes('brand', 'Acme')
       ->withSeoData('title', 'Great')
       ->get();
```

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

### Retrieve Schemaless Attribute Columns

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Use getSchemalessAttributes to return the list of columns configured as schemaless.

```php
$columns = $model->getSchemalessAttributes();
// Returns: ['extra_attributes', 'preferences']
```

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

### Accessing schemaless attributes via array syntax

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Use array key access to interact with schemaless attributes.

```php
$yourModel->extra_attributes['name'] = 'value';

$yourModel->extra_attributes['name']; // Returns 'value'
```

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

### Define a basic scope method

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/configuration.md

Implement a scope method on the model to enable querying via the extra_attributes property.

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

public function scopeWithExtraAttributes(): Builder
{
    return $this->extra_attributes->modelScope();
}
```

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

### Perform Type Coercion in Queries

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Illustrates how database type coercion applies when querying schemaless attributes for different data types.

```php
// Integer comparison
Model::withExtraAttributes('count', '>', 100)->get();
// Database compares as numeric

// String comparison
Model::withExtraAttributes('name', 'LIKE', 'John%')->get();
// Database compares as text

// Boolean in JSON (stored as true/false)
Model::withExtraAttributes('active', true)->get();
// JSON boolean value
```

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

### Inspect backtrace for scope arguments

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/architecture.md

Uses debug_backtrace to support multiple calling signatures within a single scope method implementation.

```php
public function modelScope(): Builder
{
    $arguments = debug_backtrace()[1]['args'];
    
    // Analyze argument count to determine what was passed
    if (count($arguments) === 1) {
        [$builder] = $arguments;
    }
    // ... handle other cases
    
    return $builder;
}
```

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

### set(string|iterable $key, mixed $value = null)

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Set a schemaless attribute or merge multiple attributes at once.

```APIDOC
## set(string|iterable $key, mixed $value = null)

### Description
Set a schemaless attribute or merge multiple attributes at once. Supports dot notation.

### Parameters
- **$key** (string|iterable) - Required - The attribute key (dot notation supported) or array of key-value pairs to merge.
- **$value** (mixed) - Optional - The value to set (ignored if $key is iterable).

### Return Type
self - Returns self for method chaining.
```

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

### Distinguish NULL and Empty Object States

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Note that setting a column to NULL is distinct from assigning an empty array.

```php
// NULL column
$model->metadata = null;
// is different from
// Empty object
$model->metadata = [];
```

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

### Set attributes with set()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Update single or multiple attributes using dot notation or an associative array. Returns the instance for method chaining.

```php
// Set a single attribute
$model->extra_attributes->set('name', 'John');

// Set nested attribute with dot notation
$model->extra_attributes->set('user.role', 'admin');

// Merge multiple attributes
$model->extra_attributes->set([
    'name' => 'John',
    'email' => 'john@example.com'
]);
```

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

### Add Schemaless Column to Existing Table

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Use a migration to add a new schemaless column to an existing database table.

```php
return new class extends Migration
{
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->schemalessAttributes('extra_attributes');
        });
    }

    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('extra_attributes');
        });
    }
};
```

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

### Detect and Log Attribute Changes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/advanced-patterns.md

Implement custom diffing logic to track added, removed, or changed attributes for audit logging purposes.

```php
class User extends Model
{
    protected $schemalessAttributes = ['metadata'];

    public function getMetadataChanges(): array
    {
        $original = $this->getOriginal('metadata');
        $current = $this->metadata->toArray();

        $originalArray = $original ? json_decode($original, true) : [];

        return [
            'added' => array_diff_assoc($current, $originalArray),
            'removed' => array_diff_assoc($originalArray, $current),
            'changed' => array_intersect_key(
                array_diff_assoc($current, $originalArray),
                array_diff_assoc($originalArray, $current)
            ),
        ];
    }

    public function logMetadataChanges()
    {
        $changes = $this->getMetadataChanges();

        if (!empty($changes['added']) || !empty($changes['removed']) || !empty($changes['changed'])) {
            AuditLog::create([
                'user_id' => $this->id,
                'changes' => $changes,
                'timestamp' => now(),
            ]);
        }
    }
}

// Usage
$user = User::find(1);
$user->metadata->set('role', 'admin');
$user->metadata->set('department', 'Engineering');
$user->save();

$changes = $user->getMetadataChanges();
// [
//     'added' => ['role' => 'admin', 'department' => 'Engineering'],
//     'removed' => [],
//     'changed' => []
// ]
```

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

### Filter models with modelScope()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Define a model scope to filter records based on schemaless attributes using various argument patterns.

```php
// In your model, define a scope like:
public function scopeWithExtraAttributes(): Builder
{
    return $this->extra_attributes->modelScope();
}

// Then use it with various argument counts:

// Pattern 1: Array of attributes
Model::withExtraAttributes(['name' => 'John', 'role' => 'admin'])->get();

// Pattern 2: Single key-value pair
Model::withExtraAttributes('name', 'John')->get();

// Pattern 3: Operator-based comparison
Model::withExtraAttributes('name', 'LIKE', 'John%')->get();

// Pattern 4: Nested attribute with arrow notation
Model::withExtraAttributes('character->side', 'light')->get();
```

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

### Iterate attributes with getIterator()

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Allows direct iteration over the schemaless attributes collection.

```php
foreach ($model->extra_attributes as $key => $value) {
    echo "$key: $value";
}
```

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

### Process large tables using chunk iteration

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Use chunking to prevent memory exhaustion when migrating large datasets.

```php
User::chunk(1000, function ($users) {
    foreach ($users as $user) {
        $user->metadata->set([
            'phone' => $user->phone,
            'address' => $user->address,
        ]);
        $user->save();
    }
});
```

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

### toJson(int $options = 0)

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Convert schemaless attributes to a JSON string.

```APIDOC
## toJson(int $options = 0)

### Description
Convert schemaless attributes to a JSON string.

### Parameters
- **$options** (int) - Optional - JSON encoding options (e.g., JSON_PRETTY_PRINT).

### Return Type
string - Valid JSON string.
```

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

### Perform Batch Attribute Updates

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

Use an array to set multiple attributes at once to minimize database write operations.

```php
// Inefficient: 3 database writes
$user->metadata->set('field1', 'value1'); $user->save();
$user->metadata->set('field2', 'value2'); $user->save();
$user->metadata->set('field3', 'value3'); $user->save();

// Efficient: 1 database write
$user->metadata->set([
    'field1' => 'value1',
    'field2' => 'value2',
    'field3' => 'value3',
]);
$user->save();
```

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

### Key Parameter Type Definition

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

Type definition for keys used in set and forget methods.

```php
type: string | array | iterable
```

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

### Check attribute existence using array syntax

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Verifies if an attribute key is set using the ArrayAccess interface.

```php
if (isset($model->extra_attributes['name'])) { // Uses offsetExists()
    // ...
}
```

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

### Macro equivalence

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

The schemalessAttributes macro is a shorthand for creating a nullable JSON column.

```php
// The macro is equivalent to:
$table->json('extra_attributes')->nullable();
```

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

### Create Type-Safe Attribute Wrappers

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/advanced-patterns.md

Use a dedicated value object class to enforce types and provide structured access to schemaless data.

```php
// app/Values/UserMetadata.php

namespace App\Values;

use Illuminate\Contracts\Support\Arrayable;

class UserMetadata implements Arrayable
{
    public function __construct(
        private array $data = []
    ) {}

    public static function fromArray(array $data): self
    {
        return new self($data);
    }

    public function getRole(): ?string
    {
        return $this->data['role'] ?? null;
    }

    public function setRole(string $role): self
    {
        $this->data['role'] = $role;
        return $this;
    }

    public function getLastLoginAt(): ?string
    {
        return $this->data['last_login_at'] ?? null;
    }

    public function setLastLoginAt(string $timestamp): self
    {
        $this->data['last_login_at'] = $timestamp;
        return $this;
    }

    public function getLoginCount(): int
    {
        return $this->data['login_count'] ?? 0;
    }

    public function incrementLoginCount(): self
    {
        $this->data['login_count'] = ($this->data['login_count'] ?? 0) + 1;
        return $this;
    }

    public function toArray(): array
    {
        return $this->data;
    }
}

// Usage in model

class User extends Model
{
    public function getMetadata(): UserMetadata
    {
        return UserMetadata::fromArray(
            $this->extra_attributes->toArray()
        );
    }

    public function setMetadata(UserMetadata $metadata): self
    {
        $this->extra_attributes = $metadata->toArray();
        return $this;
    }
}

// Application code
$user = User::find(1);
$metadata = $user->getMetadata();
$metadata->setRole('admin')
         ->setLastLoginAt(now()->toIso8601String())
         ->incrementLoginCount();
$user->setMetadata($metadata);
$user->save();
```

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

### Implement Model Scopes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/architecture.md

Define a scope method to leverage the package's query builder capabilities for filtering by extra attributes.

```php
// In model
public function scopeWithExtraAttributes(): Builder
{
    return $this->extra_attributes->modelScope();
}

// Enables:
Model::withExtraAttributes('key', 'val')->get();
```

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

### Define custom column names

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/migration-guide.md

The schemalessAttributes macro supports custom column names for different data purposes.

```php
$table->schemalessAttributes('metadata');
$table->schemalessAttributes('preferences');
$table->schemalessAttributes('custom_data');
$table->schemalessAttributes('api_response');
```

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

### SchemalessAttributes Class Signature

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/types.md

The core class definition and interface implementation for SchemalessAttributes.

```php
use Spatie
ull

// Type signature
SchemalessAttributes implements ArrayAccess, Arrayable, Countable, IteratorAggregate, Jsonable, JsonSerializable
```

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

### Querying models with schemaless attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Use the withExtraAttributes scope to filter models based on specific schemaless attribute values.

```php
// Returns all models that have all the given schemaless attributes
$yourModel->withExtraAttributes(['name' => 'value', 'name2' => 'value2'])->get();
```

```php
// returns all models that have a schemaless attribute `name` set to `value`
$yourModel->withExtraAttributes('name', 'value')->get();
```

```php
// returns all models that have a schemaless attribute `name` starting with `value`
$yourModel->withExtraAttributes('name', 'LIKE', 'value%')->get();
```

```php
// returns all models that have a schemaless nested attribute `han.side` set to `light`
$yourModel->withExtraAttributes('han->side', 'light')->get();
```

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

### SchemalessAttributes::createForModel

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

A static factory method to create a new instance of SchemalessAttributes for a given model.

```APIDOC
## createForModel(Model $model, string $sourceAttributeName)

### Description
Factory method to create a new instance of SchemalessAttributes.

### Parameters
- **$model** (Illuminate\Database\Eloquent\Model) - Required - The Eloquent model instance
- **$sourceAttributeName** (string) - Required - The database column name for schemaless attributes

### Returns
- **self** (SchemalessAttributes) - The created instance.

### Example
```php
$attrs = SchemalessAttributes::createForModel($user, 'extra_attributes');
```
```

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

### Manipulate and Query Schemaless Attributes

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/README.md

Demonstrates various ways to set, retrieve, and delete attributes within a schemaless JSON column on an Eloquent model.

```php
// add and retrieve an attribute
$yourModel->extra_attributes->name = 'value';
$yourModel->extra_attributes->name; // returns 'value'

// you can also use the array approach
$yourModel->extra_attributes['name'] = 'value';
$yourModel->extra_attributes['name'] // returns 'value'

// setting multiple values in one go
$yourModel->extra_attributes = [
   'rey' => ['side' => 'light'],
   'snoke' => ['side' => 'dark']
];

// setting/updating multiple values in one go via set()
$yourModel->extra_attributes->set([
   'han' => ['side' => 'light'],
   'snoke' => ['side' => 'dark']
]);

// retrieving values using dot notation
$yourModel->extra_attributes->get('rey.side'); // returns 'light'

// retrieve default value when attribute is not exists
$yourModel->extra_attributes->get('non_existing', 'default'); // returns 'default'

// it has a modelScope to retrieve all models with the given schemaless attributes
$yourModel->withSchemalessAttributes(['name' => 'value', 'name2' => 'value2'])->get();

// delete key & value
$yourModel->extra_attributes->forget('key');
```

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

### Access attributes as properties

Source: https://github.com/spatie/laravel-schemaless-attributes/blob/main/_autodocs/api-reference.md

Retrieves an attribute value using magic property access.

```php
$name = $model->extra_attributes->name; // Calls __get('name')
```
Tokens:
Raw