Studio — Custom Fields, Collections & REST API

• Screenshots
• Why Filament Studio?
• Features
  • Dynamic Collections
  • Dashboard Builder
  • Advanced Filtering
  • REST API
  • Conditional Logic
  • Multilingual Content
  • Multi-Tenancy
  • Record Versioning & Soft Deletes
  • Authorization & Spatie Permissions
• Quick Start
  • Install
  • Publish & Migrate
  • Register the Plugin
  • Configure (Optional)
• Extending
  • Custom Field Types
  • Lifecycle Hooks
• Architecture
• Documentation
• Requirements
• Testing
• Changelog
• Contributing
• Security
• Credits
• License

A dynamic data model manager for Filament v5 — create collections, define fields, manage records, and build dashboards, all at runtime. No migrations required.

Filament Studio turns your Filament admin panel into a flexible data platform. Define custom data structures through a visual interface, and the plugin handles the rest: forms, tables, filters, API endpoints, dashboards, and access control — all powered by an EAV (Entity-Attribute-Value) storage engine.

#Screenshots

Collections list

Create collection — Basic Info

Create collection — System Fields

Create collection — Settings

Fields list

Field editor

Advanced filter builder

Version history

Dashboard editor

API Keys

API Key editor

API Documentation

Collection permissions

#Why Filament Studio?

• No migrations per collection — Add new data types at runtime without touching your codebase
• Full Filament integration — Native forms, tables, filters, and actions that look and feel like hand-crafted resources
• Production-ready — Multi-tenancy, multilingual content, authorization, versioning, soft deletes, and audit logging out of the box
• Extensible — Register custom field types, panel types, condition resolvers, and lifecycle hooks

#Features

#Dynamic Collections

Create and manage data collections with custom fields through the admin UI. Each collection gets a fully functional CRUD interface with forms, tables, and filters — generated dynamically from the field definitions.

33 built-in field types across 9 categories:

#Dashboard Builder

Build data dashboards with 9 panel types: Metric, List, Time Series, Bar Chart, Line Chart, Pie Chart, Meter, Label, and Variable. Place panels on dashboards (12-column grid), collection pages, or record pages.

Panels support dynamic variables ($CURRENT_USER, $NOW, {{custom}}), aggregate functions (count, sum, avg, min, max), and interactive controls.

#Advanced Filtering

A visual filter builder with 23 operators, nested AND/OR logic, dynamic variables, and saved filter presets. Operators adapt to data type — text fields get "contains" and "starts with", dates get "before" and "after", JSON fields get "contains any/all/none".

#REST API

Auto-generated RESTful API with API key authentication, per-collection permissions, rate limiting, and OpenAPI documentation via Scramble.

#Conditional Logic

Fields can be conditionally visible, required, or disabled based on form values, user permissions, page context, or custom resolvers — with cycle detection for safety.

#Multilingual Content

Opt-in per-locale support for translatable fields. Enable multilingual globally, then configure each collection with its own supported locales and default locale. Mark individual fields as translatable — non-translatable fields (booleans, dates, numbers) store a single value regardless of locale.

• Locale resolution — ?locale= query param > X-Locale header > session > collection default > global default
• Automatic fallback — When a translation is missing, falls back to the default locale with metadata indicating which fields fell back
• Admin locale switcher — Toggle between locales in the record editor; version history includes a per-locale viewer
• API support — All REST endpoints accept locale selection; ?all_locales=true returns all translations as nested objects
• OpenAPI documentation — Locale parameters and _meta response schemas appear automatically in API docs when multilingual is enabled

// config/filament-studio.php
'locales' => [
    'enabled' => true,
    'available' => ['en', 'fr', 'de'],
    'default' => 'en',
],

#Multi-Tenancy

Full tenant isolation across all models. Every collection, record, dashboard, and API key is scoped to its tenant.

#Record Versioning & Soft Deletes

Optional snapshot-based version history with restore capability, including per-locale snapshots for translatable fields. Optional soft deletes to recover deleted records.

#Authorization & Spatie Permissions

Policy-based access control with granular per-collection permissions. When spatie/laravel-permission is installed, Filament Studio automatically syncs permissions for each collection:

• Per-collection CRUD permissions — studio.collection.{slug}.viewRecords, createRecord, updateRecord, deleteRecord
• Global permissions — studio.manageFields, studio.manageApiKeys
• Auto-sync — Permissions are created/removed automatically when collections are created, renamed, or deleted
• Navigation & action enforcement — UI elements (navigation items, create/edit/delete buttons) are hidden when the user lacks the corresponding permission
• Graceful fallback — If Spatie Permission is not installed, all actions are allowed by default

#Quick Start

#Install

composer require flexpik/filament-studio

#Publish & Migrate

php artisan vendor:publish --tag="filament-studio-migrations"
php artisan migrate

#Register the Plugin

use Flexpik\FilamentStudio\FilamentStudioPlugin;

public function panel(Panel $panel): Panel
{
    return $panel
        ->plugins([
            FilamentStudioPlugin::make(),
        ]);
}

Visit your admin panel — you'll find a new Studio section in the sidebar.

#Configure (Optional)

FilamentStudioPlugin::make()
    ->navigationGroup('Content')
    ->enableVersioning()
    ->enableSoftDeletes()
    ->enableApi()
    ->fieldTypes([
        'currency' => CurrencyFieldType::class,
    ])
    ->panelTypes([
        CustomMapPanel::class,
    ]);

Publish the config for environment-level settings:

php artisan vendor:publish --tag="filament-studio-config"

#Extending

#Custom Field Types

Create field types by extending AbstractFieldType:

use Flexpik\FilamentStudio\FieldTypes\AbstractFieldType;
use Flexpik\FilamentStudio\Enums\EavCast;

class RatingFieldType extends AbstractFieldType
{
    protected static string $key = 'rating';
    protected static string $label = 'Rating';
    protected static string $icon = 'heroicon-o-star';
    protected static EavCast $eavCast = EavCast::Integer;
    protected static string $category = 'numeric';

    public function settingsSchema(): array { /* ... */ }
    public function toFilamentComponent(): Component { /* ... */ }
    public function toTableColumn(): ?Column { /* ... */ }
    public function toFilter(): ?Filter { /* ... */ }
}

#Lifecycle Hooks

React to events and modify generated schemas:

FilamentStudioPlugin::afterCollectionCreated(fn ($collection) => /* ... */);
FilamentStudioPlugin::afterFieldAdded(fn ($field) => /* ... */);

FilamentStudioPlugin::modifyFormSchema(fn (array $schema, $collection) => $schema);
FilamentStudioPlugin::modifyTableColumns(fn (array $columns, $collection) => $columns);
FilamentStudioPlugin::modifyQuery(fn ($query) => $query);

#Architecture

Filament Studio uses EAV (Entity-Attribute-Value) storage — data is stored across four core tables instead of creating a table per collection:

This approach enables runtime schema changes without migrations while preserving native database sorting and type safety through typed storage columns.

#Documentation

#Requirements

• PHP 8.3+
• Laravel 11+
• Filament v5

#Testing

vendor/bin/pest

#Changelog

See CHANGELOG for recent changes.

#Contributing

See CONTRIBUTING for details.

#Security

If you discover a security vulnerability, please send an email to the maintainers. All security vulnerabilities will be promptly addressed.

#Credits

• Flexpik
• All Contributors

#License

The MIT License (MIT). See LICENSE for details.