25 запитань на співбесіді з Laravel та PHP у 2026 році

use App\Contracts\PaymentGateway;
use App\Services\StripePaymentGateway;

public function register(): void
{
    // Bind interface to concrete implementation
    $this->app->bind(PaymentGateway::class, StripePaymentGateway::class);

    // Singleton: resolved once, same instance reused
    $this->app->singleton(PaymentGateway::class, function ($app) {
        return new StripePaymentGateway(
            config('services.stripe.secret')
        );
    });
}

class OrderController extends Controller
{
    // Automatic injection via type-hinting
    public function __construct(
        private readonly PaymentGateway $payment
    ) {}

    public function store(Request $request): JsonResponse
    {
        $result = $this->payment->charge(
            $request->validated('amount')
        );

        return response()->json($result);
    }
}

class AnalyticsServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // register() - only bind things into the container
        $this->app->singleton(AnalyticsTracker::class, function ($app) {
            return new AnalyticsTracker(
                $app->make(HttpClient::class),
                config('analytics.key')
            );
        });
    }

    public function boot(): void
    {
        // boot() - all providers are registered, safe to use them
        $tracker = $this->app->make(AnalyticsTracker::class);
        $tracker->registerDefaultEvents();

        // Publish config for package users
        $this->publishes([
            __DIR__.'/../config/analytics.php' => config_path('analytics.php'),
        ]);
    }
}

// Simplified request lifecycle

// 1. public/index.php - Entry point
$app = require_once __DIR__.'/../bootstrap/app.php';

// 2. HTTP Kernel handles the request
$kernel = $app->make(Kernel::class);
$response = $kernel->handle(
    $request = Request::capture()
);

// 3. Inside Kernel: middleware pipeline
// Global middleware -> Route middleware -> Controller

// 4. Router matches the request
Route::get('/orders/{order}', [OrderController::class, 'show'])
    ->middleware(['auth', 'verified']);

// 5. Controller returns response
// 6. Response passes back through middleware
// 7. Response sent to browser
$response->send();
$kernel->terminate($request, $response);

// How facades work under the hood

// Using the Cache facade
Cache::put('user_123', $userData, 3600);

// Is equivalent to:
app('cache')->put('user_123', $userData, 3600);

// The facade class:
class Cache extends Facade
{
    protected static function getFacadeAccessor(): string
    {
        return 'cache'; // Key in the service container
    }
}

// Real-time facades - any class can become a facade
use Facades\App\Services\PaymentGateway;

PaymentGateway::charge(1000); // Resolves from container

class User extends Model
{
    // One-to-One: users.id -> profiles.user_id
    public function profile(): HasOne
    {
        return $this->hasOne(Profile::class);
    }

    // One-to-Many: users.id -> posts.user_id
    public function posts(): HasMany
    {
        return $this->hasMany(Post::class);
    }

    // Many-to-Many: users <-> role_user <-> roles
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Role::class)
            ->withPivot('assigned_at')
            ->withTimestamps();
    }
}

// Post.php
class Post extends Model
{
    // Inverse of hasMany
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

// Usage examples
$user = User::find(1);

// Lazy loading
$profile = $user->profile; // Single query
$posts = $user->posts; // Collection of posts

// Eager loading to avoid N+1
$users = User::with(['posts', 'roles'])->get();

// Querying relationships
$activeAuthors = User::whereHas('posts', function ($query) {
    $query->where('published', true)
          ->where('created_at', '>=', now()->subMonth());
})->get();

class Post extends Model
{
    // Local scope - called explicitly
    public function scopePublished(Builder $query): Builder
    {
        return $query->where('status', 'published')
                     ->whereNotNull('published_at');
    }

    public function scopeByAuthor(Builder $query, int $userId): Builder
    {
        return $query->where('user_id', $userId);
    }

    // Chainable scopes
    public function scopeRecent(Builder $query, int $days = 7): Builder
    {
        return $query->where('created_at', '>=', now()->subDays($days));
    }
}

// Usage: clean, readable queries
$posts = Post::published()
    ->recent(30)
    ->byAuthor($userId)
    ->paginate(15);

// Global Scope - applied to ALL queries on the model
class ActiveScope implements Scope
{
    public function apply(Builder $builder, Model $model): void
    {
        $builder->where('is_active', true);
    }
}

// In the model
class Subscription extends Model
{
    protected static function booted(): void
    {
        static::addGlobalScope(new ActiveScope());
    }
}

// All queries automatically filter active
Subscription::all(); // WHERE is_active = true

// Remove global scope when needed
Subscription::withoutGlobalScope(ActiveScope::class)->get();

class User extends Model
{
    // Automatic type casting
    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'preferences' => 'array',      // JSON <-> array
            'is_admin' => 'boolean',
            'salary' => 'decimal:2',
            'metadata' => AsCollection::class,
            'secret' => 'encrypted',        // Auto encrypt/decrypt
        ];
    }

    // Modern accessor (Laravel 9+)
    protected function fullName(): Attribute
    {
        return Attribute::make(
            get: fn () => "{$this->first_name} {$this->last_name}",
        );
    }

    // Accessor + Mutator combined
    protected function email(): Attribute
    {
        return Attribute::make(
            get: fn (string $value) => strtolower($value),
            set: fn (string $value) => strtolower(trim($value)),
        );
    }
}

// Custom Cast class for complex transformations
class MoneyCast implements CastsAttributes
{
    public function get(Model $model, string $key, mixed $value, array $attributes): Money
    {
        return new Money(
            amount: $attributes[$key],
            currency: $attributes['{$key}_currency'] ?? 'USD'
        );
    }

    public function set(Model $model, string $key, mixed $value, array $attributes): array
    {
        return [
            $key => $value->amount,
            "{$key}_currency" => $value->currency,
        ];
    }
}

// Usage in model
protected function casts(): array
{
    return [
        'price' => MoneyCast::class,
    ];
}

class EnsureUserIsSubscribed
{
    public function handle(Request $request, Closure $next): Response
    {
        if (!$request->user()?->isSubscribed()) {
            if ($request->expectsJson()) {
                return response()->json([
                    'message' => 'Subscription required.'
                ], 403);
            }

            return redirect()->route('subscribe');
        }

        return $next($request);
    }
}

// After middleware - runs after the response
class AddSecurityHeaders
{
    public function handle(Request $request, Closure $next): Response
    {
        $response = $next($request);

        $response->headers->set('X-Content-Type-Options', 'nosniff');
        $response->headers->set('X-Frame-Options', 'DENY');
        $response->headers->set('Strict-Transport-Security', 'max-age=31536000');

        return $response;
    }
}

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware) {
        // Global middleware
        $middleware->append(AddSecurityHeaders::class);

        // Named middleware for routes
        $middleware->alias([
            'subscribed' => EnsureUserIsSubscribed::class,
        ]);

        // Middleware groups
        $middleware->appendToGroup('api', [
            ThrottleRequests::class.':api',
        ]);
    })
    ->create();

// Usage in routes
Route::middleware('subscribed')->group(function () {
    Route::get('/premium', [PremiumController::class, 'index']);
});

// Route grouping with shared attributes
Route::prefix('admin')
    ->middleware(['auth', 'admin'])
    ->name('admin.')
    ->group(function () {
        Route::get('/dashboard', [AdminController::class, 'dashboard'])
            ->name('dashboard');

        // Resource controller: 7 RESTful routes
        Route::resource('articles', ArticleController::class);

        // API resource: excludes create/edit (no forms)
        Route::apiResource('categories', CategoryController::class);
    });

// Nested resources
Route::resource('posts.comments', CommentController::class)
    ->scoped()       // Auto scope bindings
    ->shallow();     // Shallow nesting for simplicity

// Route model binding with custom resolution
Route::get('/users/{user:username}', [UserController::class, 'show']);

class ArticleController extends Controller
{
    // GET /admin/articles
    public function index(): View { /* list */ }

    // GET /admin/articles/create
    public function create(): View { /* form */ }

    // POST /admin/articles
    public function store(StoreArticleRequest $request): RedirectResponse
    {
        $article = Article::create($request->validated());
        return redirect()->route('admin.articles.show', $article);
    }

    // GET /admin/articles/{article}
    public function show(Article $article): View { /* display */ }

    // GET /admin/articles/{article}/edit
    public function edit(Article $article): View { /* form */ }

    // PUT /admin/articles/{article}
    public function update(UpdateArticleRequest $request, Article $article): RedirectResponse
    {
        $article->update($request->validated());
        return redirect()->route('admin.articles.show', $article);
    }

    // DELETE /admin/articles/{article}
    public function destroy(Article $article): RedirectResponse
    {
        $article->delete();
        return redirect()->route('admin.articles.index');
    }
}

class ProcessPodcast implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;
    public int $backoff = 60; // seconds between retries
    public int $timeout = 120;

    public function __construct(
        private readonly Podcast $podcast
    ) {}

    public function handle(AudioProcessor $processor): void
    {
        $processed = $processor->process(
            $this->podcast->audio_path
        );

        $this->podcast->update([
            'processed_path' => $processed->path,
            'duration' => $processed->duration,
            'status' => 'ready',
        ]);
    }

    public function failed(\Throwable $exception): void
    {
        // Notify admin of failure
        $this->podcast->update(['status' => 'failed']);
        Log::error('Podcast processing failed', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage(),
        ]);
    }
}

// Dispatching jobs

// Basic dispatch
ProcessPodcast::dispatch($podcast);

// Delayed dispatch
ProcessPodcast::dispatch($podcast)
    ->delay(now()->addMinutes(10));

// Specific queue
ProcessPodcast::dispatch($podcast)
    ->onQueue('audio-processing');

// Job chaining - sequential execution
Bus::chain([
    new ProcessPodcast($podcast),
    new OptimizeAudio($podcast),
    new PublishPodcast($podcast),
])->dispatch();

// Job batching - parallel with completion tracking
Bus::batch([
    new ProcessChapter($podcast, 1),
    new ProcessChapter($podcast, 2),
    new ProcessChapter($podcast, 3),
])->then(function (Batch $batch) {
    Log::info('All chapters processed!');
})->catch(function (Batch $batch, Throwable $e) {
    Log::error('Batch failed: '.$e->getMessage());
})->dispatch();

class CallExternalApi implements ShouldQueue
{
    use Queueable;

    public function middleware(): array
    {
        return [
            // Max 10 jobs per minute for this API
            new ThrottlesExceptions(10, 5),

            // Rate limiting by key
            (new RateLimited('external-api'))
                ->dontRelease(), // Don't retry if rate limited

            // Prevent overlapping - only one at a time
            new WithoutOverlapping($this->userId),
        ];
    }

    public function handle(): void
    {
        // API call logic
    }

    public function retryUntil(): DateTime
    {
        return now()->addHours(1);
    }
}

// Define rate limiter in AppServiceProvider
RateLimiter::for('external-api', function (object $job) {
    return Limit::perMinute(30);
});

// Unique jobs - prevent duplicates in queue
class UpdateSearchIndex implements ShouldQueue, ShouldBeUnique
{
    use Queueable;

    // Unique for 1 hour
    public int $uniqueFor = 3600;

    public function uniqueId(): string
    {
        return $this->product->id;
    }

    public function handle(): void
    {
        // Only one job per product in queue at a time
    }
}

// CSRF Protection - automatic in forms
<form method="POST" action="/profile">
    @csrf  {{-- Generates hidden token field --}}
    @method('PUT')
    <input type="text" name="name" value="{{ $user->name }}">
    <button type="submit">Update</button>
</form>

// XSS Protection - Blade auto-escapes
{{ $userInput }}        {{-- Escaped: &lt;script&gt; --}}
{!! $trustedHtml !!}   {{-- Raw: use only for trusted content --}}

// SQL Injection Protection
// Safe - parameterized query
$users = User::where('email', $request->email)->get();
$users = DB::select('SELECT * FROM users WHERE email = ?', [$email]);

// DANGEROUS - raw unescaped input
$users = DB::select("SELECT * FROM users WHERE email = '$email'"); // NEVER DO THIS

// Mass Assignment Protection
class User extends Model
{
    // Only these fields can be mass-assigned
    protected $fillable = ['name', 'email', 'avatar'];

    // Or protect specific fields
    protected $guarded = ['is_admin', 'role'];
}

// Rate limiting for API protection
// bootstrap/app.php
$middleware->appendToGroup('api', [
    ThrottleRequests::class.':60,1',  // 60 requests per minute
]);

return [
    'defaults' => [
        'guard' => 'web',
    ],

    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'api' => [
            'driver' => 'sanctum',
            'provider' => 'users',
        ],
        'admin' => [
            'driver' => 'session',
            'provider' => 'admins',
        ],
    ],

    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
        'admins' => [
            'driver' => 'eloquent',
            'model' => App\Models\Admin::class,
        ],
    ],
];

// Authentication in controllers
class AuthController extends Controller
{
    public function login(LoginRequest $request): RedirectResponse
    {
        $credentials = $request->validated();

        if (Auth::attempt($credentials, $request->boolean('remember'))) {
            $request->session()->regenerate();
            return redirect()->intended('dashboard');
        }

        throw ValidationException::withMessages([
            'email' => __('auth.failed'),
        ]);
    }

    public function logout(Request $request): RedirectResponse
    {
        Auth::logout();
        $request->session()->invalidate();
        $request->session()->regenerateToken();

        return redirect('/');
    }
}

// Multi-guard authentication
Auth::guard('admin')->attempt($credentials);
Auth::guard('api')->user();

// AuthServiceProvider or AppServiceProvider boot()
Gate::define('manage-settings', function (User $user): bool {
    return $user->is_admin;
});

Gate::define('update-post', function (User $user, Post $post): bool {
    return $user->id === $post->user_id;
});

// Using gates
if (Gate::allows('manage-settings')) { /* ... */ }
Gate::authorize('update-post', $post); // Throws 403 if denied

class PostPolicy
{
    // Runs before all other checks
    public function before(User $user, string $ability): ?bool
    {
        if ($user->is_super_admin) {
            return true; // Bypass all checks
        }
        return null; // Fall through to specific method
    }

    public function view(User $user, Post $post): bool
    {
        return $post->published || $user->id === $post->user_id;
    }

    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }

    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id
            && $post->comments_count === 0;
    }
}

// Using policies in controllers
public function update(Request $request, Post $post): RedirectResponse
{
    $this->authorize('update', $post); // Auto-resolves PostPolicy

    $post->update($request->validated());
    return redirect()->route('posts.show', $post);
}

// In Blade templates
@can('update', $post)
    <a href="{{ route('posts.edit', $post) }}">Edit</a>
@endcan

class StoreArticleRequest extends FormRequest
{
    public function authorize(): bool
    {
        return $this->user()->can('create', Article::class);
    }

    public function rules(): array
    {
        return [
            'title' => ['required', 'string', 'max:255', 'unique:articles'],
            'slug' => ['required', 'string', 'regex:/^[a-z0-9-]+$/'],
            'body' => ['required', 'string', 'min:100'],
            'category_id' => ['required', 'exists:categories,id'],
            'tags' => ['array', 'max:5'],
            'tags.*' => ['string', 'max:30'],
            'publish_at' => ['nullable', 'date', 'after:now'],
            'cover_image' => ['nullable', 'image', 'max:2048', 'dimensions:min_width=800'],
        ];
    }

    public function messages(): array
    {
        return [
            'title.unique' => 'An article with this title already exists.',
            'body.min' => 'Article content must be at least 100 characters.',
        ];
    }

    // Transform data before validation
    protected function prepareForValidation(): void
    {
        $this->merge([
            'slug' => Str::slug($this->title),
        ]);
    }
}

// Custom validation rule
class StrongPassword implements ValidationRule
{
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (strlen($value) < 12) {
            $fail('The :attribute must be at least 12 characters.');
        }

        if (!preg_match('/[A-Z]/', $value)) {
            $fail('The :attribute must contain an uppercase letter.');
        }

        if (!preg_match('/[0-9]/', $value)) {
            $fail('The :attribute must contain a number.');
        }
    }
}

// Usage
'password' => ['required', new StrongPassword()],

// Conditional validation
$request->validate([
    'role' => 'required|in:user,admin',
    'admin_code' => 'required_if:role,admin|string',
    'company' => Rule::requiredIf($request->role === 'admin'),
]);

class ArticleTest extends TestCase
{
    use RefreshDatabase;

    public function test_user_can_create_article(): void
    {
        $user = User::factory()->create();

        $response = $this->actingAs($user)
            ->post('/articles', [
                'title' => 'Test Article',
                'body' => str_repeat('Content ', 20),
                'category_id' => Category::factory()->create()->id,
            ]);

        $response->assertRedirect();
        $this->assertDatabaseHas('articles', [
            'title' => 'Test Article',
            'user_id' => $user->id,
        ]);
    }

    public function test_guest_cannot_create_article(): void
    {
        $response = $this->post('/articles', [
            'title' => 'Test',
        ]);

        $response->assertRedirect('/login');
    }
}

// Same tests with Pest syntax
uses(RefreshDatabase::class);

it('allows authenticated users to create articles', function () {
    $user = User::factory()->create();

    $response = $this->actingAs($user)
        ->post('/articles', [
            'title' => 'Test Article',
            'body' => str_repeat('Content ', 20),
            'category_id' => Category::factory()->create()->id,
        ]);

    $response->assertRedirect();
    expect(Article::where('title', 'Test Article')->exists())->toBeTrue();
});

it('prevents guests from creating articles', function () {
    $this->post('/articles', ['title' => 'Test'])
        ->assertRedirect('/login');
});

// Testing with mocks
it('sends welcome email after registration', function () {
    Mail::fake();

    $this->post('/register', [
        'name' => 'John',
        'email' => 'john@example.com',
        'password' => 'SecurePass123!',
    ]);

    Mail::assertSent(WelcomeEmail::class, function ($mail) {
        return $mail->hasTo('john@example.com');
    });
});

class ArticleFactory extends Factory
{
    protected $model = Article::class;

    public function definition(): array
    {
        return [
            'user_id' => User::factory(),  // Auto-creates related user
            'category_id' => Category::factory(),
            'title' => fake()->sentence(),
            'slug' => fake()->slug(),
            'body' => fake()->paragraphs(5, true),
            'status' => 'draft',
            'published_at' => null,
        ];
    }

    // State methods for variations
    public function published(): static
    {
        return $this->state(fn (array $attributes) => [
            'status' => 'published',
            'published_at' => fake()->dateTimeBetween('-1 year'),
        ]);
    }

    public function withComments(int $count = 3): static
    {
        return $this->has(Comment::factory()->count($count));
    }
}

// Using factories in tests

// Single model
$article = Article::factory()->create();

// With specific attributes
$article = Article::factory()->published()->create([
    'title' => 'Specific Title',
]);

// With relationships
$user = User::factory()
    ->has(Article::factory()->count(5)->published())
    ->has(Article::factory()->count(2)) // drafts
    ->create();

// Complex seeder
class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        // Create admin
        User::factory()->create([
            'email' => 'admin@example.com',
            'is_admin' => true,
        ]);

        // Create users with articles
        User::factory(10)
            ->has(Article::factory()->count(rand(1, 10))->published())
            ->create();

        $this->call([
            CategorySeeder::class,
            TagSeeder::class,
        ]);
    }
}

interface ArticleRepositoryInterface
{
    public function findById(int $id): ?Article;
    public function findPublished(int $perPage = 15): LengthAwarePaginator;
    public function create(array $data): Article;
    public function update(int $id, array $data): Article;
    public function delete(int $id): bool;
}

// Repositories/EloquentArticleRepository.php
class EloquentArticleRepository implements ArticleRepositoryInterface
{
    public function __construct(
        private readonly Article $model
    ) {}

    public function findById(int $id): ?Article
    {
        return $this->model
            ->with(['author', 'category', 'tags'])
            ->find($id);
    }

    public function findPublished(int $perPage = 15): LengthAwarePaginator
    {
        return $this->model
            ->published()
            ->with(['author', 'category'])
            ->latest('published_at')
            ->paginate($perPage);
    }

    public function create(array $data): Article
    {
        return $this->model->create($data);
    }

    public function update(int $id, array $data): Article
    {
        $article = $this->model->findOrFail($id);
        $article->update($data);
        return $article->fresh();
    }

    public function delete(int $id): bool
    {
        return $this->model->findOrFail($id)->delete();
    }
}

// Bind in ServiceProvider
$this->app->bind(
    ArticleRepositoryInterface::class,
    EloquentArticleRepository::class
);

// Use in controller
class ArticleController extends Controller
{
    public function __construct(
        private readonly ArticleRepositoryInterface $articles
    ) {}

    public function index(): View
    {
        return view('articles.index', [
            'articles' => $this->articles->findPublished(),
        ]);
    }
}

class CreateArticleAction
{
    public function __construct(
        private readonly ImageUploader $uploader,
        private readonly SlugGenerator $slugs
    ) {}

    public function execute(User $author, array $data): Article
    {
        $slug = $this->slugs->generate($data['title']);

        $coverPath = isset($data['cover_image'])
            ? $this->uploader->upload($data['cover_image'], 'articles')
            : null;

        $article = $author->articles()->create([
            'title' => $data['title'],
            'slug' => $slug,
            'body' => $data['body'],
            'cover_image' => $coverPath,
            'category_id' => $data['category_id'],
            'status' => $data['publish'] ? 'published' : 'draft',
            'published_at' => $data['publish'] ? now() : null,
        ]);

        if (!empty($data['tags'])) {
            $article->tags()->sync($data['tags']);
        }

        if ($article->status === 'published') {
            event(new ArticlePublished($article));
        }

        return $article;
    }
}

// Usage in controller
class ArticleController extends Controller
{
    public function store(
        StoreArticleRequest $request,
        CreateArticleAction $action
    ): RedirectResponse {
        $article = $action->execute(
            $request->user(),
            $request->validated()
        );

        return redirect()->route('articles.show', $article);
    }
}

// Reusable in Artisan commands
class ImportArticleCommand extends Command
{
    protected $signature = 'articles:import {file}';

    public function handle(CreateArticleAction $action): int
    {
        $articles = json_decode(
            file_get_contents($this->argument('file')),
            true
        );

        foreach ($articles as $data) {
            $action->execute($this->getSystemUser(), $data);
        }

        return Command::SUCCESS;
    }
}

class OrderPlaced
{
    use SerializesModels;

    public function __construct(
        public readonly Order $order
    ) {}
}

// Listeners/SendOrderConfirmation.php
class SendOrderConfirmation implements ShouldQueue
{
    public function handle(OrderPlaced $event): void
    {
        Mail::to($event->order->user)
            ->send(new OrderConfirmationMail($event->order));
    }
}

// Listeners/UpdateInventory.php
class UpdateInventory
{
    public function handle(OrderPlaced $event): void
    {
        foreach ($event->order->items as $item) {
            $item->product->decrement('stock', $item->quantity);
        }
    }
}

// Listeners/NotifyWarehouse.php
class NotifyWarehouse implements ShouldQueue
{
    public function handle(OrderPlaced $event): void
    {
        Http::post('https://warehouse.api/orders', [
            'order_id' => $event->order->id,
            'items' => $event->order->items->toArray(),
        ]);
    }
}

// Event registration (EventServiceProvider or auto-discovery)
protected $listen = [
    OrderPlaced::class => [
        SendOrderConfirmation::class,
        UpdateInventory::class,
        NotifyWarehouse::class,
    ],
];

// Dispatching events
event(new OrderPlaced($order));

// Or using the static dispatch method
OrderPlaced::dispatch($order);

// Model observers - events for Eloquent models
class OrderObserver
{
    public function created(Order $order): void
    {
        event(new OrderPlaced($order));
    }

    public function updated(Order $order): void
    {
        if ($order->wasChanged('status')) {
            event(new OrderStatusChanged($order));
        }
    }
}

// N+1 Problem - 1 query for posts + N queries for authors
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Each access = 1 query
}
// Result: 1 + N queries (101 queries for 100 posts!)

// Solution: Eager Loading
$posts = Post::with('author')->get();  // 2 queries total

// Nested eager loading
$posts = Post::with([
    'author',
    'comments.user',  // Nested: comments AND their users
    'tags',
])->get();

// Conditional eager loading
$posts = Post::with(['comments' => function ($query) {
    $query->where('approved', true)
          ->latest()
          ->limit(5);
}])->get();