Preguntas de entrevista de PHP y Laravel — 50 con código y respuestas

<?php
declare(strict_types=1);

function sumar(int $a, int $b): int {
    return $a + $b;
}

sumar(2, "3"); // TypeError: Argument #2 must be of type int, string given

<?php

enum Estado: string {
    case Pendiente = 'pendiente';
    case Activo    = 'activo';
    case Cerrado   = 'cerrado';
}

// Uso en una clase
class Ticket {
    public function __construct(
        public readonly Estado $estado = Estado::Pendiente
    ) {}
}

$ticket = new Ticket();
echo $ticket->estado->value; // pendiente

// Comparación segura
if ($ticket->estado === Estado::Activo) {
    // ...
}

<?php

$fiber = new Fiber(function(): void {
    $valor = Fiber::suspend('primer suspend');
    echo "Fiber recibió: {$valor}\n";
});

$resultado = $fiber->start();
echo "Main recibió: {$resultado}\n"; // Main recibió: primer suspend

$fiber->resume('hola desde main');
// Fiber recibió: hola desde main

<?php

class Usuario {
    public function __construct(
        public readonly int    $id,
        public readonly string $email,
    ) {}
}

$u = new Usuario(id: 1, email: 'juan@ejemplo.com');
$u->email = 'otro@ejemplo.com'; // Error: Cannot modify readonly property

<?php

readonly class PedidoDTO {
    public function __construct(
        public int    $id,
        public string $producto,
        public float  $precio,
    ) {}
}

<?php

$codigo = 200;

$mensaje = match($codigo) {
    200, 201 => 'Éxito',
    400      => 'Petición inválida',
    404      => 'No encontrado',
    500      => 'Error del servidor',
    default  => 'Código desconocido',
};

echo $mensaje; // Éxito

<?php

// Antes
$ciudad = null;
if ($usuario !== null && $usuario->perfil !== null) {
    $ciudad = $usuario->perfil->ciudad;
}

// Con nullsafe
$ciudad = $usuario?->perfil?->ciudad;

<?php

trait Timestampable {
    private \DateTimeImmutable $creadoEn;
    private \DateTimeImmutable $actualizadoEn;

    public function setCreadoEn(): void {
        $this->creadoEn = new \DateTimeImmutable();
    }

    public function getCreadoEn(): \DateTimeImmutable {
        return $this->creadoEn;
    }
}

class Producto {
    use Timestampable;
    // ...
}

class Entrada {
    use Timestampable;
    // ...
}

<?php

interface Exportable {
    public function exportar(): string;
}

abstract class DocumentoBase implements Exportable {
    abstract protected function contenido(): string;

    public function exportar(): string {
        return "<doc>" . $this->contenido() . "</doc>";
    }
}

class Factura extends DocumentoBase {
    protected function contenido(): string {
        return "Datos de factura";
    }
}

<?php

// Union type: acepta int O string
function procesar(int|string $valor): void {
    echo $valor;
}

// Intersection type (PHP 8.1): debe implementar AMBAS interfaces
function guardar(Exportable&Serializable $obj): void {
    // ...
}

<?php

class Animal {}
class Perro extends Animal {}

class Repositorio {
    public function encontrar(int $id): Animal {
        return new Animal();
    }
}

class RepositorioPerros extends Repositorio {
    // Covariante: devuelve un tipo más específico (Perro extends Animal)
    public function encontrar(int $id): Perro {
        return new Perro();
    }
}

<?php

// Binding en un ServiceProvider
public function register(): void
{
    $this->app->bind(
        \App\Contracts\MailerInterface::class,
        \App\Services\SendgridMailer::class
    );
}

// En un controlador
class UserController extends Controller {
    public function __construct(
        private readonly MailerInterface $mailer
    ) {}
}
// Laravel inyecta SendgridMailer automáticamente

<?php

// bind: nueva instancia cada vez que se resuelve
$this->app->bind(Logger::class, FileLogger::class);

// singleton: misma instancia en toda la request
$this->app->singleton(Cache::class, RedisCache::class);

// instance: registrás un objeto ya creado
$logger = new FileLogger('/var/log/app.log');
$this->app->instance(Logger::class, $logger);

<?php

// Así está implementada la Facade de Cache
class Cache extends Facade {
    protected static function getFacadeAccessor(): string {
        return 'cache'; // clave en el container
    }
}

// Vos llamás:
Cache::get('usuarios');

// Laravel hace internamente:
app('cache')->get('usuarios');

<?php

// Con inyección: las dependencias son visibles en el constructor
class PedidoService {
    public function __construct(
        private readonly MailerInterface   $mailer,
        private readonly PedidoRepository $repo,
    ) {}
}

// En el test:
$mailer = Mockery::mock(MailerInterface::class);
$mailer->shouldReceive('enviar')->once();
$service = new PedidoService($mailer, $this->repo);

<?php

class PagosServiceProvider extends ServiceProvider {
    public function register(): void {
        $this->app->singleton(GatewayInterface::class, function ($app) {
            return new MercadoPagoGateway(
                config('pagos.mercadopago_key'),
                config('pagos.mercadopago_secret'),
            );
        });
    }

    public function boot(): void {
        $this->publishes([
            __DIR__.'/../config/pagos.php' => config_path('pagos.php'),
        ]);
    }
}

<?php

// MAL — problema N+1: 1 query para posts + N queries para autores
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->autor->nombre; // query por cada post
}

// BIEN — eager loading: 2 queries en total
$posts = Post::with('autor')->get();
foreach ($posts as $post) {
    echo $post->autor->nombre; // sin queries adicionales
}

// Con múltiples relaciones
$posts = Post::with(['autor', 'etiquetas', 'comentarios.usuario'])->get();

<?php

// En AppServiceProvider::boot()
// Solo en desarrollo:
if (app()->isLocal()) {
    DB::listen(function ($query) {
        if ($query->time > 100) {
            logger()->warning('Query lenta', ['sql' => $query->sql]);
        }
    });
}

<?php

class Usuario extends Model {
    // Un usuario tiene un perfil (1:1)
    public function perfil(): HasOne {
        return $this->hasOne(Perfil::class);
    }

    // Un usuario tiene muchos posts (1:N)
    public function posts(): HasMany {
        return $this->hasMany(Post::class);
    }

    // Un usuario tiene muchos roles (N:M)
    public function roles(): BelongsToMany {
        return $this->belongsToMany(Rol::class, 'usuario_rol');
    }
}

class Post extends Model {
    // Un post pertenece a un usuario
    public function usuario(): BelongsTo {
        return $this->belongsTo(Usuario::class);
    }
}

<?php

class Post extends Model {
    // Scope global: se aplica SIEMPRE a todas las queries del modelo
    protected static function booted(): void {
        static::addGlobalScope('publicado', function (Builder $builder) {
            $builder->where('estado', 'publicado');
        });
    }

    // Scope local: se aplica cuando lo pedís explícitamente
    public function scopeRecientes(Builder $query): void {
        $query->orderBy('created_at', 'desc')->limit(10);
    }

    public function scopePorAutor(Builder $query, int $autorId): void {
        $query->where('usuario_id', $autorId);
    }
}

// Uso de scopes locales
$posts = Post::recientes()->porAutor(5)->get();

// Ignorar global scope
$todos = Post::withoutGlobalScope('publicado')->get();

<?php

class PedidoObserver {
    public function created(Pedido $pedido): void {
        // Enviar email de confirmación
        Mail::to($pedido->usuario->email)
            ->queue(new PedidoConfirmado($pedido));
    }

    public function updated(Pedido $pedido): void {
        if ($pedido->wasChanged('estado')) {
            Cache::forget("pedido_{$pedido->id}");
        }
    }

    public function deleted(Pedido $pedido): void {
        $pedido->items()->delete();
    }
}

// En AppServiceProvider o en el Model con $dispatchesEvents
Pedido::observe(PedidoObserver::class);

<?php

// withCount: trae el conteo de relaciones sin cargarlas
$categorias = Categoria::withCount('productos')->get();
echo $categorias[0]->productos_count; // 42

// withSum, withAvg, withMin, withMax
$usuarios = Usuario::withSum('pedidos', 'total')->get();
echo $usuarios[0]->pedidos_sum_total; // 15000.00

// loadAggregate en instancias ya cargadas
$categoria->loadCount('productos');

<?php

// updateOrCreate: una query SELECT + una INSERT o UPDATE
// Útil para un registro a la vez
$producto = Producto::updateOrCreate(
    ['sku' => 'ABC-123'],
    ['nombre' => 'Auriculares', 'precio' => 9999]
);

// upsert: una sola query, ideal para bulk operations
Producto::upsert(
    [
        ['sku' => 'ABC-123', 'nombre' => 'Auriculares', 'precio' => 9999],
        ['sku' => 'DEF-456', 'nombre' => 'Teclado', 'precio' => 5499],
    ],
    uniqueBy: ['sku'],
    update: ['nombre', 'precio']
);

<?php

// Migración segura para tabla grande en producción
public function up(): void
{
    // Agregar la columna primero como nullable
    Schema::table('pedidos', function (Blueprint $table) {
        $table->string('referencia_externa')->nullable()->after('id');
    });

    // Poblar los datos en chunks para no lockear la tabla
    Pedido::whereNull('referencia_externa')
        ->chunkById(1000, function ($pedidos) {
            foreach ($pedidos as $pedido) {
                $pedido->update([
                    'referencia_externa' => 'REF-' . $pedido->id
                ]);
            }
        });

    // Agregar índice y constraint
    Schema::table('pedidos', function (Blueprint $table) {
        $table->string('referencia_externa')->nullable(false)->change();
        $table->unique('referencia_externa');
    });
}

<?php

class ProductoSeeder extends Seeder {
    public function run(): void
    {
        // DELETE respeta foreign keys pero es más lento (logs de transacción)
        Producto::query()->delete();

        // TRUNCATE es más rápido pero falla si hay FK sin deshabilitar
        DB::statement('SET FOREIGN_KEY_CHECKS=0;');
        Producto::truncate();
        DB::statement('SET FOREIGN_KEY_CHECKS=1;');

        // Inserción masiva eficiente
        $productos = collect(range(1, 100))->map(fn($i) => [
            'nombre'     => "Producto {$i}",
            'precio'     => fake()->randomFloat(2, 100, 9999),
            'created_at' => now(),
            'updated_at' => now(),
        ])->all();

        Producto::insert($productos); // Una sola query
    }
}

# Rollback de la última batch
php artisan migrate:rollback

# Rollback de N pasos
php artisan migrate:rollback --step=3

# Ver el estado de migraciones
php artisan migrate:status

# En tests, usá RefreshDatabase que hace rollback automático

<?php

class EnviarEmailBienvenida implements ShouldQueue {
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;
    public int $backoff = 60; // segundos entre reintentos

    public function __construct(
        private readonly Usuario $usuario
    ) {}

    public function handle(MailerInterface $mailer): void
    {
        $mailer->enviar(
            new EmailBienvenida($this->usuario)
        );
    }

    public function failed(\Throwable $exception): void
    {
        // Se llama cuando se agotaron los reintentos
        logger()->error('Falló envío de email', [
            'usuario_id' => $this->usuario->id,
            'error'      => $exception->getMessage(),
        ]);

        // Podés notificar al equipo acá
    }

    public function retryUntil(): \DateTime
    {
        // Reintentar por no más de 24hs
        return now()->addHours(24);
    }
}

// Despachar
EnviarEmailBienvenida::dispatch($usuario);

// Con delay
EnviarEmailBienvenida::dispatch($usuario)->delay(now()->addMinutes(10));

// En una queue específica
EnviarEmailBienvenida::dispatch($usuario)->onQueue('emails');

<?php

// ShouldQueueAfterCommit: el job no se encola hasta que la transacción DB
// se confirme. Evita el race condition donde el job se ejecuta antes
// de que los datos estén en la base.

class NotificarNuevoPedido implements ShouldQueue, ShouldQueueAfterCommit {
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(private Pedido $pedido) {}

    public function handle(): void
    {
        // Garantizado: el pedido ya está commiteado en DB
        $this->pedido->refresh();
        // ...
    }
}

<?php

use Illuminate\Bus\Batch;
use Illuminate\Support\Facades\Bus;

$batch = Bus::batch([
    new ProcesarImagen($imagen1),
    new ProcesarImagen($imagen2),
    new ProcesarImagen($imagen3),
])->then(function (Batch $batch) {
    // Todos completaron OK
    logger('Procesamiento completo');
})->catch(function (Batch $batch, \Throwable $e) {
    // Al menos uno falló
    logger()->error('Error en batch', ['error' => $e->getMessage()]);
})->finally(function (Batch $batch) {
    // Se ejecuta siempre, independientemente del resultado
})->dispatch();

echo $batch->id; // UUID del batch, podés usarlo para tracking

<?php

class VerificarSuscripcion {
    public function handle(Request $request, Closure $next): Response
    {
        $usuario = $request->user();

        if (!$usuario || !$usuario->suscripcion?->activa()) {
            // Terminar la request antes de llegar al controlador
            return response()->json([
                'mensaje' => 'Suscripción requerida',
                'codigo'  => 'SUBSCRIPTION_REQUIRED',
            ], 402);
        }

        return $next($request);
    }
}

// Registrar en bootstrap/app.php (Laravel 11+)
->withMiddleware(function (Middleware $middleware) {
    $middleware->alias([
        'suscripcion' => VerificarSuscripcion::class,
    ]);
})

// Uso en rutas
Route::get('/premium', PremiumController::class)
    ->middleware('suscripcion');

<?php

// Agrupar middleware para APIs
->withMiddleware(function (Middleware $middleware) {
    $middleware->group('api-privada', [
        'auth:sanctum',
        'suscripcion',
        \Illuminate\Routing\Middleware\ThrottleRequests::class . ':60,1',
    ]);
})

// En rutas
Route::middleware('api-privada')->group(function () {
    Route::get('/reportes', ReportesController::class);
    Route::get('/exportar', ExportarController::class);
});

<?php

// Gate: para acciones de aplicación (no CRUD de un modelo)
Gate::define('acceder-panel-admin', function (Usuario $usuario) {
    return $usuario->rol === 'admin';
});

// Uso
if (Gate::allows('acceder-panel-admin')) {
    // ...
}

// Policy: para CRUD de un modelo
class PostPolicy {
    public function update(Usuario $usuario, Post $post): bool
    {
        return $usuario->id === $post->usuario_id;
    }

    public function delete(Usuario $usuario, Post $post): bool
    {
        return $usuario->id === $post->usuario_id
            || $usuario->rol === 'admin';
    }
}

// Registrar (Laravel auto-descubre si seguís la convención)
Gate::policy(Post::class, PostPolicy::class);

// Uso en controlador
$this->authorize('update', $post);

// Uso en Blade
@can('update', $post)
    <button>Editar</button>
@endcan

<?php

class PostPolicy {
    // Antes de cualquier método de la policy, el "before" tiene prioridad
    public function before(Usuario $usuario, string $ability): bool|null
    {
        if ($usuario->esAdmin()) {
            return true; // Admin puede todo
        }

        return null; // null significa "seguir evaluando la policy"
    }

    public function viewAny(Usuario $usuario): bool
    {
        return true; // Cualquier usuario puede listar
    }

    public function create(Usuario $usuario): bool
    {
        return $usuario->suscripcion?->activa() ?? false;
    }

    public function update(Usuario $usuario, Post $post): bool
    {
        return $usuario->id === $post->usuario_id;
    }
}

<?php
// PHPUnit style
class PostTest extends TestCase {
    public function test_un_usuario_puede_crear_un_post(): void
    {
        $usuario = Usuario::factory()->create();
        $response = $this->actingAs($usuario)
            ->postJson('/api/posts', ['titulo' => 'Mi post', 'contenido' => '...']);
        $response->assertStatus(201);
        $this->assertDatabaseHas('posts', ['titulo' => 'Mi post']);
    }
}

// Pest style — mismo test, más legible
it('permite a un usuario crear un post', function () {
    $usuario = Usuario::factory()->create();

    actingAs($usuario)
        ->postJson('/api/posts', ['titulo' => 'Mi post', 'contenido' => '...'])
        ->assertStatus(201);

    assertDatabaseHas('posts', ['titulo' => 'Mi post']);
});

<?php

it('envía email al crear un pedido', function () {
    // Fake del mailer: intercepta todos los emails sin enviarlos
    Mail::fake();

    $usuario = Usuario::factory()->create();
    $response = actingAs($usuario)
        ->postJson('/api/pedidos', ['producto_id' => 1]);

    $response->assertStatus(201);

    // Verificar que se envió el email correcto
    Mail::assertSent(PedidoConfirmado::class, function ($mail) use ($usuario) {
        return $mail->hasTo($usuario->email);
    });
});

it('encola el job de procesamiento', function () {
    Queue::fake();

    actingAs(Usuario::factory()->create())
        ->postJson('/api/importar', ['archivo' => 'datos.csv'])
        ->assertAccepted();

    Queue::assertPushed(ProcesarImportacion::class);
});

<?php

class UsuarioFactory extends Factory {
    public function definition(): array {
        return [
            'nombre' => fake()->name(),
            'email'  => fake()->unique()->safeEmail(),
            'estado' => 'activo',
        ];
    }

    public function inactivo(): static {
        return $this->state(['estado' => 'inactivo']);
    }

    public function admin(): static {
        return $this->state(['rol' => 'admin']);
    }

    public function conSuscripcion(): static {
        return $this->has(
            Suscripcion::factory()->activa(),
            'suscripcion'
        );
    }
}

// En tests
$admin = Usuario::factory()->admin()->conSuscripcion()->create();
$inactivos = Usuario::factory()->inactivo()->count(5)->create();

<?php

// RefreshDatabase: ejecuta las migrations en cada test suite
// Más lento pero garantiza un estado limpio
uses(RefreshDatabase::class);

// DatabaseTransactions: envuelve cada test en una transacción
// y hace rollback al terminar. Más rápido pero no funciona
// con jobs o código que corre fuera de la transacción
uses(DatabaseTransactions::class);

// Para tests de API rápidos, preferí DatabaseTransactions
// Para tests con queues o eventos, usá RefreshDatabase

<?php

it('el comando de limpieza elimina registros viejos', function () {
    // Crear datos de prueba
    $viejos = Pedido::factory()
        ->count(5)
        ->create(['created_at' => now()->subDays(90)]);

    $recientes = Pedido::factory()
        ->count(3)
        ->create(['created_at' => now()]);

    // Correr el comando
    $this->artisan('pedidos:limpiar --dias=60')
         ->assertExitCode(0)
         ->expectsOutput('5 pedidos eliminados.');

    // Verificar resultado
    expect(Pedido::count())->toBe(3);
});

<?php

// MAL: carga objetos completos cuando solo necesitás ciertos campos
$usuarios = Usuario::all();

// BIEN: solo los campos necesarios
$usuarios = Usuario::select(['id', 'nombre', 'email'])->get();

// Para queries de reporte, usá Query Builder directo (sin hidratación)
$reporte = DB::table('pedidos')
    ->selectRaw('DATE(created_at) as fecha, COUNT(*) as total, SUM(monto) as facturacion')
    ->where('estado', 'completado')
    ->whereBetween('created_at', [$inicio, $fin])
    ->groupBy('fecha')
    ->orderBy('fecha')
    ->get();

// Para grandes volúmenes, usá cursor() o chunk()
Pedido::where('estado', 'pendiente')
    ->cursor() // Usa generators, muy eficiente en memoria
    ->each(function (Pedido $pedido) {
        // Procesar uno a la vez
    });

<?php

class ReporteService {
    public function getTopProductos(): Collection
    {
        return Cache::remember('top-productos', ttl: 3600, function () {
            return Producto::withCount('ventas')
                ->orderByDesc('ventas_count')
                ->limit(10)
                ->get();
        });
    }

    // Cache por usuario (cache tagging)
    public function getDashboard(int $usuarioId): array
    {
        return Cache::tags(["usuario:{$usuarioId}", 'dashboard'])
            ->remember("dashboard:{$usuarioId}", 300, function () use ($usuarioId) {
                return [
                    'pedidos'   => $this->contarPedidos($usuarioId),
                    'facturas'  => $this->sumarFacturas($usuarioId),
                ];
            });
    }

    // Invalidar cache cuando cambian los datos
    public function actualizarPedido(Pedido $pedido): void
    {
        $pedido->save();
        Cache::tags(["usuario:{$pedido->usuario_id}", 'dashboard'])->flush();
    }
}

<?php

// Asegurate de que los campos en WHERE tengan índices en la migración
Schema::create('pedidos', function (Blueprint $table) {
    $table->id();
    $table->foreignId('usuario_id')->constrained()->index();
    $table->string('estado', 20)->index();
    $table->timestamp('created_at')->index();

    // Índice compuesto para queries frecuentes
    $table->index(['estado', 'created_at']);
    $table->index(['usuario_id', 'estado']);
});

// Scope que aprovecha el índice compuesto
public function scopePendientesRecientes(Builder $query): void
{
    $query->where('estado', 'pendiente')
          ->where('created_at', '>=', now()->subDays(7))
          ->orderBy('created_at', 'desc');
}

<?php

class ReportingServiceProvider extends ServiceProvider {
    // Solo registrar cuando realmente se necesite
    public function register(): void
    {
        $this->app->bind(ReportGenerator::class, function ($app) {
            // Esta closure solo se ejecuta cuando alguien resuelve ReportGenerator
            // No cuando la app hace bootstrap
            return new ReportGenerator(
                config('reporting.driver'),
                new ReportCache($app->make(Cache::class))
            );
        });
    }
}

<?php

// dd(): dump and die — para debug rápido, bloquea la ejecución
dd($variable, $otraVariable);

// dump(): muestra sin cortar la ejecución
dump($variable);
$resultado = hacerAlgo(); // esto sí se ejecuta

// ray() (paquete spatie/ray): envía a la app Ray, no interfiere con la respuesta
// Ideal para debugging en APIs donde dd() rompe el JSON
ray($variable)->label('mi variable');
ray()->measure(); // timing

// logger() para logging permanente
logger()->debug('Debug info', ['data' => $variable]);

# Generar classmap optimizado (1 archivo, sin filesystem lookups)
composer install --optimize-autoloader --no-dev

# Equivalente manual
composer dump-autoload --optimize --no-dev

# En el pipeline de CI/CD, siempre usar:
composer install --no-interaction --no-dev --prefer-dist --optimize-autoloader

<?php

// Definir el evento
class PedidoCreado {
    public function __construct(
        public readonly Pedido $pedido
    ) {}
}

// Listener
class EnviarEmailConfirmacion {
    public function handle(PedidoCreado $evento): void
    {
        Mail::to($evento->pedido->usuario->email)
            ->queue(new PedidoConfirmado($evento->pedido));
    }
}

// Registrar en EventServiceProvider (o con atributos PHP 8)
protected $listen = [
    PedidoCreado::class => [
        EnviarEmailConfirmacion::class,
        ActualizarInventario::class,
        NotificarVendedor::class,
    ],
];

// Disparar el evento
event(new PedidoCreado($pedido));
// o desde el modelo
PedidoCreado::dispatch($pedido);

<?php

class CrearPedidoRequest extends FormRequest {
    public function authorize(): bool
    {
        // Lógica de autorización aquí (no en el controlador)
        return $this->user()->puedeCrearPedidos();
    }

    public function rules(): array
    {
        return [
            'producto_id'    => ['required', 'integer', 'exists:productos,id'],
            'cantidad'       => ['required', 'integer', 'min:1', 'max:100'],
            'direccion_id'   => ['required', 'integer', 'exists:direcciones,id'],
        ];
    }

    public function messages(): array
    {
        return [
            'producto_id.exists' => 'El producto seleccionado no existe.',
            'cantidad.max'       => 'No podés pedir más de :max unidades.',
        ];
    }
}

// En el controlador: solo lógica de negocio
class PedidoController extends Controller {
    public function store(CrearPedidoRequest $request): JsonResponse
    {
        // Si llegamos acá, la validación y autorización ya pasaron
        $pedido = $this->pedidoService->crear($request->validated());
        return response()->json($pedido, 201);
    }
}

<?php

class PedidoResource extends JsonResource {
    public function toArray(Request $request): array
    {
        return [
            'id'        => $this->id,
            'estado'    => $this->estado,
            'total'     => number_format($this->total / 100, 2),
            'creado_en' => $this->created_at->toIso8601String(),
            'usuario'   => new UsuarioResource($this->whenLoaded('usuario')),
            'items'     => PedidoItemResource::collection(
                $this->whenLoaded('items')
            ),
            // Solo incluir si el usuario es admin
            'notas_internas' => $this->when(
                $request->user()?->esAdmin(),
                $this->notas_internas
            ),
        ];
    }
}

// Colección con metadata de paginación
class PedidoCollection extends ResourceCollection {
    public function toArray(Request $request): array
    {
        return [
            'data' => $this->collection,
            'meta' => [
                'total_facturado' => $this->collection->sum('total'),
            ],
        ];
    }
}

<?php

use Illuminate\Database\Eloquent\Casts\Attribute;

class Usuario extends Model {
    // Accessor: transforma el valor al leerlo
    protected function nombreCompleto(): Attribute
    {
        return Attribute::make(
            get: fn () => "{$this->nombre} {$this->apellido}",
        );
    }

    // Mutator: transforma el valor al guardarlo
    protected function email(): Attribute
    {
        return Attribute::make(
            get: fn (string $value) => strtolower($value),
            set: fn (string $value) => strtolower(trim($value)),
        );
    }
}

// Uso
$usuario->nombre_completo; // "Juan García" — campo virtual
$usuario->email = '  JUAN@EJEMPLO.COM  '; // se guarda "juan@ejemplo.com"

<?php

class Producto extends Model {
    use SoftDeletes; // Agrega campo deleted_at

    // Los productos eliminados no aparecen en queries normales
}

// Queries con soft deletes
$activos   = Producto::all(); // Solo donde deleted_at IS NULL
$con_todos = Producto::withTrashed()->get();
$solo_elim = Producto::onlyTrashed()->get();

// Restaurar
Producto::withTrashed()->find(1)->restore();

// Eliminar permanentemente
Producto::withTrashed()->find(1)->forceDelete();

<?php

// Cast nativo
class Pedido extends Model {
    protected $casts = [
        'metadata'   => 'array',
        'total'      => 'integer',
        'enviado_en' => 'immutable_datetime',
        'activo'     => 'boolean',
        'estado'     => Estado::class, // enum cast
    ];
}

// Cast personalizado para un value object
class DireccionCast implements CastsAttributes {
    public function get(Model $model, string $key, mixed $value, array $attributes): Direccion
    {
        $data = json_decode($value, true);
        return new Direccion($data['calle'], $data['ciudad'], $data['cp']);
    }

    public function set(Model $model, string $key, mixed $value, array $attributes): string
    {
        return json_encode([
            'calle'  => $value->calle,
            'ciudad' => $value->ciudad,
            'cp'     => $value->cp,
        ]);
    }
}

// En el modelo
protected $casts = [
    'direccion_envio' => DireccionCast::class,
];

app/
├── Actions/          # Una clase por acción de negocio (CQRS-lite)
│   ├── Pedidos/
│   │   ├── CrearPedido.php
│   │   └── CancelarPedido.php
├── Contracts/        # Interfaces
├── Data/             # DTOs (spatie/laravel-data)
│   └── PedidoData.php
├── Http/
│   ├── Controllers/  # Solo glue: validar, llamar Action, devolver Resource
│   ├── Requests/     # Form Requests
│   └── Resources/    # API Resources
├── Models/           # Solo propiedades, relaciones, casts, scopes
├── Repositories/     # Abstracción de queries complejas
└── Services/         # Orquestación entre Actions

<?php

// Action: una responsabilidad, inyectable, testeable
class CrearPedido {
    public function __construct(
        private readonly PedidoRepository $repo,
        private readonly EventDispatcher  $events,
    ) {}

    public function ejecutar(PedidoData $datos): Pedido
    {
        $pedido = $this->repo->crear($datos);
        $this->events->dispatch(new PedidoCreado($pedido));
        return $pedido;
    }
}

// Controlador liviano
class PedidoController extends Controller {
    public function store(CrearPedidoRequest $request, CrearPedido $action): JsonResponse
    {
        $pedido = $action->ejecutar(PedidoData::fromRequest($request));
        return new PedidoResource($pedido);
    }
}

<?php

// MAL: env() en un Service directamente
class PagoService {
    private string $key = env('STRIPE_KEY'); // No se cachea con config:cache
}

// BIEN: siempre pasar por config()
class PagoService {
    private string $key;

    public function __construct() {
        $this->key = config('services.stripe.key');
    }
}