Laravel 12

Laravel 12 Development Skill

This skill provides comprehensive guidance for developing high-quality Laravel 12 applications using modern best practices, proper architecture patterns, and Laravel's streamlined structure.

Purpose

Provide expert-level Laravel 12 development guidance covering:

• Modern Laravel 12 streamlined architecture and file structure
• Eloquent ORM patterns with proper type hints and relationships
• Authentication and authorization using current best practices
• Form validation with Form Request classes
• Queue and job management for background processing
• Database migrations, models, and API development
• Testing patterns and conventions
• Configuration and environment management

When to Use

Use this skill when:

• Creating or working with Laravel 12 applications
• Building models, controllers, migrations, or any Laravel components
• Implementing authentication or authorization
• Creating APIs with Eloquent resources
• Writing database queries or working with relationships
• Setting up queues and background jobs
• Writing form validation
• Configuring Laravel applications
• Following Laravel best practices and conventions
• Ensuring proper Laravel 12 structure compliance

Core Principles

1. Use Artisan Commands

Always create files using php artisan make: commands with appropriate options:

# Models with migrations, factories, seeders
php artisan make:model Post -mfs

# Form Requests for validation
php artisan make:request StorePostRequest

# Controllers
php artisan make:controller PostController --resource

# Jobs
php artisan make:job ProcessPodcast

# Generic PHP classes
php artisan make:class Services/PaymentService

Important: Pass --no-interaction when running commands programmatically.

2. Follow Laravel 12 Streamlined Structure

Laravel 12 uses a simplified structure:

• No app/Http/Middleware/ directory - register middleware in bootstrap/app.php
• No app/Console/Kernel.php - use bootstrap/app.php or routes/console.php
• Commands auto-register from app/Console/Commands/
• Central configuration in bootstrap/app.php for middleware, routing, exceptions

Read references/structure.md for complete details on Laravel 12 architecture.

3. Authentication: Always Use $request->user()

CRITICAL: Always retrieve authenticated user via $request->user(), never use auth()->user() or Auth::user():

// ✅ CORRECT
public function index(Request $request): Response
{
    $user = $request->user();
    // ...
}

// ❌ WRONG
public function index(): Response
{
    $user = auth()->user();  // Don't do this
}

Read references/authentication.md for complete authentication and authorization guidance.

4. Database: Eloquent Over DB Facade

Prefer Eloquent models and relationships over raw queries:

// ✅ PREFER
$users = User::query()->where('active', true)->get();

// ❌ AVOID
$users = DB::table('users')->where('active', true)->get();

Prevent N+1 queries by eager loading relationships:

// ✅ GOOD - Prevents N+1
$posts = Post::with('user', 'comments')->get();

// ❌ BAD - Causes N+1
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name; // New query each iteration
}

Read references/database.md for Eloquent patterns, relationships, migrations, and query optimization.

5. Validation: Always Use Form Requests

Never use inline validation. Always create Form Request classes:

php artisan make:request StorePostRequest

Form Requests should include:

• Validation rules (check project conventions for array vs string format)
• Custom error messages
• Authorization logic when needed

public function rules(): array
{
    return [
        'title' => ['required', 'string', 'max:255'],
        'body' => ['required', 'string'],
    ];
}

Read references/validation.md for complete validation patterns and examples.

6. Configuration: Never Use env() Outside Config Files

// ❌ WRONG
$apiKey = env('API_KEY');

// ✅ CORRECT
$apiKey = config('services.api.key');

Environment variables should only be accessed in config/*.php files, then accessed via config() helper throughout the application.

7. Background Processing: Use Queues

Use queued jobs with ShouldQueue interface for time-consuming operations:

php artisan make:job ProcessPodcast

class ProcessPodcast implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public int $tries = 3;
    public int $timeout = 120;
    
    public function __construct(public Podcast $podcast) {}
    
    public function handle(): void
    {
        $this->podcast->process();
    }
}

Read references/queues.md for queue patterns, job chains, batches, and worker management.

Working with Models

Model Creation

When creating models, use appropriate flags:

# Model with migration, factory, seeder
php artisan make:model Post -mfs

# Model with migration, factory, seeder, policy, controller
php artisan make:model Post -mfsc --policy

Model Conventions

1. Use return type hints on relationships:

public function posts(): HasMany
{
    return $this->hasMany(Post::class);
}

2. Use casts() method for type casting:

protected function casts(): array
{
    return [
        'published_at' => 'datetime',
        'is_featured' => 'boolean',
        'metadata' => 'array',
    ];
}

3. Use constructor property promotion:

public function __construct(
    public string $name,
    public int $age,
) {}

Working with Controllers

1. Type-hint Request in controller methods
2. Use resource controllers for CRUD operations
3. Return proper response types with type hints
4. Use Form Requests for validation
5. Keep controllers thin - move business logic to services/actions

public function store(StorePostRequest $request): RedirectResponse
{
    $post = Post::create($request->validated());
    
    return redirect()->route('posts.show', $post);
}

API Development

Use Eloquent API Resources for consistent API responses:

php artisan make:resource PostResource

class PostResource extends JsonResource
{
    public function toArray($request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'author' => new UserResource($this->whenLoaded('user')),
        ];
    }
}

Migrations

CRITICAL: When modifying columns, include ALL previous attributes or they will be lost:

// ❌ WRONG - Loses 'nullable' attribute
$table->string('email')->unique()->change();

// ✅ CORRECT - Preserves all attributes
$table->string('email')->nullable()->unique()->change();

Reference Files

This skill includes detailed reference files for specific topics:

• references/structure.md - Laravel 12 file structure, Artisan commands, configuration
• references/authentication.md - Authentication, authorization, policies, gates
• references/database.md - Eloquent, relationships, migrations, queries, API resources
• references/validation.md - Form Requests, validation rules, custom messages
• references/queues.md - Jobs, queues, workers, chains, batches

Read the appropriate reference file(s) when working on related tasks to ensure following best practices.

PHP Conventions

1. Always use curly braces for control structures, even single-line
2. Use explicit return type declarations for all methods
3. Use PHP 8+ constructor property promotion
4. Use type hints for method parameters
5. Prefer PHPDoc blocks over inline comments

protected function isAccessible(User $user, ?string $path = null): bool
{
    // Implementation
}

Best Practices Summary

1. ✅ Use php artisan make: commands to create files
2. ✅ Follow Laravel 12 streamlined structure
3. ✅ Always use $request->user() for authentication
4. ✅ Prefer Eloquent over DB facade
5. ✅ Always create Form Request classes for validation
6. ✅ Never use env() outside config files
7. ✅ Use queues for time-consuming operations
8. ✅ Add return type hints on relationships
9. ✅ Eager load to prevent N+1 queries
10. ✅ Include all attributes when modifying columns
11. ✅ Use named routes with route() helper
12. ✅ Use API Resources for APIs
13. ✅ Keep controllers thin
14. ✅ Write descriptive, type-safe code

Common Tasks Workflow

Creating a New Resource

1. Create model with migrations and factory: php artisan make:model Post -mf
2. Create Form Requests: php artisan make:request StorePostRequest
3. Create controller: php artisan make:controller PostController --resource
4. Create API resource (if needed): php artisan make:resource PostResource
5. Define routes in appropriate routes file with named routes
6. Write tests for all functionality

Adding Authentication to Routes

1. Use middleware in route definition or bootstrap/app.php
2. Access user via $request->user()
3. Use policies for authorization
4. Return appropriate responses for unauthorized access

This skill ensures Laravel applications follow modern best practices, maintain clean architecture, and leverage Laravel 12's streamlined structure effectively.

Converted and distributed by TomeVault — claim your Tome and manage your conversions.