Part 2: Laravel 13 Core Internals: Service Container, Pipelines & Terminating Middleware

<?php

declare(strict_types=1);

namespace App\Providers;

use App\Contracts\PaymentGatewayInterface;
use App\Services\StripePaymentGateway;
use App\Services\PayPalPaymentGateway;
use App\Http\Controllers\CheckoutController;
use App\Http\Controllers\SubscriptionController;
use Illuminate\Support\ServiceProvider;

class PaymentServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // 1. Contextual Binding: Deliver different implementations based on requesting class
        $this->app->when(CheckoutController::class)
            ->needs(PaymentGatewayInterface::class)
            ->give(function () {
                return new StripePaymentGateway(config('services.stripe.secret'));
            });

        $this->app->when(SubscriptionController::class)
            ->needs(PaymentGatewayInterface::class)
            ->give(PayPalPaymentGateway::class);

        // 2. Scoped Binding: Safely isolated per Octane HTTP request
        $this->app->scoped(\App\Support\TenantContext::class, function () {
            return new \App\Support\TenantContext();
        });
    }
}

<?php

// Conceptual implementation of Laravel's Illuminate\Pipeline\Pipeline:
$pipes = [
    EnsureUserIsAuthenticated::class,
    VerifyCsrfToken::class,
    ThrottleApiRequests::class,
];

$response = (new Pipeline($container))
    ->send($request)
    ->through($pipes)
    ->then(function ($request) {
        // Core Destination: Route Controller action
        return $controller->handle($request);
    });

<?php

declare(strict_types=1);

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
use Illuminate\Support\Facades\DB;

class LogApiTelemetryMiddleware
{
    private float $startTime;

    public function handle(Request $request, Closure $next): Response
    {
        $this->startTime = microtime(true);
        // Process request normally:
        return $next($request);
    }

    /**
     * Executes AFTER HTTP response bytes are already flushed to client browser!
     */
    public function terminate(Request $request, Response $response): void
    {
        $durationMs = (microtime(true) - $this->startTime) * 1000;

        // Non-blocking database audit log write:
        DB::table('api_telemetry_logs')->insert([
            'ip' => $request->ip(),
            'method' => $request->method(),
            'path' => $request->path(),
            'status_code' => $response->getStatusCode(),
            'duration_ms' => round($durationMs, 2),
            'created_at' => now(),
        ]);
    }
}

<?php

use Illuminate\Support\Facades\Context;
use Illuminate\Support\Facades\Log;

// Middleware captures distributed tracing header:
Context::add('trace_id', $request->header('X-Trace-Id', (string) Str::uuid()));
Context::add('actor_id', auth()->id());

// All subsequent Log calls automatically append trace_id and actor_id to JSON logs!
Log::info('Order checkout initiated.', ['order_total' => 4500]);

<?php

public function registerUser(UserRegistrationRequest $request)
{
    $user = User::create($request->validated());

    // Execute heavy webhook and notification after the 201 response is delivered!
    defer(fn () => dispatch(new SendWelcomeEmailJob($user->id)));

    return response()->json(['message' => 'User created successfully'], 201);
}

<?php

declare(strict_types=1);

namespace App\Providers;

use App\Contracts\TenantStorageInterface;
use App\Services\S3TenantStorage;
use App\Services\LocalEncryptedStorage;
use App\Http\Controllers\EnterpriseUploadController;
use App\Http\Controllers\StandardUploadController;
use Illuminate\Support\ServiceProvider;

class MultiTenantStorageServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->when(EnterpriseUploadController::class)
            ->needs(TenantStorageInterface::class)
            ->give(function () {
                $tenant = request()->attributes->get('tenant');
                return new S3TenantStorage($tenant->s3_bucket, $tenant->kms_key);
            });

        $this->app->when(StandardUploadController::class)
            ->needs(TenantStorageInterface::class)
            ->give(LocalEncryptedStorage::class);
    }
}

<?php

// App\Models\Blog.php
public function resolveRouteBinding($value, $field = null)
{
    // Enforce multi-tenant scoping and visibility boundaries automatically:
    return $this->where($field ?? 'slug', $value)
        ->where('is_published', true)
        ->with(['series', 'categories'])
        ->firstOrFail();
}

<?php

// Pessimistic Locking: Acquires exclusive row lock (SELECT ... FOR UPDATE)
DB::transaction(function () use ($ticketId) {
    $ticket = DB::table('concert_tickets')
        ->where('id', $ticketId)
        ->where('status', 'available')
        ->lockForUpdate()
        ->first();

    if (! $ticket) {
        throw new TicketUnavailableException('Ticket is already claimed.');
    }

    DB::table('concert_tickets')->where('id', $ticketId)->update([
        'status' => 'reserved',
        'reserved_until' => now()->addMinutes(10),
    ]);
});

<?php

// Optimistic Locking: Compares version column on UPDATE without blocking reads!
$item = DB::table('products')->where('id', $productId)->first();

$updated = DB::table('products')
    ->where('id', $productId)
    ->where('version', $item->version) // Invariant check!
    ->update([
        'price' => $newPrice,
        'version' => $item->version + 1, // Atomic increment
    ]);

if ($updated === 0) {
    // Conflict detected: another process modified the product concurrently!
    throw new ConcurrentModificationException('Product was updated by another administrator. Please refresh.');
}