Eloquent

Overview Livewire 4 introduces **Islands**, a specialized feature designed to solve long-standing performance bottlenecks in dynamic web applications. Traditionally, heavy database operations or complex Eloquent queries could stall an entire page render. Islands allow developers to isolate specific sections of a component, enabling independent refreshing and management without triggering a full-page reload. This architectural shift ensures that static content remains responsive while dynamic, data-heavy segments load asynchronously. Prerequisites To effectively implement islands, you should be familiar with: * Laravel framework fundamentals * Basic Livewire component structure (Single File Components) * PHP Eloquent ORM * Tailwind CSS (for styling placeholders and animations) Key Libraries & Tools * **Livewire 4**: The core full-stack framework for Laravel. * **Laravel AI SDK**: Upcoming integration for AI-driven development (Feb 2026). * **Native PHP**: The underlying language environment (v2 and v3 support). Code Walkthrough Implementing an island involves wrapping dynamic Blade content in `@island` directives. ```php @island @foreach($tickets as $ticket) <div>{{ $ticket->subject }}</div> @endforeach @endisland ``` Deferred and Lazy Loading To prevent the initial page load from hanging on a 2-second query, use the `defer` attribute. This renders the main page immediately and fetches the island data in a subsequent request. ```html @island('latest-tickets', defer: true) ``` For content below the fold, use `lazy: true`. This ensures the network request only triggers once the user scrolls the island into the viewport. Placeholders and Polling Improve user experience by adding a `@placeholder` block. This displays temporary UI, like an animated pulse, while the server processes the request. ```php @island @placeholder <div class="animate-pulse">Loading tickets...</div> @endplaceholder <!-- Dynamic Content --> @endisland ``` Syntax Notes * **Named Islands**: Assigning a name (e.g., `latest-tickets`) allows you to target specific segments for manual refreshes using `wire:island="name"`. * **Encapsulation**: Islands are strictly scoped; they cannot access local variables defined outside the `@island` directive unless passed explicitly. Practical Examples * **Dashboard Widgets**: Use `defer` for analytic charts so the main navigation is instant. * **Live Feeds**: Combine islands with `wire:poll` to update a specific list every few seconds without disrupting the rest of the UI. * **Heavy Tables**: Use `lazy` for tables at the bottom of a long page to save server resources. Tips & Gotchas * **Looping Restrictions**: Never place an `@island` directive inside a `@foreach` loop; it will fail. Instead, place the loop *inside* the island. * **Scope Isolation**: If you see an "Undefined variable" error, ensure the variable is part of the component's state or passed directly; islands do not inherit the surrounding Blade scope.

Overview Laravel recently introduced the `JsonApiResource` class in version 12.45, a significant update that aligns the framework with the official JSON:API specification. Historically, Laravel utilized an opinionated, flat structure for its Eloquent resources. This new feature allows developers to serve data in a standardized format that includes specific keys like `type`, `id`, and `attributes`, making it easier for standardized frontend clients to consume backend data without custom mapping. Prerequisites To follow this guide, you should have a baseline understanding of PHP and the Laravel framework. Familiarity with REST APIs and Postman for testing endpoints is recommended. You must be running Laravel 12.45 or higher to access the new resource class. Key Libraries & Tools * **Laravel Framework**: The core PHP framework providing the new API features. * **JSON:API Specification**: The industry-standard protocol for building APIs in JSON. * **Postman**: A tool used to visualize and test the differences between standard and JSON:API responses. Code Walkthrough Instead of extending the usual `JsonResource`, you now extend `JsonApiResource`. This small change fundamentally reshapes the output. ```php use Illuminate\Http\Resources\Json\JsonApiResource; class PostResource extends JsonApiResource { public function toArray($request) { return [ 'id' => $this->id, 'title' => $this->title, 'slug' => $this->slug, 'category' => new CategoryResource($this->whenLoaded('category')), ]; } } ``` In the standard `JsonResource`, the fields like `title` and `slug` appear at the top level of the `data` object. However, when using `JsonApiResource`, Laravel automatically nests these fields under an `attributes` key and extracts the `id` and `type` to the top level. This satisfies the strict requirements of the JSON:API spec without requiring you to manually rebuild the array structure. Global Configuration You can configure global metadata for your JSON:API implementation within the `AppServiceProvider` or a dedicated provider. This allows you to set versioning or extensions that apply to all resources. ```php use Illuminate\Http\Resources\Json\JsonApiResource; public function boot() { JsonApiResource::configure( version: '1.1', meta: ['api_status' => 'stable'] ); } ``` Syntax Notes The `JsonApiResource` class uses internal logic to wrap your `toArray` return values. While your resource file looks familiar, the framework post-processes the array to move everything into the `attributes` block unless it matches the reserved keys for `id`, `type`, or `relationships`. Tips & Gotchas One common point of confusion is the versioning string in the configuration. While the JSON:API website currently highlights versions 1.1 and 1.2, Laravel allows you to pass custom strings. Always verify your frontend client's expectations before hardcoding a version like `2.0` in your service provider.

Overview Modern web applications often require highly interactive, stateful interfaces without the overhead of a full SPA framework. This Laravel Quiz Project demonstrates how to build a robust examination system using the TALL stack. It bridges the gap between complex administrative backend tasks—like CSV question imports—and a fluid, real-time student experience featuring countdown timers and progress tracking. Prerequisites To implement this architecture, you need a firm grasp of PHP 8.2+ and Laravel 11/12. Familiarity with Livewire lifecycle hooks, basic AlpineJS directives, and Eloquent relationships is essential for handling the data-intensive nature of quiz attempts. Key Libraries & Tools - **Laravel**: The foundation framework. - **Livewire**: Handles the dynamic quiz-taking interface without manual JS. - **Filament**: A powerful admin panel used for question and category management. - **AlpineJS**: Manages client-side reactivity for the timer. - **Flux UI**: Provides accessible UI components like badges and progress bars. Code Walkthrough Interactive Quiz Component The quiz logic resides in a Livewire component that tracks user state. Instead of standard controllers, we use the `mount` and `boot` methods to initialize services and validate student attempts. ```php public function boot(QuizService $quizService) { // Workaround for constructor property promotion in Livewire $this->quizService = $quizService; } public function updatedAnswers($value, $key) { // Save progress to database immediately on selection $this->quizService->saveAnswer($this->attempt->id, $key, $value); } ``` Reactive Frontend with AlpineJS We handle the countdown timer purely on the frontend to avoid unnecessary server round-trips. AlpineJS synchronizes with Livewire when the time expires. ```html <div x-data="{ timer: 60 }" x-init="setInterval(() => { if(timer > 0) timer-- }, 1000)"> <span x-text="timer"></span> seconds remaining </div> ``` Filament Admin Integration Administrators manage complex question types using Filament repeaters. This allows for dynamic addition of options and validation to ensure at least one correct answer exists. ```php Repeater::make('options') ->schema([ TextInput::make('option_text')->required(), Toggle::make('is_correct'), ]) ->rules([/* Custom validation logic */]) ``` Syntax Notes The project utilizes `wire:model.live.debounce.500ms` for answer selection. This specific pattern ensures the server is notified of the student's choice almost instantly without flooding the network with requests on every micro-interaction. Practical Examples This architecture fits certifications, internal corporate training modules, or educational platforms. By utilizing the Filament importer, you can migrate thousands of questions from legacy spreadsheets into a functional web app in seconds. Tips & Gotchas Avoid using traditional PHP constructors in Livewire components; use the `boot` method for dependency injection instead. Additionally, always ensure `wire:key` is unique within loops to prevent AlpineJS from losing track of the DOM state during live updates.

Overview Standard Laravel Eloquent Observers often feel repetitive. Developers frequently find themselves writing the same notification or logging logic across dozens of models. This guide explores a highly efficient refactoring pattern that uses custom Artisan commands and framework stubs to generate boilerplate-free observers automatically. By shifting logic into traits and templates, you can maintain a consistent audit log or notification system without manual coding. Prerequisites To implement this pattern, you should be comfortable with PHP and the Laravel framework. You need a basic understanding of Eloquent model events (created, updated, deleted) and how Artisan CLI commands interact with the file system. Key Libraries & Tools * **Laravel Framework**: The core environment providing the Eloquent ORM. * **Artisan CLI**: Used for generating code and publishing framework templates. * **PHP File System**: Utilized by custom commands to iterate through model directories. Code Walkthrough Step 1: Create the Base Notification Trait Instead of defining notification logic in every observer, move it to a shared trait. This keeps your observers slim. ```php trait SendsNotifications { public function sendSuccessNotification($model, $action) { // Logic to send database notification } public function sendDangerNotification($model, $action) { // Logic for deletions or errors } } ``` Step 2: Customizing the Observer Stub Run `php artisan stub:publish` to bring Laravel's internal templates into your `stubs/` directory. Modify `observer.stub` to include your trait and default methods. ```php namespace {{ namespace }}; use {{ namespacedModel }}; use App\Traits\SendsNotifications; class {{ class }} { use SendsNotifications; public function created({{ model }} ${{ modelVariable }}) { $this->sendSuccessNotification(${{ modelVariable }}, 'created'); } } ``` Step 3: The Bulk Generation Command A custom Artisan command can automate the creation for all models in your app. ```php public function handle() { $models = File::allFiles(app_path('Models')); foreach ($models as $file) { $modelName = $file->getFilenameWithoutExtension(); $this->call('make:observer', [ 'name' => "{$modelName}Observer", '--model' => $modelName ]); } } ``` Syntax Notes Laravel uses mustache-style placeholders like `{{ model }}` in its stubs. When you run a `make` command, the framework's generator replaces these with the actual class names you provide in the terminal. This allows for dynamic code generation while maintaining strict typing. Practical Examples This approach shines in large-scale applications requiring a robust activity log or audit trail. Instead of installing heavy packages, you generate lightweight observers that trigger database notifications every time a record changes. It ensures every new model added to the system is automatically tracked without additional developer effort. Tips & Gotchas Watch out for infinite loops. If your observer saves data back to the same model it is observing, it will trigger itself again. Always use the `saveQuietly()` method if you need to update the model instance within the observer logic to prevent recursive crashes.

The Problem with Manual Database Queries Standard database queries fail when your data scales. You might start with a simple `where('title', 'like', "%$query%")` clause, but requirements quickly snowball. Soon, you need to search descriptions, genres, and metadata. Coding these chainable queries manually creates bloated, unreadable controllers. Performance hits become inevitable as your database struggles to scan every string across multiple columns. Laravel Scout solves this by providing a driver-based solution that offloads the heavy lifting to dedicated search engines. Prerequisites and Setup Before you begin, ensure you have a Laravel project running with a functional database. You should understand Eloquent models and basic controller logic. To follow this guide, you will need the Scout package installed via Composer and a search driver like Algolia, Meilisearch, or Typesense configured in your environment variables. Making Models Searchable To enable search, you must prepare your model. Add the `Searchable` trait to your class definition. This trait hooks into Eloquent's model observers to keep your search index synced with your database. ```php namespace App\Models; use Laravel\Scout\Searchable; use Illuminate\Database\Eloquent\Model; class Movie extends Model { use Searchable; public function toSearchableArray(): array { return [ 'title' => $this->title, 'description' => $this->description, 'rank' => $this->rank, ]; } } ``` The `toSearchableArray` method is your control center. It defines exactly what data gets sent to the search engine. This prevents sensitive data from leaking into your public index and allows you to format relationships or calculated fields for better search relevance. Clean Controller Integration Once the model is ready, your controller code shrinks significantly. You can replace messy query builders with a single, expressive `search` method. ```php public function index(Request $request) { $movies = Movie::search($request->input('search'))->get(); return view('movies.index', compact('movies')); } ``` Syncing Data and Using External Drivers While the local database driver works for development, production environments require specialized tools. Services like Algolia provide lightning-fast results and handle complex relationship searches that standard SQL struggles with. To populate your external index for the first time, use the artisan command: ```bash php artisan scout:import "App\Models\Movie" ``` Tips and Gotchas Don't try to search relationships directly using the basic database driver; it will look for a column that doesn't exist on the table and throw an error. If you need to search through related data like Genres, use a more advanced driver. Always remember that Scout uses observers—if you use mass updates via `Movie::query()->update()`, the search index won't see those changes. Use standard Eloquent `save()` or `update()` calls to keep everything in sync.

Overview of Multi-Tenancy Models Multi-tenancy allows a single application to serve multiple distinct groups of users, or tenants, while keeping their data invisible to one another. In the Laravel ecosystem, this architecture usually takes two forms: **single-database** and **multi-database** isolation. Choosing between them depends on your scale, legal requirements, and the nature of your customers. For B2C apps where users are individuals, a shared database with simple filtering is often sufficient. However, for B2B enterprises requiring strict data privacy, physically separating data into different databases is the standard. Prerequisites To follow this guide, you should be comfortable with PHP and the Laravel framework. Familiarity with Eloquent models, Middleware, and Artisan commands is essential. You should also understand basic DNS concepts like wildcards and subdomains if you plan to implement database-per-tenant isolation. Key Libraries & Tools * **stancl/tenancy**: A powerful package (also known as Tenancy for Laravel) that automates database creation, switching, and routing for multi-tenant apps. * **Laravel Fortify**: A front-end agnostic authentication backend used to handle registration and login logic. * **Laravel Herd**: A local development environment that simplifies managing subdomains and local testing. Code Walkthrough: Implementing Logic 1. Single Database Filtering In a shared database, you typically include an `organization_id` on every table. You can then use Eloquent scopes to ensure users only see their own data. ```php // TaskController.php public function store(Request $request) { // Automatically associate task with the user's organization $task = Task::create([ 'title' => $request->title, 'user_id' => auth()->id(), 'organization_id' => auth()->user()->organization_id, ]); } ``` 2. Multi-Database Setup with stancl/tenancy When using stancl/tenancy, the package handles the heavy lifting of switching database connections based on the current subdomain. You must define a `Tenant` model to track these entities. ```php // config/tenancy.php 'tenant_model' => App\Models\Tenant::class, // Creating a tenant during registration $tenant = Tenant::create(['id' => $subdomain]); $tenant->domains()->create(['domain' => $subdomain . '.yourapp.test']); ``` Syntax Notes & Authentication Pitfalls Modern Laravel starter kits often use Laravel Fortify, which abstracts routes into internal actions. When implementing subdomains, you must override the `LogoutResponse` and `LoginResponse` to ensure users are redirected to the correct tenant-specific URL. Without these overrides, the application might attempt to authenticate a user against the central database rather than the tenant-specific database, leading to failed logins. Tips & Gotchas When scaling a multi-database architecture, remember that you cannot easily perform cross-database joins. If your users are stored in the central database but tasks are in tenant databases, standard Eloquent relationships will fail. Furthermore, always use `tenants:migrate` instead of the standard migration command to ensure every tenant schema stays in sync. If one tenant grows massively, you may eventually need to move their specific database to a dedicated server, a process that requires robust DevOps orchestration.

Overview Managing complex data relationships often leads developers into a maze of redundant tables and messy foreign keys. Laravel Eloquent solves this by providing sophisticated relationship types that streamline database architecture. This guide explores how to implement polymorphic connections, handle pivot table data, and traverse deep model chains to keep your codebase clean and efficient. Prerequisites To follow this guide, you should have a solid grasp of PHP and basic Laravel concepts. You should understand standard One-to-Many and Many-to-Many relationships, as well as how to run database migrations and work with Eloquent models. Key Libraries & Tools * **Laravel Eloquent**: The powerful Object-Relational Mapper (ORM) included with Laravel. * **Eloquent Has Many Deep**: A package by Jonas Staudenmeir for extending relationships beyond two levels. * **Laravel Parental**: A tool for implementing single-table inheritance. * **Eloquent Cascade Soft Deletes**: Ensures child records are soft-deleted alongside their parents. Code Walkthrough: Polymorphic Relations Polymorphic relations allow a model to belong to more than one other type of model using a single set of columns. Instead of creating separate tables like `user_photos` and `task_photos`, you use a unified `photos` table. ```php Schema::create('photos', function (Blueprint $table) { $table->id(); $table->string('path'); $table->morphs('photoable'); // Creates photoable_id and photoable_type $table->timestamps(); }); ``` In your `Photo` model, define the relationship using `morphTo()`: ```php class Photo extends Model { public function photoable() { return $this->morphTo(); } } ``` In the parent models (e.g., `User` or `Task`), use `morphMany()`: ```php public function photos() { return $this->morphMany(Photo::class, 'photoable'); } ``` Syntax Notes Laravel uses the `morphs()` helper in migrations to automatically generate a string column for the model type and an unsigned big integer for the ID. For cleaner database entries, use `Relation::enforceMorphMap()` in your `AppServiceProvider` to map short strings (like 'user') to full class names. Practical Examples Use **Has Many Through** when you need to access distant relations. For instance, if a `Country` has many `Users`, and each `User` has many `Posts`, you can access all posts for a country directly without manual loops or complex joins. Use **Pivot Extra Fields** to store data like `is_active` or `timestamps` on a many-to-many link table by calling `withPivot('column')` in your relationship definition. Tips & Gotchas Soft deletes do not automatically cascade to related models in standard Eloquent. If you delete a parent, its children remain in the database unless you manually handle them or use a dedicated package. Always check the Laravel Debugbar to ensure your advanced relations aren't triggering the N+1 query problem.