Transform JSON into Typed Collections with Laravel's AsCollection::of()

Laravel enhances data handling capabilities with the AsCollection::of() method, enabling developers to transform JSON columns into strongly-typed collections of value objects automatically. This feature brings structure and maintainability to complex data storage scenarios.

Working with complex data structures in Laravel often requires storing information in JSON columns, but dealing with raw arrays can create messy, difficult-to-maintain code. The AsCollection::of() method addresses this challenge by casting JSON data into properly typed collections:

use App\ValueObjects\Setting;
use Illuminate\Database\Eloquent\Casts\AsCollection;
 
protected function casts(): array
{
    return [
        'settings' => AsCollection::of(Setting::class)
    ];
}

This casting automatically transforms your JSON column into a collection of your specified class instances, equivalent to:

Collection::make($this->attributes['settings'])->mapInto(Setting::class);

The transformation occurs automatically when Laravel hydrates your model from the database, providing type safety and encapsulation without additional effort.

Consider building a content management system where articles have multiple configuration settings. Each setting contains a key, value, and visibility flag:

namespace App\ValueObjects;
 
use Illuminate\Contracts\Support\Arrayable;
use JsonSerializable;
 
class ArticleSetting implements Arrayable, JsonSerializable
{
    public function __construct(
        public readonly string $key,
        public readonly string $value,
        public readonly bool $isPublic = false
    ) {}
 
    public function toArray()
    {
        return [
            'key' => $this->key,
            'value' => $this->value,
            'is_public' => $this->isPublic,
        ];
    }
 
    public function jsonSerialize(): mixed
    {
        return $this->toArray();
    }
 
    public function isVisibleToGuests(): bool
    {
        return $this->isPublic && !empty($this->value);
    }
}

In your Article model, apply the AsCollection::of() cast:

namespace App\Models;
 
use App\ValueObjects\ArticleSetting;
use Illuminate\Database\Eloquent\Casts\AsCollection;
use Illuminate\Database\Eloquent\Model;
 
class Article extends Model
{
    protected function casts(): array
    {
        return [
            'settings' => AsCollection::of(ArticleSetting::class)
        ];
    }
 
    public function getPublicSettingsAttribute()
    {
        return $this->settings->filter(fn ($setting) => $setting->isPublic);
    }
}

Now you can work with article settings as first-class objects:

$article = Article::find(1);
 
// Get all settings as ArticleSetting objects
$allSettings = $article->settings;
 
// Filter using methods on your value object
$visibleSettings = $article->settings->filter(fn ($setting) => $setting->isVisibleToGuests());
 
// Add a new setting (automatically serialized back to JSON)
$article->settings->push(new ArticleSetting('author_display', 'John Doe', true));
$article->save();

This approach excels in scenarios like user preferences, application configurations, survey responses, feature toggles with metadata, or any situation requiring structured data with consistent patterns.