Question 1

¿Qué es Laravel y por qué es uno de los frameworks PHP más populares?

Accepted Answer

Laravel es un framework de PHP de código abierto creado por Taylor Otwell en 2011, diseñado para facilitar el desarrollo de aplicaciones web siguiendo el patrón de arquitectura MVC (Modelo-Vista-Controlador). Su popularidad se debe a que ofrece una sintaxis elegante y expresiva que hace el desarrollo más agradable y productivo.

Entre sus características principales destacan: un sistema de rutas potente, un ORM llamado Eloquent, un motor de plantillas (Blade), un sistema de migraciones de base de datos, colas de trabajo, broadcasting en tiempo real, y un ecosistema enorme que incluye herramientas como Sail, Forge, Vapor, Nova y Livewire.

```php
// Ejemplo de la elegancia de Laravel: definir una ruta con un controlador
Route::get('/usuarios', [UserController::class, 'index'])->name('usuarios.index');

// Consultar la base de datos con Eloquent
$usuarios = User::where('activo', true)
    ->orderBy('nombre')
    ->paginate(15);
```

Laravel también cuenta con una comunidad muy activa, documentación excelente y un ciclo de lanzamientos predecible con versiones LTS, lo que lo convierte en una opción sólida tanto para proyectos pequeños como para aplicaciones empresariales a gran escala.

Question 2

¿Qué es el patrón MVC y cómo lo implementa Laravel?

Accepted Answer

El patrón MVC (Modelo-Vista-Controlador) es un patrón de diseño arquitectónico que separa una aplicación en tres componentes principales: el Modelo, que gestiona los datos y la lógica de negocio; la Vista, que se encarga de la presentación al usuario; y el Controlador, que actúa como intermediario procesando las peticiones del usuario.

En Laravel, los **Modelos** se encuentran en `app/Models/` y representan tablas de la base de datos mediante Eloquent ORM. Las **Vistas** se almacenan en `resources/views/` y utilizan el motor de plantillas Blade. Los **Controladores** están en `app/Http/Controllers/` y contienen la lógica para manejar las peticiones HTTP.

```php
// Modelo (app/Models/Articulo.php)
class Articulo extends Model
{
    protected $fillable = ['titulo', 'contenido', 'autor_id'];
}

// Controlador (app/Http/Controllers/ArticuloController.php)
class ArticuloController extends Controller
{
    public function index()
    {
        $articulos = Articulo::latest()->paginate(10);
        return view('articulos.index', compact('articulos'));
    }
}
```

En la práctica, Laravel extiende el MVC puro con capas adicionales como Middleware, Form Requests, Events, Jobs y Service Providers, lo que permite organizar el código de forma más granular y mantener los controladores ligeros.

Question 3

¿Qué es Eloquent ORM y cuáles son sus ventajas?

Accepted Answer

Eloquent es el ORM (Object-Relational Mapping) incluido en Laravel que permite interactuar con la base de datos utilizando modelos PHP en lugar de escribir consultas SQL directamente. Cada modelo de Eloquent representa una tabla de la base de datos y proporciona métodos para consultar, insertar, actualizar y eliminar registros.

Las principales ventajas de Eloquent son su sintaxis intuitiva, el soporte para relaciones complejas (uno a uno, uno a muchos, muchos a muchos, polimórficas), la protección automática contra inyección SQL, la carga ansiosa (eager loading) para optimizar consultas, y características como soft deletes, casting de atributos y scopes.

```php
// Crear un registro
$usuario = User::create([
    'nombre' => 'María García',
    'email' => 'maria@ejemplo.com',
]);

// Consultar con relaciones (eager loading)
$posts = Post::with(['autor', 'comentarios'])
    ->where('publicado', true)
    ->latest()
    ->get();

// Actualizar
$usuario->update(['nombre' => 'María García López']);

// Soft delete
$usuario->delete(); // No elimina realmente, marca deleted_at
```

Aunque Eloquent es muy potente, es importante entender que para consultas muy complejas o de alto rendimiento, a veces es más eficiente usar el Query Builder de Laravel (`DB::table(...)`) o incluso consultas SQL directas.

Question 4

¿Qué son las migraciones en Laravel y por qué son importantes?

Accepted Answer

Las migraciones en Laravel son como un sistema de control de versiones para la base de datos. Permiten definir y modificar la estructura de las tablas de forma programática usando PHP, en lugar de ejecutar sentencias SQL manualmente. Cada migración es un archivo con una marca de tiempo que contiene dos métodos: `up()` para aplicar los cambios y `down()` para revertirlos.

Son fundamentales porque garantizan que todos los miembros del equipo tengan la misma estructura de base de datos, facilitan el despliegue en distintos entornos y permiten rastrear los cambios en el esquema a lo largo del tiempo.

```php
// Crear una migración: php artisan make:migration create_productos_table

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('productos', function (Blueprint $table) {
            $table->id();
            $table->string('nombre');
            $table->text('descripcion')->nullable();
            $table->decimal('precio', 10, 2);
            $table->foreignId('categoria_id')->constrained();
            $table->boolean('activo')->default(true);
            $table->timestamps();
        });
    }

public function down(): void
    {
        Schema::dropIfExists('productos');
    }
};
```

Los comandos principales son `php artisan migrate` para ejecutar migraciones pendientes, `php artisan migrate:rollback` para revertir la última tanda, y `php artisan migrate:fresh --seed` para recrear toda la base de datos con datos de prueba.

Question 5

¿Cómo funciona el sistema de rutas en Laravel?

Accepted Answer

El sistema de rutas de Laravel define cómo la aplicación responde a las peticiones HTTP. Las rutas se definen en archivos dentro del directorio `routes/`: `web.php` para rutas web con sesión y protección CSRF, `api.php` para rutas de API sin estado, `console.php` para comandos Artisan y `channels.php` para broadcasting.

Laravel soporta todos los verbos HTTP (GET, POST, PUT, PATCH, DELETE) y permite agrupar rutas, añadir middleware, usar parámetros de ruta y generar URLs nombradas.

```php
// Rutas básicas
Route::get('/inicio', function () {
    return view('inicio');
});

// Con controlador y nombre
Route::get('/usuarios/{id}', [UserController::class, 'show'])
    ->name('usuarios.show');

// Rutas de recurso (CRUD completo)
Route::resource('articulos', ArticuloController::class);

// Grupo con middleware y prefijo
Route::middleware(['auth', 'verified'])
    ->prefix('admin')
    ->name('admin.')
    ->group(function () {
        Route::get('/dashboard', [AdminController::class, 'dashboard'])
            ->name('dashboard');
    });

// Ruta API con versionado
Route::prefix('v1')->group(function () {
    Route::apiResource('productos', ProductoController::class);
});
```

Es recomendable usar siempre nombres en las rutas (`->name(...)`) para generar URLs de forma segura con `route('nombre')`, ya que si cambias la URL, las referencias en tu código seguirán funcionando correctamente.

Question 6

¿Qué son los Middleware en Laravel y para qué se usan?

Accepted Answer

Los Middleware en Laravel son filtros que interceptan las peticiones HTTP antes o después de que lleguen a la aplicación. Actúan como capas intermedias que pueden inspeccionar, modificar o rechazar peticiones y respuestas. Son ideales para tareas transversales como autenticación, autorización, logging, CORS o limitación de tasa.

Laravel incluye varios middleware por defecto como `auth` (verifica autenticación), `throttle` (limita peticiones), `verified` (verifica email) y `guest` (solo usuarios no autenticados).

```php
// Crear middleware: php artisan make:middleware VerificarEdad

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class VerificarEdad
{
    public function handle(Request $request, Closure $next): mixed
    {
        if ($request->user()->edad < 18) {
            return redirect('no-autorizado');
        }

// Continúa al siguiente middleware o controlador
        return $next($request);
    }
}

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

// Usar en rutas
Route::get('/contenido-adulto', [ContenidoController::class, 'index'])
    ->middleware('mayor_edad');
```

Existen middleware "before" (ejecutan lógica antes de la petición), "after" (después de la respuesta) y "terminable" (después de enviar la respuesta al navegador, útiles para logging o analíticas sin afectar el tiempo de respuesta).

Question 7

¿Cómo funciona Blade, el motor de plantillas de Laravel?

Accepted Answer

Blade es el motor de plantillas de Laravel que permite escribir vistas PHP de forma limpia y organizada. A diferencia de otros motores de plantillas, Blade no restringe el uso de PHP nativo y compila las vistas a código PHP plano que se cachea hasta que se modifique, por lo que no añade sobrecarga al rendimiento. Blade ofrece directivas especiales como `@if`, `@foreach`, `@auth`, herencia de plantillas con `@extends` y `@yield`, componentes reutilizables y la sintaxis `{{ }}` para escapar variables automáticamente (protección contra XSS). ```php {{-- resources/views/layouts/app.blade.php --}} @yield('titulo', 'Mi App')

@yield('contenido')

{{-- resources/views/articulos/index.blade.php --}} @extends('layouts.app') @section('titulo', 'Artículos') @section('contenido') @forelse($articulos as $articulo) @empty

No hay artículos disponibles.

@endforelse {{ $articulos->links() }} @endsection ``` Desde Laravel 7, los componentes Blade (``) permiten crear elementos reutilizables con su propia lógica, similar a los componentes de React o Vue, lo que mejora enormemente la organización del código en las vistas.

Question 8

¿Qué es la validación en Laravel y cómo se implementa?

Accepted Answer

La validación en Laravel es el proceso de verificar que los datos recibidos del usuario cumplen con reglas específicas antes de procesarlos. Laravel ofrece varias formas de validar datos, desde la validación directa en el controlador hasta los Form Requests dedicados.

El método más básico es usar `$request->validate()` directamente en el controlador. Para validaciones más complejas o reutilizables, se recomienda usar Form Requests, que son clases dedicadas a la validación.

```php
// Validación básica en controlador
public function store(Request $request)
{
    $datos = $request->validate([
        'nombre' => 'required|string|max:255',
        'email' => 'required|email|unique:users,email',
        'edad' => 'required|integer|min:18|max:120',
        'avatar' => 'nullable|image|max:2048',
    ]);

User::create($datos);
}

// Form Request (php artisan make:request StoreUserRequest)
class StoreUserRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

public function rules(): array
    {
        return [
            'nombre' => ['required', 'string', 'max:255'],
            'email' => ['required', 'email', Rule::unique('users')->ignore($this->user)],
            'password' => ['required', 'confirmed', Password::min(8)->mixedCase()->numbers()],
        ];
    }

public function messages(): array
    {
        return [
            'nombre.required' => 'El nombre es obligatorio.',
            'email.unique' => 'Este email ya está registrado.',
        ];
    }
}
```

Laravel incluye más de 90 reglas de validación predefinidas y permite crear reglas personalizadas con `php artisan make:rule`. Cuando la validación falla, Laravel redirige automáticamente al formulario anterior con los errores y los datos introducidos (`old()`).

Question 9

¿Qué son los comandos Artisan y cómo se crean comandos personalizados?

Accepted Answer

Artisan es la interfaz de línea de comandos (CLI) incluida en Laravel. Proporciona docenas de comandos útiles para el desarrollo como `migrate`, `make:model`, `tinker`, `serve`, `queue:work`, entre otros. Puedes ver todos los comandos disponibles con `php artisan list`.

Además de los comandos incluidos, puedes crear tus propios comandos personalizados para automatizar tareas específicas de tu aplicación como limpieza de datos, envío de reportes, sincronización con APIs externas, etc.

```php
// Crear comando: php artisan make:command EnviarReporteSemanal

namespace App\Console\Commands;

use Illuminate\Console\Command;

class EnviarReporteSemanal extends Command
{
    protected $signature = 'reporte:semanal
        {--email= : Email del destinatario}
        {--forzar : Enviar aunque ya se haya enviado hoy}';

protected $description = 'Envía el reporte semanal de ventas por email';

public function handle(): int
    {
        $email = $this->option('email') ?? config('app.admin_email');

$this->info('Generando reporte semanal...');

$bar = $this->output->createProgressBar(100);
        // ... lógica del reporte ...
        $bar->finish();

$this->newLine();
        $this->info("Reporte enviado a {$email}");

return Command::SUCCESS;
    }
}

// Ejecutar: php artisan reporte:semanal --email=admin@ejemplo.com
```

Los comandos Artisan también se pueden programar para ejecutarse automáticamente usando el scheduler de Laravel en `routes/console.php`, eliminando la necesidad de configurar múltiples entradas cron en el servidor.

Question 10

¿Cómo funciona el ciclo de vida de una petición HTTP en Laravel?

Accepted Answer

El ciclo de vida de una petición en Laravel comienza cuando el servidor web (Nginx/Apache) redirige la petición al archivo `public/index.php`, que es el punto de entrada de toda la aplicación. Desde ahí, se inicia un proceso ordenado de bootstrap, middleware y resolución.

El flujo completo es el siguiente: primero se carga el autoloader de Composer, luego se crea la instancia de la aplicación (`bootstrap/app.php`), se resuelve el kernel HTTP, se procesan los middleware globales, se resuelve la ruta, se ejecutan los middleware de ruta, se llama al controlador, se genera la respuesta y finalmente se envía al cliente.

```php
// 1. public/index.php - Punto de entrada
require __DIR__.'/../vendor/autoload.php';
$app = require_once __DIR__.'/../bootstrap/app.php';

// 2. El Kernel HTTP procesa la petición
$kernel = $app->make(Kernel::class);
$response = $kernel->handle(
    $request = Request::capture()
);

// 3. Orden de ejecución simplificado:
// Middleware globales → Resolución de ruta → Middleware de ruta
// → Form Request (validación) → Controlador → Respuesta
// → Middleware terminables

// 4. Se envía la respuesta
$response->send();

// 5. Se ejecutan tareas de terminación
$kernel->terminate($request, $response);
```

Entender este ciclo es crucial para saber dónde colocar tu lógica. Por ejemplo, los Service Providers se registran durante el bootstrap (antes de cualquier ruta), los middleware globales se ejecutan en cada petición, y los terminable middleware corren después de enviar la respuesta, ideales para tareas como logging que no deben afectar el tiempo de respuesta.

Question 11

¿Qué son las Collections en Laravel y cuáles son sus métodos más útiles?

Accepted Answer

Las Collections de Laravel son una envoltura potente sobre los arrays de PHP que proporcionan una interfaz fluida para trabajar con conjuntos de datos. Cada consulta de Eloquent retorna una Collection, pero también puedes crear Collections a partir de cualquier array con `collect()`.

A diferencia de las funciones nativas de PHP para arrays, las Collections permiten encadenar métodos de forma legible y expresiva, siguiendo un estilo funcional similar a los streams de Java o los métodos de array de JavaScript.

```php
$usuarios = collect([
    ['nombre' => 'Ana', 'edad' => 28, 'ciudad' => 'Madrid'],
    ['nombre' => 'Carlos', 'edad' => 35, 'ciudad' => 'Barcelona'],
    ['nombre' => 'Elena', 'edad' => 22, 'ciudad' => 'Madrid'],
    ['nombre' => 'Pedro', 'edad' => 31, 'ciudad' => 'Sevilla'],
]);

// Filtrar, transformar y agrupar
$resultado = $usuarios
    ->where('edad', '>=', 25)
    ->sortBy('nombre')
    ->groupBy('ciudad')
    ->map(fn ($grupo) => $grupo->pluck('nombre'));

// Métodos muy usados
$usuarios->pluck('nombre');           // ['Ana', 'Carlos', 'Elena', 'Pedro']
$usuarios->sum('edad');               // 116
$usuarios->avg('edad');               // 29
$usuarios->contains('nombre', 'Ana'); // true
$usuarios->firstWhere('ciudad', 'Barcelona'); // Carlos
$usuarios->chunk(2);                  // Divide en grupos de 2
$usuarios->unique('ciudad');          // Elimina duplicados por ciudad
```

Algunos de los métodos más útiles son `map()`, `filter()`, `reduce()`, `pluck()`, `groupBy()`, `sortBy()`, `flatten()`, `merge()`, `when()` y `pipe()`. Es importante saber que las Collections de Eloquent incluyen métodos adicionales como `load()` para eager loading diferido y `modelKeys()` para obtener los IDs.

Question 12

¿Qué son los Service Providers en Laravel y cuál es su función?

Accepted Answer

Los Service Providers son el punto central de arranque (bootstrap) de toda aplicación Laravel. Son las clases responsables de registrar servicios en el contenedor de inyección de dependencias, configurar event listeners, registrar middleware, definir rutas y cualquier otra configuración que la aplicación necesite al iniciar.

Todo en Laravel se carga a través de Service Providers: la base de datos, las colas, la validación, el routing, etc. Tu aplicación los configura en `bootstrap/providers.php` (Laravel 11+) o en `config/app.php` (versiones anteriores).

```php
// app/Providers/AppServiceProvider.php
namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Services\PasarelaPago;
use App\Services\StripePasarela;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Registrar servicios en el contenedor.
     * Aquí solo se hacen bindings, no se usa ningún otro servicio.
     */
    public function register(): void
    {
        $this->app->bind(PasarelaPago::class, function ($app) {
            return new StripePasarela(config('services.stripe.key'));
        });
    }

/**
     * Configurar servicios después de que todos estén registrados.
     * Aquí sí puedes usar otros servicios.
     */
    public function boot(): void
    {
        View::share('appNombre', config('app.name'));

Model::preventLazyLoading(! app()->isProduction());
    }
}
```

La distinción entre `register()` y `boot()` es esencial: en `register()` solo debes vincular cosas al contenedor (nunca usar otros servicios que podrían no estar registrados aún). En `boot()`, todos los providers ya están registrados, así que puedes usar cualquier servicio de la aplicación.

Question 13

¿Cómo funcionan las relaciones en Eloquent y qué tipos existen?

Accepted Answer

Eloquent permite definir relaciones entre modelos de forma expresiva, representando las relaciones de la base de datos como métodos PHP. Laravel soporta varios tipos de relaciones que cubren prácticamente cualquier esquema de base de datos.

Los tipos principales son: `hasOne` (uno a uno), `hasMany` (uno a muchos), `belongsTo` (inversa), `belongsToMany` (muchos a muchos con tabla pivote), `hasOneThrough` y `hasManyThrough` (relaciones a través de un modelo intermedio), y las relaciones polimórficas.

```php
class Usuario extends Model
{
    // Uno a uno: un usuario tiene un perfil
    public function perfil(): HasOne
    {
        return $this->hasOne(Perfil::class);
    }

// Uno a muchos: un usuario tiene muchos artículos
    public function articulos(): HasMany
    {
        return $this->hasMany(Articulo::class);
    }

// Muchos a muchos: un usuario tiene muchos roles
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Rol::class)
            ->withPivot('asignado_en')
            ->withTimestamps();
    }
}

// Uso con eager loading para evitar el problema N+1
$usuarios = Usuario::with(['perfil', 'articulos' => function ($query) {
    $query->where('publicado', true)->latest();
}])->paginate(20);

// Consultar a través de relaciones
$usuariosConArticulos = Usuario::has('articulos', '>=', 5)->get();
$usuariosEnMadrid = Usuario::whereHas('perfil', function ($query) {
    $query->where('ciudad', 'Madrid');
})->get();
```

Un error muy común es no usar eager loading (`with()`), lo que provoca el problema N+1: si tienes 100 usuarios y accedes a sus artículos en un bucle, se ejecutarán 101 consultas en lugar de solo 2. Laravel permite detectar esto automáticamente con `Model::preventLazyLoading()` en desarrollo.

Question 14

¿Qué son los Query Scopes en Eloquent y cómo se utilizan?

Accepted Answer

Los Query Scopes en Eloquent son una forma de encapsular condiciones de consulta reutilizables directamente en el modelo. Existen dos tipos: scopes locales (que se aplican manualmente) y scopes globales (que se aplican automáticamente a todas las consultas del modelo).

Los scopes locales se definen como métodos con el prefijo `scope` y reciben el query builder como primer argumento. Los scopes globales se aplican a cada consulta del modelo y son útiles para filtros que siempre deben estar presentes, como mostrar solo registros activos.

```php
class Articulo extends Model
{
    // Scope local: se usa como ->publicado()
    public function scopePublicado(Builder $query): Builder
    {
        return $query->where('estado', 'publicado')
                     ->whereNotNull('publicado_en');
    }

// Scope local con parámetros
    public function scopeDeCategoria(Builder $query, string $categoria): Builder
    {
        return $query->where('categoria', $categoria);
    }

// Scope local para ordenar por popularidad
    public function scopePopulares(Builder $query): Builder
    {
        return $query->orderByDesc('visitas');
    }
}

// Uso encadenado - muy legible
$articulos = Articulo::publicado()
    ->deCategoria('laravel')
    ->populares()
    ->paginate(15);

// Scope global (se aplica siempre)
class SoloActivosScope implements Scope
{
    public function apply(Builder $builder, Model $model): void
    {
        $builder->where('activo', true);
    }
}

// En el modelo:
protected static function booted(): void
{
    static::addGlobalScope(new SoloActivosScope);
}

// Para saltar el scope global puntualmente:
Articulo::withoutGlobalScope(SoloActivosScope::class)->get();
```

Los scopes mejoran la legibilidad del código y evitan duplicar condiciones de consulta por toda la aplicación. Un ejemplo clásico de scope global es el `SoftDeletes` trait de Laravel, que añade automáticamente `whereNull('deleted_at')` a todas las consultas.

Question 15

¿Cómo funcionan los Events y Listeners en Laravel?

Accepted Answer

El sistema de Events y Listeners de Laravel implementa el patrón Observer, permitiendo desacoplar diferentes partes de la aplicación. Un evento representa algo que ha ocurrido (un usuario se registró, un pedido se completó), mientras que un listener es una clase que reacciona a ese evento (enviar email de bienvenida, generar factura).

Un evento puede tener múltiples listeners, lo que permite añadir comportamientos sin modificar el código existente, respetando el principio Open/Closed de SOLID.

```php
// Evento (php artisan make:event PedidoCompletado)
class PedidoCompletado
{
    use Dispatchable, SerializesModels;

public function __construct(
        public readonly Pedido $pedido
    ) {}
}

// Listener (php artisan make:listener EnviarConfirmacionPedido)
class EnviarConfirmacionPedido implements ShouldQueue
{
    public function handle(PedidoCompletado $event): void
    {
        $event->pedido->usuario->notify(
            new PedidoConfirmadoNotification($event->pedido)
        );
    }
}

// Listener para generar factura
class GenerarFactura implements ShouldQueue
{
    public function handle(PedidoCompletado $event): void
    {
        FacturaService::generar($event->pedido);
    }
}

// Registrar en AppServiceProvider o EventServiceProvider
Event::listen(PedidoCompletado::class, EnviarConfirmacionPedido::class);
Event::listen(PedidoCompletado::class, GenerarFactura::class);

// Disparar el evento
PedidoCompletado::dispatch($pedido);
```

Laravel también ofrece Model Events (`creating`, `created`, `updating`, etc.) que se disparan automáticamente en operaciones de Eloquent, y Model Observers que agrupan estos listeners en una sola clase. Los listeners que implementan `ShouldQueue` se ejecutan en segundo plano, ideal para tareas pesadas que no deben bloquear la respuesta al usuario.

Question 16

¿Cómo se implementan las colas de trabajo (Queues) en Laravel?

Accepted Answer

Las colas de trabajo en Laravel permiten diferir tareas pesadas para ejecutarlas en segundo plano, mejorando el tiempo de respuesta de la aplicación. Por ejemplo, en lugar de enviar un email y hacer esperar al usuario, se coloca el trabajo en una cola y un worker lo procesa después.

Laravel soporta varios drivers de cola: `database`, `redis`, `sqs` (Amazon), `beanstalkd` y `sync` (ejecución inmediata para desarrollo). Redis es la opción más común en producción por su rendimiento.

```php
// Crear un Job: php artisan make:job ProcesarImagen
class ProcesarImagen implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

public int $tries = 3;          // Reintentos máximos
    public int $backoff = 60;       // Segundos entre reintentos
    public int $timeout = 120;      // Timeout en segundos

public function __construct(
        public readonly Imagen $imagen
    ) {}

public function handle(ImagenService $servicio): void
    {
        $servicio->redimensionar($this->imagen, 800, 600);
        $servicio->optimizar($this->imagen);
        $servicio->generarThumbnail($this->imagen);

$this->imagen->update(['procesada' => true]);
    }

public function failed(\Throwable $exception): void
    {
        Log::error('Error procesando imagen', [
            'imagen_id' => $this->imagen->id,
            'error' => $exception->getMessage(),
        ]);
    }
}

// Despachar a la cola
ProcesarImagen::dispatch($imagen);

// Con opciones
ProcesarImagen::dispatch($imagen)
    ->onQueue('imagenes')
    ->delay(now()->addMinutes(5));
```

Para procesar las colas necesitas ejecutar un worker con `php artisan queue:work`. En producción se recomienda usar Supervisor o Laravel Horizon (para Redis) para gestionar los workers, reiniciarlos si fallan y monitorizar el rendimiento. Laravel también ofrece Job Batching para agrupar jobs y ejecutar callbacks cuando todos terminen.

Question 17

¿Cómo implementarías una estrategia de caché en Laravel?

Accepted Answer

Laravel ofrece una API unificada de caché que soporta múltiples backends: file, database, Redis, Memcached y DynamoDB. Una buena estrategia de caché debe considerar qué datos cachear, durante cuánto tiempo, y cómo invalidar el caché cuando los datos cambien.

Las estrategias más comunes son: cache-aside (buscar en caché, si no existe consultar y almacenar), write-through (actualizar caché al escribir en BD) y cache tagging (agrupar entradas para invalidación masiva).

```php
// Cache-aside básico con remember()
$articulos = Cache::remember('articulos.populares', 3600, function () {
    return Articulo::with('autor')
        ->publicado()
        ->populares()
        ->take(10)
        ->get();
});

// Cache con tags (solo Redis/Memcached)
Cache::tags(['articulos', 'portada'])->remember('portada.articulos', 3600, function () {
    return Articulo::portada()->get();
});

// Invalidar por tag cuando se actualiza un artículo
Cache::tags(['articulos'])->flush();

// Caché a nivel de modelo con un método en el modelo
class Configuracion extends Model
{
    public static function obtener(string $clave, mixed $default = null): mixed
    {
        return Cache::rememberForever("config.{$clave}", function () use ($clave, $default) {
            return static::where('clave', $clave)->value('valor') ?? $default;
        });
    }

protected static function booted(): void
    {
        static::saved(fn ($config) => Cache::forget("config.{$config->clave}"));
    }
}

// Caché de rutas y configuración en producción
// php artisan route:cache
// php artisan config:cache
// php artisan view:cache
// php artisan event:cache
```

En producción, es fundamental cachear rutas, configuración y vistas con los comandos Artisan correspondientes. Para datos dinámicos, Redis es la mejor opción por su velocidad. Se recomienda establecer TTLs apropiados y usar cache tags para una invalidación granular. Evita cachear datos de usuario específicos a menos que sea estrictamente necesario.

Question 18

¿Cómo se crean API Resources en Laravel para transformar datos?

Accepted Answer

Los API Resources de Laravel proporcionan una capa de transformación entre los modelos Eloquent y las respuestas JSON de tu API. Permiten controlar exactamente qué datos se envían al cliente, dar formato a campos, incluir relaciones condicionales y añadir metadatos, todo de forma organizada y reutilizable.

Existen dos tipos: Resources (para un solo modelo) y Resource Collections (para colecciones de modelos). Se crean con `php artisan make:resource`.

```php
// php artisan make:resource ArticuloResource
class ArticuloResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'titulo' => $this->titulo,
            'slug' => $this->slug,
            'extracto' => Str::limit($this->contenido, 200),
            'contenido' => $this->when(
                $request->routeIs('articulos.show'),
                $this->contenido
            ),
            'autor' => new AutorResource($this->whenLoaded('autor')),
            'etiquetas' => EtiquetaResource::collection($this->whenLoaded('etiquetas')),
            'comentarios_count' => $this->whenCounted('comentarios'),
            'publicado_en' => $this->publicado_en?->format('d/m/Y H:i'),
            'es_reciente' => $this->publicado_en?->isAfter(now()->subWeek()),
            'enlaces' => [
                'self' => route('api.articulos.show', $this),
                'autor' => route('api.autores.show', $this->autor_id),
            ],
        ];
    }
}

// Resource Collection con metadatos
class ArticuloCollection extends ResourceCollection
{
    public function toArray(Request $request): array
    {
        return [
            'data' => $this->collection,
            'meta' => [
                'total_publicados' => Articulo::publicado()->count(),
            ],
        ];
    }
}

// Uso en controlador
public function index()
{
    $articulos = Articulo::with(['autor', 'etiquetas'])
        ->withCount('comentarios')
        ->publicado()
        ->paginate(15);

return new ArticuloCollection($articulos);
}

public function show(Articulo $articulo)
{
    $articulo->load(['autor', 'etiquetas', 'comentarios.usuario']);
    return new ArticuloResource($articulo);
}
```

Los métodos `when()`, `whenLoaded()` y `whenCounted()` son especialmente útiles para incluir datos condicionalmente, evitando consultas innecesarias y adaptando la respuesta según el contexto. Esto mantiene tus respuestas API consistentes y eficientes.

Question 19

¿Cómo se escribe testing en Laravel con Pest o PHPUnit?

Accepted Answer

Laravel viene preconfigurado para testing con PHPUnit y ofrece soporte de primera clase para Pest, una capa más expresiva sobre PHPUnit. Los tests se organizan en `tests/Feature/` (tests de integración que prueban flujos completos) y `tests/Unit/` (tests unitarios para clases individuales).

Laravel proporciona helpers como `actingAs()`, `assertDatabaseHas()`, métodos HTTP (`get()`, `post()`, etc.) y traits como `RefreshDatabase` para trabajar con una base de datos limpia en cada test.

```php
// Test con Pest (tests/Feature/ArticuloTest.php)
use App\Models\User;
use App\Models\Articulo;

uses(RefreshDatabase::class);

test('un usuario autenticado puede crear un artículo', function () {
    $usuario = User::factory()->create();

$response = $this->actingAs($usuario)
        ->post('/articulos', [
            'titulo' => 'Mi primer artículo',
            'contenido' => 'Contenido del artículo de prueba.',
            'categoria' => 'laravel',
        ]);

$response->assertRedirect('/articulos');

$this->assertDatabaseHas('articulos', [
        'titulo' => 'Mi primer artículo',
        'user_id' => $usuario->id,
    ]);
});

test('un usuario no autenticado no puede crear artículos', function () {
    $this->post('/articulos', [
        'titulo' => 'Test',
    ])->assertRedirect('/login');
});

test('el título es obligatorio al crear un artículo', function () {
    $usuario = User::factory()->create();

$this->actingAs($usuario)
        ->post('/articulos', ['titulo' => ''])
        ->assertSessionHasErrors('titulo');
});

// Test de API
test('la API retorna artículos paginados', function () {
    Articulo::factory()->count(20)->create(['estado' => 'publicado']);

$this->getJson('/api/articulos')
        ->assertOk()
        ->assertJsonCount(15, 'data')
        ->assertJsonStructure([
            'data' => [['id', 'titulo', 'autor']],
            'meta' => ['current_page', 'total'],
        ]);
});
```

Se recomienda ejecutar los tests con `php artisan test` (que usa Pest si está instalado) o `php artisan test --parallel` para ejecución paralela. Los Factories y Seeders son esenciales para crear datos de prueba realistas. Una buena práctica es mantener una cobertura alta en tests de Feature, ya que prueban el flujo real de la aplicación.

Question 20

¿Qué es el patrón Repository y cuándo tiene sentido usarlo en Laravel?

Accepted Answer

El patrón Repository actúa como una capa de abstracción entre la lógica de negocio y la capa de acceso a datos. En teoría, permite cambiar la fuente de datos (de MySQL a MongoDB, por ejemplo) sin afectar al resto de la aplicación. Sin embargo, su uso en Laravel es controvertido.

Eloquent ya actúa como una abstracción sobre la base de datos, por lo que añadir un Repository encima puede ser redundancia innecesaria (Repository sobre Repository). Sin embargo, hay casos donde tiene sentido, como cuando la lógica de consulta es compleja y se reutiliza en múltiples lugares.

```php
// Interface
interface ArticuloRepositoryInterface
{
    public function obtenerPublicados(int $porPagina = 15): LengthAwarePaginator;
    public function obtenerPorCategoria(string $categoria): Collection;
    public function buscar(string $termino): Collection;
}

// Implementación con Eloquent
class EloquentArticuloRepository implements ArticuloRepositoryInterface
{
    public function __construct(
        private readonly Articulo $modelo
    ) {}

public function obtenerPublicados(int $porPagina = 15): LengthAwarePaginator
    {
        return $this->modelo
            ->with(['autor', 'etiquetas'])
            ->publicado()
            ->latest('publicado_en')
            ->paginate($porPagina);
    }

public function buscar(string $termino): Collection
    {
        return $this->modelo
            ->where('titulo', 'like', "%{$termino}%")
            ->orWhere('contenido', 'like', "%{$termino}%")
            ->publicado()
            ->get();
    }
}

// Binding en Service Provider
$this->app->bind(
    ArticuloRepositoryInterface::class,
    EloquentArticuloRepository::class
);

// Uso en controlador
class ArticuloController extends Controller
{
    public function __construct(
        private readonly ArticuloRepositoryInterface $articulos
    ) {}

public function index()
    {
        return view('articulos.index', [
            'articulos' => $this->articulos->obtenerPublicados(),
        ]);
    }
}
```

La recomendación pragmática es: para proyectos pequeños-medianos, los Query Scopes de Eloquent suelen ser suficientes. Para proyectos grandes con lógica de consulta compleja, un Repository o un Query Object puede mejorar la organización. Evita crear Repositories genéricos con métodos CRUD básicos que solo duplican lo que Eloquent ya hace.

Question 21

¿Qué son las relaciones polimórficas en Eloquent y cuándo usarlas?

Accepted Answer

Las relaciones polimórficas permiten que un modelo pertenezca a más de un tipo de modelo usando una sola asociación. Es decir, en lugar de tener una tabla `comentarios_articulos` y otra `comentarios_videos`, tienes una sola tabla `comentarios` con columnas `commentable_id` y `commentable_type` que determinan a qué modelo pertenece cada comentario.

Laravel soporta varios tipos: `morphOne`, `morphMany`, `morphToMany` (polimórfica muchos a muchos) y `morphTo` (la inversa).

```php
// Tabla comentarios: id, contenido, commentable_id, commentable_type, timestamps

class Comentario extends Model
{
    public function commentable(): MorphTo
    {
        return $this->morphTo();
    }
}

class Articulo extends Model
{
    public function comentarios(): MorphMany
    {
        return $this->morphMany(Comentario::class, 'commentable');
    }
}

class Video extends Model
{
    public function comentarios(): MorphMany
    {
        return $this->morphMany(Comentario::class, 'commentable');
    }
}

// Uso
$articulo = Articulo::find(1);
$articulo->comentarios()->create(['contenido' => '¡Gran artículo!']);
// commentable_type = 'App\Models\Articulo'
// commentable_id = 1

// Polimórfica muchos a muchos (tags compartidos)
// Tabla taggables: tag_id, taggable_id, taggable_type
class Tag extends Model
{
    public function articulos(): MorphToMany
    {
        return $this->morphedByMany(Articulo::class, 'taggable');
    }

public function videos(): MorphToMany
    {
        return $this->morphedByMany(Video::class, 'taggable');
    }
}

class Articulo extends Model
{
    public function tags(): MorphToMany
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}
```

Las relaciones polimórficas son ideales para features compartidas como comentarios, likes, archivos adjuntos, tags o logs de actividad. Sin embargo, tienen desventajas: no pueden tener foreign keys a nivel de base de datos (lo que puede causar datos huérfanos) y las consultas pueden ser más lentas. Usa `Relation::enforceMorphMap()` para evitar almacenar nombres de clase completos en la base de datos.

Question 22

¿Cómo funcionan los Form Requests y cuándo se deben usar?

Accepted Answer

Los Form Requests son clases dedicadas a la validación y autorización de peticiones HTTP. Permiten extraer la lógica de validación del controlador a una clase independiente, manteniendo los controladores limpios y la validación reutilizable y testeable.

Se crean con `php artisan make:request` y contienen dos métodos principales: `authorize()` para verificar si el usuario puede realizar la acción, y `rules()` que define las reglas de validación.

```php
// php artisan make:request UpdateArticuloRequest
class UpdateArticuloRequest extends FormRequest
{
    public function authorize(): bool
    {
        // Verifica que el usuario sea el autor del artículo
        return $this->user()->id === $this->route('articulo')->user_id;
    }

public function rules(): array
    {
        return [
            'titulo' => ['required', 'string', 'max:255'],
            'slug' => [
                'required',
                'string',
                Rule::unique('articulos')->ignore($this->route('articulo')),
            ],
            'contenido' => ['required', 'string', 'min:100'],
            'categoria_id' => ['required', 'exists:categorias,id'],
            'etiquetas' => ['nullable', 'array', 'max:5'],
            'etiquetas.*' => ['exists:etiquetas,id'],
            'imagen' => ['nullable', 'image', 'max:2048', 'dimensions:min_width=800'],
        ];
    }

public function messages(): array
    {
        return [
            'contenido.min' => 'El artículo debe tener al menos 100 caracteres.',
            'etiquetas.max' => 'No puedes asignar más de 5 etiquetas.',
        ];
    }

// Transformar datos antes de la validación
    protected function prepareForValidation(): void
    {
        $this->merge([
            'slug' => Str::slug($this->titulo),
        ]);
    }

// Lógica post-validación
    public function after(): array
    {
        return [
            function (Validator $validator) {
                if ($this->detectarSpam($this->contenido)) {
                    $validator->errors()->add('contenido', 'El contenido parece ser spam.');
                }
            },
        ];
    }
}

// Uso en controlador - limpio y conciso
public function update(UpdateArticuloRequest $request, Articulo $articulo)
{
    $articulo->update($request->validated());
    return redirect()->route('articulos.show', $articulo);
}
```

Los Form Requests se deben usar siempre que la validación tenga más de 2-3 reglas o cuando necesites reutilizar las mismas reglas en múltiples lugares. Para validaciones simples de un solo campo, `$request->validate()` directo en el controlador es perfectamente aceptable.

Question 23

¿Cómo implementarías notificaciones en Laravel a través de múltiples canales?

Accepted Answer

El sistema de notificaciones de Laravel permite enviar notificaciones a usuarios a través de múltiples canales (email, SMS, Slack, base de datos, push, etc.) desde una sola clase. Cada notificación define en qué canales se envía y cómo se formatea para cada uno.

Las notificaciones se crean con `php artisan make:notification` y se pueden enviar de forma inmediata o en cola para mejorar el rendimiento.

```php
// php artisan make:notification PedidoEnviadoNotification
class PedidoEnviadoNotification extends Notification implements ShouldQueue
{
    use Queueable;

public function __construct(
        public readonly Pedido $pedido
    ) {}

// Definir canales según preferencias del usuario
    public function via(object $notifiable): array
    {
        $canales = ['database'];

if ($notifiable->prefiere_email) {
            $canales[] = 'mail';
        }

if ($notifiable->telefono) {
            $canales[] = VonageChannel::class; // SMS
        }

return $canales;
    }

public function toMail(object $notifiable): MailMessage
    {
        return (new MailMessage)
            ->subject('Tu pedido ha sido enviado')
            ->greeting("¡Hola {$notifiable->nombre}!")
            ->line("Tu pedido #{$this->pedido->numero} ha sido enviado.")
            ->line("Número de seguimiento: {$this->pedido->tracking}")
            ->action('Ver pedido', route('pedidos.show', $this->pedido))
            ->line('¡Gracias por tu compra!');
    }

public function toDatabase(object $notifiable): array
    {
        return [
            'tipo' => 'pedido_enviado',
            'pedido_id' => $this->pedido->id,
            'mensaje' => "Tu pedido #{$this->pedido->numero} ha sido enviado.",
            'tracking' => $this->pedido->tracking,
        ];
    }

public function toArray(object $notifiable): array
    {
        return $this->toDatabase($notifiable);
    }
}

// Enviar notificación
$usuario->notify(new PedidoEnviadoNotification($pedido));

// Enviar a múltiples usuarios
Notification::send($usuarios, new PedidoEnviadoNotification($pedido));

// Leer notificaciones de base de datos
$sinLeer = $usuario->unreadNotifications;
$sinLeer->markAsRead();
```

Para las notificaciones por base de datos, necesitas ejecutar `php artisan notifications:table && php artisan migrate`. Laravel también permite crear canales personalizados (por ejemplo, para Telegram o Discord) implementando un método `toCustomChannel()` en la notificación y una clase de canal con un método `send()`.

Question 24

¿Cómo funciona el Service Container de Laravel internamente?

Accepted Answer

El Service Container (contenedor de servicios) es el corazón de Laravel. Es un contenedor de inyección de dependencias que gestiona las dependencias de las clases y realiza la inyección de dependencias automáticamente. Internamente, mantiene un registro de bindings (vínculos) entre interfaces/clases abstractas y sus implementaciones concretas.

Cuando Laravel necesita resolver una clase, el container utiliza PHP Reflection para inspeccionar el constructor de la clase, determinar sus dependencias, resolverlas recursivamente y finalmente instanciar el objeto. Este proceso se llama auto-resolución (auto-wiring).

```php
// El container resuelve automáticamente las dependencias
class PedidoController extends Controller
{
    // Laravel inspecciona el constructor, ve que necesita PedidoService,
    // resuelve PedidoService (y sus dependencias), e inyecta todo
    public function __construct(
        private readonly PedidoService $pedidoService
    ) {}
}

// Tipos de bindings

// bind() - Nueva instancia cada vez que se resuelve
$this->app->bind(PasarelaPago::class, StripePasarela::class);

// singleton() - Misma instancia compartida
$this->app->singleton(CarritoService::class, function ($app) {
    return new CarritoService(
        $app->make(SessionManager::class),
        config('carrito.moneda_defecto')
    );
});

// scoped() - Singleton dentro de la misma petición (se resetea entre peticiones)
$this->app->scoped(TenantContext::class, function ($app) {
    return new TenantContext($app->make(Request::class));
});

// Contextual bindings - diferentes implementaciones según quién las necesite
$this->app->when(FotoController::class)
    ->needs(StorageInterface::class)
    ->give(S3Storage::class);

$this->app->when(DocumentoController::class)
    ->needs(StorageInterface::class)
    ->give(LocalStorage::class);

// Resolver manualmente
$servicio = app(PedidoService::class);
$servicio = app()->make(PedidoService::class);
$servicio = resolve(PedidoService::class);
```

Entender el container es crucial para la arquitectura avanzada. Permite programar contra interfaces en lugar de implementaciones, facilita el testing (puedes sustituir servicios reales por mocks) y es la base de la extensibilidad de Laravel. Los tagged bindings (`$this->app->tag(...)`) permiten agrupar implementaciones y resolverlas todas juntas, útil para patrones como Strategy o Chain of Responsibility.

Question 25

¿Cómo aplicarías los principios SOLID en una aplicación Laravel?

Accepted Answer

Los principios SOLID son cinco principios de diseño orientado a objetos que producen código más mantenible y extensible. Laravel facilita su aplicación gracias a su arquitectura basada en el contenedor de servicios.

**S - Single Responsibility:** Cada clase debe tener una sola responsabilidad. En lugar de poner toda la lógica en controladores, separamos en Form Requests (validación), Services (lógica de negocio), Actions (operaciones específicas) y Events (efectos secundarios).

```php
// MAL: controlador con demasiadas responsabilidades
public function store(Request $request) {
    $request->validate([...]);
    $usuario = User::create([...]);
    Mail::send(...);
    Log::info(...);
    // ... 50 líneas más
}

// BIEN: cada clase hace una cosa
public function store(RegistroRequest $request, RegistrarUsuarioAction $action)
{
    $usuario = $action->execute($request->validated());
    return redirect()->route('dashboard');
}

class RegistrarUsuarioAction
{
    public function execute(array $datos): User
    {
        $usuario = DB::transaction(function () use ($datos) {
            $usuario = User::create($datos);
            $usuario->perfil()->create(['bio' => '']);
            return $usuario;
        });

UsuarioRegistrado::dispatch($usuario); // Los listeners manejan email, log, etc.
        return $usuario;
    }
}
```

**O - Open/Closed:** Las clases deben estar abiertas a extensión pero cerradas a modificación. Los Events/Listeners y los Pipelines de Laravel son perfectos para esto.

**L - Liskov Substitution:** Las subclases deben ser sustituibles por sus clases padre. Esto se aplica al diseñar interfaces y usar el contenedor.

**I - Interface Segregation:** Interfaces pequeñas y específicas en lugar de una interfaz gigante.

```php
// BIEN: interfaces segregadas
interface PuedeEnviarEmail { public function enviarEmail(Mailable $mail): void; }
interface PuedeEnviarSMS { public function enviarSMS(string $mensaje): void; }

// MAL: una interfaz monolítica
interface Notificable { public function enviarEmail(...); public function enviarSMS(...); public function enviarPush(...); }
```

**D - Dependency Inversion:** Depender de abstracciones, no de implementaciones concretas. El Service Container de Laravel permite vincular interfaces a implementaciones y cambiarlas sin tocar el código que las consume.

```php
// El controlador depende de la abstracción
public function __construct(private readonly PasarelaPagoInterface $pasarela) {}

// En testing puedes sustituir la implementación
$this->app->bind(PasarelaPagoInterface::class, PasarelaPagoFake::class);
```

Question 26

¿Cómo implementarías Domain-Driven Design (DDD) en una aplicación Laravel?

Accepted Answer

Implementar DDD en Laravel implica reorganizar la estructura del proyecto para que refleje los dominios de negocio en lugar de los conceptos técnicos. En lugar de agrupar por tipo (Models, Controllers, etc.), agrupamos por dominio (Pedidos, Usuarios, Inventario), y separamos las capas de dominio, aplicación e infraestructura.

La estructura típica organiza el código en módulos de dominio dentro de `src/` o `app/Domain/`, manteniendo la capa de infraestructura de Laravel (controllers, routes, views) como adaptadores.

```php
// Estructura de directorios
app/
├── Domain/
│   ├── Pedidos/
│   │   ├── Models/          // Entidades y Value Objects
│   │   │   ├── Pedido.php
│   │   │   ├── LineaPedido.php
│   │   │   └── ValueObjects/
│   │   │       ├── Dinero.php
│   │   │       └── DireccionEnvio.php
│   │   ├── Actions/         // Casos de uso
│   │   │   ├── CrearPedidoAction.php
│   │   │   └── CancelarPedidoAction.php
│   │   ├── Events/
│   │   │   └── PedidoCreado.php
│   │   ├── Exceptions/
│   │   │   └── StockInsuficienteException.php
│   │   └── DataTransferObjects/
│   │       └── CrearPedidoDTO.php
│   └── Inventario/
│       └── ...
├── Http/                    // Capa de infraestructura
│   └── Controllers/
│       └── PedidoController.php
└── Providers/

// Value Object inmutable
final class Dinero
{
    public function __construct(
        public readonly int $centimos,
        public readonly string $moneda = 'EUR'
    ) {
        if ($centimos < 0) {
            throw new \InvalidArgumentException('El importe no puede ser negativo');
        }
    }

public function sumar(Dinero $otro): self
    {
        if ($this->moneda !== $otro->moneda) {
            throw new MonedaIncompatibleException();
        }
        return new self($this->centimos + $otro->centimos, $this->moneda);
    }

public function formatear(): string
    {
        return number_format($this->centimos / 100, 2, ',', '.') . ' €';
    }
}

// Action como caso de uso
class CrearPedidoAction
{
    public function __construct(
        private readonly VerificarStockAction $verificarStock,
        private readonly CalcularPrecioService $calculadorPrecios
    ) {}

public function execute(CrearPedidoDTO $dto): Pedido
    {
        return DB::transaction(function () use ($dto) {
            $this->verificarStock->execute($dto->lineas);

$pedido = Pedido::crear(
                usuario: $dto->usuario,
                direccion: $dto->direccion,
                lineas: $dto->lineas,
                total: $this->calculadorPrecios->calcular($dto->lineas)
            );

PedidoCreado::dispatch($pedido);

return $pedido;
        });
    }
}
```

DDD no es todo o nada. Se recomienda empezar con los conceptos que más valor aporten: separar en dominios, usar DTOs para transferir datos, Value Objects para conceptos con identidad por valor, y Actions para encapsular casos de uso. Evita sobreingeniería: no todo proyecto necesita DDD completo. Es más adecuado para aplicaciones con lógica de negocio compleja que justifique el coste adicional de abstracción.

Question 27

¿Cómo escalarías horizontalmente una aplicación Laravel?

Accepted Answer

Escalar horizontalmente significa añadir más servidores en lugar de hacer más potente uno solo. Para que una aplicación Laravel funcione correctamente en múltiples servidores, hay varios aspectos críticos que deben externalizarse y configurarse correctamente.

Los principales desafíos son: sesiones compartidas, caché distribuida, almacenamiento de archivos centralizado, colas de trabajo y equilibrio de carga.

```php
// 1. SESIONES - Usar Redis o base de datos en vez de archivos
// .env
SESSION_DRIVER=redis
REDIS_HOST=redis-cluster.ejemplo.com

// 2. CACHÉ - Redis centralizado
CACHE_DRIVER=redis

// 3. ALMACENAMIENTO - S3 en vez de disco local
FILESYSTEM_DISK=s3

// config/filesystems.php
's3' => [
    'driver' => 's3',
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION'),
    'bucket' => env('AWS_BUCKET'),
    'url' => env('AWS_URL'), // CDN como CloudFront
],

// 4. COLAS - Redis o SQS con workers dedicados
QUEUE_CONNECTION=redis

// 5. BASE DE DATOS - Réplicas de lectura
// config/database.php
'mysql' => [
    'read' => [
        'host' => [
            env('DB_READ_HOST_1'),
            env('DB_READ_HOST_2'),
        ],
    ],
    'write' => [
        'host' => env('DB_WRITE_HOST'),
    ],
    'sticky' => true, // Evita inconsistencias read-after-write
],

// 6. BROADCASTING - Redis Pub/Sub para websockets
BROADCAST_CONNECTION=redis
```

```yaml
# docker-compose.yml para escalado con Docker Swarm o Kubernetes
services:
  app:
    image: mi-app-laravel:latest
    deploy:
      replicas: 4
      resources:
        limits:
          cpus: '1'
          memory: 512M
    environment:
      - SESSION_DRIVER=redis
      - CACHE_DRIVER=redis
      - QUEUE_CONNECTION=redis

worker:
    image: mi-app-laravel:latest
    command: php artisan queue:work --tries=3 --timeout=90
    deploy:
      replicas: 2

scheduler:
    image: mi-app-laravel:latest
    command: php artisan schedule:work
    deploy:
      replicas: 1
```

Además del escalado de infraestructura, hay optimizaciones de código importantes: usar cache agresivamente, implementar eager loading, usar índices de base de datos adecuados, paginar resultados, usar `chunk()` para procesar grandes volúmenes, y configurar los cachés de Laravel (`route:cache`, `config:cache`, `view:cache`). Herramientas como Laravel Vapor (serverless en AWS Lambda) eliminan gran parte de la complejidad del escalado horizontal.

Question 28

¿Cómo optimizarías el rendimiento de una aplicación Laravel en producción?

Accepted Answer

La optimización del rendimiento en Laravel abarca múltiples capas: desde la configuración del framework hasta las consultas a base de datos, pasando por el servidor web y la infraestructura. Una estrategia completa debe abordar todas estas capas.

Lo primero es medir antes de optimizar. Herramientas como Laravel Telescope, Laravel Debugbar, Clockwork o servicios como New Relic te permiten identificar los cuellos de botella reales.

```php
// 1. CACHÉS DE FRAMEWORK (obligatorio en producción)
// php artisan optimize
// Equivale a:
// php artisan config:cache   → Cachea config en un solo archivo
// php artisan route:cache    → Serializa las rutas
// php artisan view:cache     → Precompila vistas Blade
// php artisan event:cache    → Cachea event/listener mappings

// 2. OPTIMIZAR CONSULTAS - Evitar N+1
// Detectar N+1 automáticamente en desarrollo
Model::preventLazyLoading(! app()->isProduction());

// Seleccionar solo columnas necesarias
$usuarios = User::select(['id', 'nombre', 'email'])
    ->with(['perfil:id,user_id,avatar'])
    ->paginate(20);

// Usar chunk para procesamiento masivo
User::where('activo', true)->chunk(1000, function ($usuarios) {
    foreach ($usuarios as $usuario) {
        // Procesar sin cargar todos en memoria
    }
});

// 3. CACHÉ INTELIGENTE
$estadisticas = Cache::remember('dashboard.stats', 300, function () {
    return [
        'usuarios_total' => User::count(),
        'pedidos_hoy' => Pedido::whereDate('created_at', today())->count(),
        'ingresos_mes' => Pedido::whereMonth('created_at', now()->month)->sum('total'),
    ];
});

// 4. ÍNDICES DE BASE DE DATOS
Schema::table('articulos', function (Blueprint $table) {
    $table->index(['estado', 'publicado_en']); // Índice compuesto
    $table->fullText('contenido');              // Full-text search
});

// 5. LAZY COLLECTIONS para archivos grandes
LazyCollection::make(function () {
    $handle = fopen('archivo_enorme.csv', 'r');
    while ($line = fgetcsv($handle)) {
        yield $line;
    }
})->chunk(1000)->each(function ($lineas) {
    // Procesar sin agotar memoria
});
```

```nginx
# 6. CONFIGURACIÓN NGINX optimizada
location ~* \.(css|js|jpg|jpeg|png|gif|ico|svg|woff2)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
}

gzip on;
gzip_types text/css application/javascript application/json;
```

Otras optimizaciones importantes: usar OPcache para PHP, configurar PHP-FPM con el número adecuado de workers, usar Redis para sesiones y caché, implementar CDN para assets estáticos, usar `defer`/`async` en scripts, y considerar Laravel Octane (Swoole/RoadRunner) que mantiene la aplicación en memoria entre peticiones, mejorando drásticamente los tiempos de respuesta.

Question 29

¿Cómo diseñarías un sistema de permisos y roles avanzado en Laravel?

Accepted Answer

Un sistema de permisos robusto debe ser flexible, performante y fácil de mantener. Aunque paquetes como Spatie Permission cubren la mayoría de casos, entender cómo diseñar uno desde cero es valioso para situaciones que requieren lógica personalizada.

El diseño típico utiliza tres tablas: `roles`, `permisos` y tablas pivote. Pero para sistemas más complejos, puede incluir permisos directos a usuarios, permisos contextuales (por recurso) y jerarquías de roles.

```php
// Migraciones base
Schema::create('roles', function (Blueprint $table) {
    $table->id();
    $table->string('nombre')->unique(); // admin, editor, moderador
    $table->string('descripcion')->nullable();
    $table->timestamps();
});

Schema::create('permisos', function (Blueprint $table) {
    $table->id();
    $table->string('nombre')->unique(); // articulos.crear, articulos.editar
    $table->string('modulo');            // articulos, usuarios, pedidos
    $table->timestamps();
});

// Trait reutilizable para verificación de permisos
trait TieneRolesYPermisos
{
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Rol::class);
    }

public function tieneRol(string ...$roles): bool
    {
        return $this->roles->pluck('nombre')->intersect($roles)->isNotEmpty();
    }

public function tienePermiso(string $permiso): bool
    {
        // Super admin tiene todo
        if ($this->tieneRol('super-admin')) {
            return true;
        }

return $this->roles
            ->flatMap->permisos
            ->pluck('nombre')
            ->contains($permiso);
    }
}

// Gate y Policy para autorización
// AppServiceProvider o AuthServiceProvider
Gate::before(function (User $user, string $habilidad) {
    if ($user->tieneRol('super-admin')) {
        return true; // Bypass total
    }
});

// Policy con permisos granulares
class ArticuloPolicy
{
    public function update(User $user, Articulo $articulo): bool
    {
        // Puede editar si tiene el permiso general
        // O si es el autor del artículo
        return $user->tienePermiso('articulos.editar')
            || $user->id === $articulo->user_id;
    }

public function delete(User $user, Articulo $articulo): bool
    {
        return $user->tienePermiso('articulos.eliminar');
    }
}

// Middleware personalizado
class VerificarPermiso
{
    public function handle(Request $request, Closure $next, string $permiso): mixed
    {
        if (! $request->user()->tienePermiso($permiso)) {
            abort(403, 'No tienes permiso para realizar esta acción.');
        }
        return $next($request);
    }
}

// Uso en rutas
Route::middleware('permiso:articulos.crear')
    ->post('/articulos', [ArticuloController::class, 'store']);
```

Para rendimiento, es crucial cachear los permisos del usuario (por ejemplo, cargarlos una vez por petición en un middleware y almacenarlos en caché con Redis). También considera usar `Gate::define()` para permisos simples y Policies para recursos específicos. En aplicaciones SaaS multi-tenant, los permisos pueden variar por tenant, lo que añade otra capa de complejidad que requiere scoping adecuado.

Question 30

¿Cómo desarrollarías un paquete reutilizable para Laravel?

Accepted Answer

Desarrollar un paquete de Laravel requiere entender el sistema de Service Providers, el auto-discovery, las convenciones de publicación de recursos y las mejores prácticas de distribución vía Composer.

Un paquete bien estructurado debe ser independiente, configurable, testeable y seguir las convenciones de la comunidad. La estructura de directorios y el archivo `composer.json` son la base de todo.

```json
// composer.json del paquete
{
    "name": "miempresa/laravel-facturacion",
    "description": "Sistema de facturación para Laravel",
    "type": "library",
    "require": {
        "php": "^8.2",
        "illuminate/support": "^11.0|^12.0"
    },
    "autoload": {
        "psr-4": {
            "MiEmpresa\Facturacion\": "src/"
        }
    },
    "extra": {
        "laravel": {
            "providers": [
                "MiEmpresa\Facturacion\FacturacionServiceProvider"
            ],
            "aliases": {
                "Facturacion": "MiEmpresa\Facturacion\Facades\Facturacion"
            }
        }
    }
}
```

```php
// Estructura del paquete
// packages/miempresa/laravel-facturacion/
// ├── config/facturacion.php
// ├── database/migrations/
// ├── resources/views/
// ├── src/
// │   ├── FacturacionServiceProvider.php
// │   ├── Facades/Facturacion.php
// │   ├── Models/Factura.php
// │   ├── Services/FacturacionManager.php
// │   └── Commands/GenerarFacturasMensuales.php
// ├── tests/
// └── composer.json

// Service Provider del paquete
class FacturacionServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/facturacion.php', 'facturacion'
        );

$this->app->singleton('facturacion', function ($app) {
            return new FacturacionManager(
                $app->make(Config::class),
                $app->make(PasarelaPagoInterface::class)
            );
        });
    }

public function boot(): void
    {
        // Publicar configuración
        $this->publishes([
            __DIR__.'/../config/facturacion.php' => config_path('facturacion.php'),
        ], 'facturacion-config');

// Publicar migraciones
        $this->publishesMigrations([
            __DIR__.'/../database/migrations' => database_path('migrations'),
        ], 'facturacion-migrations');

// Cargar rutas
        $this->loadRoutesFrom(__DIR__.'/../routes/api.php');

// Cargar vistas con namespace
        $this->loadViewsFrom(__DIR__.'/../resources/views', 'facturacion');

// Publicar vistas para personalización
        $this->publishes([
            __DIR__.'/../resources/views' => resource_path('views/vendor/facturacion'),
        ], 'facturacion-views');

// Registrar comando
        if ($this->app->runningInConsole()) {
            $this->commands([
                GenerarFacturasMensuales::class,
            ]);
        }
    }
}

// Facade
class Facturacion extends Facade
{
    protected static function getFacadeAccessor(): string
    {
        return 'facturacion';
    }
}

// Uso desde la aplicación
Facturacion::crearFactura($pedido);
// php artisan vendor:publish --tag=facturacion-config
```

Para testing del paquete, usa Orchestra Testbench que simula una aplicación Laravel completa. Para distribución, publica en Packagist conectado a tu repositorio Git. Usa versionado semántico y mantén un CHANGELOG. Herramientas como Laravel Package Boilerplate pueden acelerar la configuración inicial.

Question 31

¿Cómo implementarías Event Sourcing en una aplicación Laravel?

Accepted Answer

Event Sourcing es un patrón arquitectónico donde, en lugar de almacenar solo el estado actual de las entidades, se almacenan todos los eventos (cambios) que han ocurrido. El estado actual se reconstruye reproduciendo los eventos. Esto ofrece trazabilidad completa, capacidad de auditoría y la posibilidad de reconstruir el estado en cualquier punto del tiempo. En Laravel, puedes implementarlo manualmente o usar el paquete `spatie/laravel-event-sourcing`. Veamos un enfoque con el paquete de Spatie. ```php // 1. Definir eventos del dominio class DineroDepositado extends ShouldBeStored { public function __construct( public readonly int $cantidadCentimos, public readonly string $descripcion ) {} } class DineroRetirado extends ShouldBeStored { public function __construct( public readonly int $cantidadCentimos, public readonly string $descripcion ) {} } // 2. Aggregate Root - contiene la lógica de negocio class CuentaBancariaAggregate extends AggregateRoot { private int $saldo = 0; private int $limiteDescubierto = 0; public function depositar(int $cantidadCentimos, string $descripcion): self { if ($cantidadCentimos <= 0) { throw new CantidadInvalidaException('El depósito debe ser positivo.'); } $this->recordThat(new DineroDepositado($cantidadCentimos, $descripcion)); return $this; } public function retirar(int $cantidadCentimos, string $descripcion): self { $nuevoSaldo = $this->saldo - $cantidadCentimos; if ($nuevoSaldo < -$this->limiteDescubierto) { throw new FondosInsuficientesException( "Saldo insuficiente. Disponible: {$this->saldo}" ); } $this->recordThat(new DineroRetirado($cantidadCentimos, $descripcion)); return $this; } // Estos métodos reconstruyen el estado a partir de los eventos protected function applyDineroDepositado(DineroDepositado $event): void { $this->saldo += $event->cantidadCentimos; } protected function applyDineroRetirado(DineroRetirado $event): void { $this->saldo -= $event->cantidadCentimos; } } // 3. Projector - Actualiza las vistas de lectura (read models) class CuentaBancariaProjector extends Projector { public function onDineroDepositado( DineroDepositado $event, string $aggregateUuid ): void { $cuenta = CuentaBancaria::findByUuid($aggregateUuid); $cuenta->saldo += $event->cantidadCentimos; $cuenta->save(); } public function onDineroRetirado( DineroRetirado $event, string $aggregateUuid ): void { $cuenta = CuentaBancaria::findByUuid($aggregateUuid); $cuenta->saldo -= $event->cantidadCentimos; $cuenta->save(); } } // 4. Uso en controlador public function depositar(DepositoRequest $request, string $cuentaUuid) { CuentaBancariaAggregate::retrieve($cuentaUuid) ->depositar( $request->cantidad_centimos, $request->descripcion ) ->persist(); return response()->json(['mensaje' => 'Depósito realizado']); } ``` Event Sourcing es ideal para sistemas financieros, auditoría, sistemas con historial completo y cuando necesitas reproducir eventos para debugging. Sin embargo, aumenta significativamente la complejidad: necesitas projectors para las vistas de lectura, snapshots para optimizar la reconstrucción de aggregates con muchos eventos, y un buen entendimiento de CQRS (Command Query Responsibility Segregation). No lo uses si tu dominio es CRUD simple.

Question 32

¿Cómo configurarías un pipeline de CI/CD completo para una aplicación Laravel?

Accepted Answer

Un pipeline de CI/CD para Laravel debe automatizar la ejecución de tests, análisis de código, building de assets y despliegue. La configuración varía según la plataforma (GitHub Actions, GitLab CI, Jenkins), pero los principios son los mismos.

Veamos un ejemplo completo con GitHub Actions que cubre testing, análisis estático y despliegue.

```yaml
# .github/workflows/ci.yml
name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  tests:
    runs-on: ubuntu-latest

services:
      mysql:
        image: mysql:8.0
        env:
          MYSQL_ROOT_PASSWORD: password
          MYSQL_DATABASE: testing
        ports:
          - 3306:3306
        options: >-
          --health-cmd="mysqladmin ping"
          --health-interval=10s
          --health-timeout=5s
          --health-retries=3
      redis:
        image: redis:7
        ports:
          - 6379:6379

steps:
      - uses: actions/checkout@v4

- name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.3'
          extensions: mbstring, pdo_mysql, redis
          coverage: xdebug

- name: Cache Composer
        uses: actions/cache@v4
        with:
          path: vendor
          key: composer-${{ hashFiles('composer.lock') }}

- name: Install dependencies
        run: composer install --no-interaction --prefer-dist

- name: Prepare environment
        run: |
          cp .env.ci .env
          php artisan key:generate
          php artisan migrate --force

- name: Run tests
        run: php artisan test --parallel --coverage-clover=coverage.xml

- name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: coverage.xml

code-quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

- name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.3'

- name: Install dependencies
        run: composer install --no-interaction

- name: PHPStan
        run: vendor/bin/phpstan analyse --memory-limit=512M

- name: Pint (code style)
        run: vendor/bin/pint --test

deploy:
    needs: [tests, code-quality]
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: ubuntu-latest

steps:
      - uses: actions/checkout@v4

- name: Deploy to production
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.DEPLOY_HOST }}
          username: ${{ secrets.DEPLOY_USER }}
          key: ${{ secrets.DEPLOY_KEY }}
          script: |
            cd /var/www/mi-app
            php artisan down --retry=60
            git pull origin main
            composer install --no-dev --optimize-autoloader
            php artisan migrate --force
            php artisan optimize
            npm ci && npm run build
            php artisan queue:restart
            php artisan up
```

```php
// .env.ci para el pipeline
APP_ENV=testing
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_DATABASE=testing
DB_USERNAME=root
DB_PASSWORD=password
CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis
```

Consideraciones importantes: usa `--no-dev` en producción para excluir dependencias de desarrollo, ejecuta `php artisan optimize` para cachear todo, usa `php artisan down` con `--retry` para indicar al load balancer cuándo reintentarlo, y reinicia los workers de cola tras cada deploy. Para zero-downtime deployments, herramientas como Envoyer, Deployer o scripts con enlaces simbólicos son más adecuados que el enfoque de git pull directo.

Question 33

¿Cómo implementarías una arquitectura multi-tenant en Laravel?

Accepted Answer

Una aplicación multi-tenant sirve a múltiples clientes (tenants) desde una sola instalación. Hay tres enfoques principales: base de datos compartida con columna `tenant_id`, base de datos separada por tenant, y esquema separado por tenant. La elección depende de los requisitos de aislamiento, escala y complejidad.

El enfoque más común en Laravel es la base de datos compartida con columna `tenant_id`, usando scopes globales para filtrar automáticamente todos los datos por tenant.

```php
// 1. IDENTIFICACIÓN DEL TENANT
// Middleware que identifica el tenant por subdominio
class IdentificarTenant
{
    public function handle(Request $request, Closure $next): mixed
    {
        $subdominio = explode('.', $request->getHost())[0];
        $tenant = Tenant::where('subdominio', $subdominio)->firstOrFail();

// Almacenar el tenant actual en el container
        app()->instance('tenant.actual', $tenant);

// Configurar conexión si usamos BD separada
        // Config::set('database.connections.tenant.database', $tenant->database);

return $next($request);
    }
}

// 2. SCOPE GLOBAL para filtrar por tenant automáticamente
class TenantScope implements Scope
{
    public function apply(Builder $builder, Model $model): void
    {
        if ($tenant = app('tenant.actual', null)) {
            $builder->where($model->getTable() . '.tenant_id', $tenant->id);
        }
    }
}

// Trait para modelos multi-tenant
trait PerteneceATenant
{
    protected static function bootPerteneceATenant(): void
    {
        static::addGlobalScope(new TenantScope());

static::creating(function (Model $model) {
            if ($tenant = app('tenant.actual', null)) {
                $model->tenant_id = $tenant->id;
            }
        });
    }

public function tenant(): BelongsTo
    {
        return $this->belongsTo(Tenant::class);
    }
}

// 3. Uso en modelos - simplemente añade el trait
class Producto extends Model
{
    use PerteneceATenant;

protected $fillable = ['nombre', 'precio', 'tenant_id'];
}

// Las consultas se filtran automáticamente
// Si el tenant actual es "Empresa A":
Producto::all(); // Solo productos de Empresa A
Producto::create(['nombre' => 'Widget']); // tenant_id se asigna automáticamente

// 4. JOBS Y COLAS - Preservar el contexto del tenant
class ProcesarPedido implements ShouldQueue
{
    public function __construct(
        public readonly int $tenantId,
        public readonly Pedido $pedido
    ) {}

public function handle(): void
    {
        // Restaurar contexto del tenant en el worker
        $tenant = Tenant::findOrFail($this->tenantId);
        app()->instance('tenant.actual', $tenant);

// Ahora las consultas están filtradas correctamente
        $this->pedido->procesar();
    }
}

// 5. CACHÉ con prefijo por tenant
class TenantCacheManager
{
    public static function get(string $key, mixed $default = null): mixed
    {
        $prefix = 'tenant_' . app('tenant.actual')->id;
        return Cache::get("{$prefix}:{$key}", $default);
    }
}
```

Para implementaciones robustas, paquetes como `stancl/tenancy` automatizan gran parte de esta complejidad, incluyendo la gestión de bases de datos separadas, cache isolation, queue context y más. Los aspectos críticos a considerar son: aislamiento de datos (un tenant nunca debe ver datos de otro), rendimiento (índices en `tenant_id`), caché aislada, migraciones por tenant, y estrategias de backup. En escalas muy grandes, considera sharding: grupos de tenants en diferentes servidores de base de datos.

Question 34

¿Cómo manejarías las migraciones de base de datos en un entorno de producción con zero downtime?

Accepted Answer

Las migraciones en producción con zero downtime requieren un enfoque cuidadoso porque las migraciones que bloquean tablas o son incompatibles con el código actual pueden causar errores durante el despliegue. La clave es hacer migraciones compatibles con las versiones anterior y nueva del código.

El principio fundamental es: la migración debe ser compatible con el código antes Y después del despliegue. Esto se logra dividiendo cambios destructivos en múltiples pasos de despliegue.

```php
// EJEMPLO: Renombrar una columna de 'nombre' a 'nombre_completo'

// ❌ MAL: Un solo despliegue - romperá la aplicación
// Schema::table('users', fn ($t) => $t->renameColumn('nombre', 'nombre_completo'));

// ✅ BIEN: Tres despliegues separados

// DESPLIEGUE 1: Añadir nueva columna y sincronizar datos
// Migración:
public function up(): void
{
    Schema::table('users', function (Blueprint $table) {
        $table->string('nombre_completo')->nullable()->after('nombre');
    });

// Copiar datos existentes
    DB::statement('UPDATE users SET nombre_completo = nombre');
}

// Modelo: leer de nombre_completo, escribir en ambas
class User extends Model
{
    protected static function booted(): void
    {
        static::saving(function (User $user) {
            $user->nombre_completo = $user->nombre_completo ?? $user->nombre;
            $user->nombre = $user->nombre_completo; // Mantener sincronizado
        });
    }
}

// DESPLIEGUE 2: Código usa solo nombre_completo
// Actualizar todo el código para usar nombre_completo
// La columna nombre sigue existiendo pero ya no se usa

// DESPLIEGUE 3: Eliminar columna antigua
public function up(): void
{
    Schema::table('users', function (Blueprint $table) {
        $table->dropColumn('nombre');
    });
}

// PARA TABLAS GRANDES: Usar migraciones no bloqueantes
// En MySQL, ALTER TABLE en tablas grandes puede bloquear por minutos

// Opción 1: pt-online-schema-change (Percona Toolkit)
// Crea una tabla temporal, copia datos y hace swap
public function up(): void
{
    if (app()->isProduction()) {
        DB::statement(
            "pt-online-schema-change --alter 'ADD INDEX idx_estado (estado)' "
            . "D=miapp,t=pedidos --execute"
        );
    } else {
        Schema::table('pedidos', fn ($t) => $t->index('estado'));
    }
}

// Opción 2: Crear índices CONCURRENTLY (PostgreSQL)
public function up(): void
{
    DB::statement(
        'CREATE INDEX CONCURRENTLY idx_pedidos_estado ON pedidos (estado)'
    );
}
```

```php
// Script de despliegue zero-downtime con symbolic links
// deploy.sh
$nuevaRelease = "/var/www/releases/" . date('YmdHis');
$enlaceActual = "/var/www/current";

// 1. Preparar nueva release
// git clone, composer install, npm build...

// 2. Ejecutar migraciones (compatible con código anterior)
// php artisan migrate --force

// 3. Cambiar el enlace simbólico (atómico)
// ln -sfn $nuevaRelease $enlaceActual

// 4. Recargar PHP-FPM (no restart)
// kill -USR2 $(cat /var/run/php-fpm.pid)

// 5. Reiniciar workers de cola
// php artisan queue:restart
```

Reglas de oro para migraciones en producción: nunca renombres ni elimines columnas en uso, siempre añade columnas como `nullable` o con valor por defecto, usa `after()` para documentar la posición, y testea las migraciones en un entorno de staging con datos reales. Herramientas como Laravel Envoyer o Deployer automatizan el flujo de zero-downtime deployment.

Question 35

¿Cómo implementarías un sistema de búsqueda avanzada en Laravel?

Accepted Answer

Un sistema de búsqueda avanzada en Laravel puede implementarse de varias formas según la complejidad: desde consultas SQL con LIKE hasta motores de búsqueda completos como Meilisearch o Elasticsearch. Laravel Scout proporciona una API unificada para integrar motores de búsqueda full-text.

Para proyectos pequeños-medianos, las búsquedas SQL con índices full-text pueden ser suficientes. Para búsquedas más sofisticadas con relevancia, filtros facetados y tolerancia a errores tipográficos, Meilisearch es la opción recomendada.

```php
// OPCIÓN 1: Búsqueda SQL con filtros dinámicos
class BuscadorArticulos
{
    public function buscar(BusquedaDTO $filtros): LengthAwarePaginator
    {
        return Articulo::query()
            ->with(['autor', 'etiquetas', 'categoria'])
            ->when($filtros->termino, function ($query, $termino) {
                $query->where(function ($q) use ($termino) {
                    $q->whereFullText(['titulo', 'contenido'], $termino)
                      ->orWhere('titulo', 'like', "%{$termino}%");
                });
            })
            ->when($filtros->categoria, function ($query, $categoria) {
                $query->where('categoria_id', $categoria);
            })
            ->when($filtros->etiquetas, function ($query, $etiquetas) {
                $query->whereHas('etiquetas', function ($q) use ($etiquetas) {
                    $q->whereIn('slug', $etiquetas);
                });
            })
            ->when($filtros->fechaDesde, function ($query, $fecha) {
                $query->where('publicado_en', '>=', $fecha);
            })
            ->when($filtros->ordenar === 'popular', function ($query) {
                $query->orderByDesc('visitas');
            }, function ($query) {
                $query->latest('publicado_en');
            })
            ->publicado()
            ->paginate($filtros->porPagina)
            ->withQueryString();
    }
}

// OPCIÓN 2: Laravel Scout con Meilisearch
// composer require laravel/scout meilisearch/meilisearch-php

class Articulo extends Model
{
    use Searchable;

// Datos a indexar en el motor de búsqueda
    public function toSearchableArray(): array
    {
        return [
            'id' => $this->id,
            'titulo' => $this->titulo,
            'contenido' => strip_tags($this->contenido),
            'categoria' => $this->categoria->nombre,
            'etiquetas' => $this->etiquetas->pluck('nombre')->toArray(),
            'autor' => $this->autor->nombre,
            'publicado_en_timestamp' => $this->publicado_en?->timestamp,
            'visitas' => $this->visitas,
        ];
    }

// Configurar filtros y ordenación en Meilisearch
    // AppServiceProvider
    public function boot(): void
    {
        Articulo::search('', function ($meilisearch, $query, $options) {
            $meilisearch->updateFilterableAttributes([
                'categoria', 'etiquetas', 'publicado_en_timestamp'
            ]);
            $meilisearch->updateSortableAttributes([
                'publicado_en_timestamp', 'visitas'
            ]);
        });
    }
}

// Uso de Scout
$resultados = Articulo::search($termino)
    ->where('categoria', 'Laravel')
    ->orderBy('publicado_en_timestamp', 'desc')
    ->paginate(15);
```

Meilisearch ofrece ventajas significativas: búsqueda con tolerancia a typos, resultados casi instantáneos (<50ms), filtros facetados, highlighting de coincidencias y relevancia personalizable. Para el indexado inicial ejecuta `php artisan scout:import "App\Models\Articulo"`. Los modelos se resincronizan automáticamente al crear, actualizar o eliminar registros.

Question 36

¿Cómo gestionarías la seguridad integral de una aplicación Laravel?

Accepted Answer

La seguridad en Laravel abarca múltiples capas: protección contra vulnerabilidades web comunes, autenticación robusta, autorización granular, protección de datos sensibles y monitorización. Laravel incluye protecciones por defecto, pero es responsabilidad del desarrollador configurarlas correctamente y añadir capas adicionales. Veamos las áreas principales de seguridad y cómo abordarlas. ```php // 1. PROTECCIÓN CSRF - Incluida por defecto en rutas web // Blade lo incluye automáticamente en formularios: // 2. PROTECCIÓN XSS - Blade escapa por defecto {{ $variable }} // Escapado - SEGURO {!! $variable !!} // Sin escapar - PELIGROSO, solo para HTML de confianza // Sanitizar HTML cuando sea necesario use Stevebauman\Purify\Facades\Purify; $contenidoLimpio = Purify::clean($request->input('contenido')); // 3. PROTECCIÓN SQL INJECTION - Eloquent y Query Builder son seguros // ❌ NUNCA hagas esto: DB::select("SELECT * FROM users WHERE email = '$email'"); // ✅ Usa bindings: DB::select('SELECT * FROM users WHERE email = ?', [$email]); // 4. RATE LIMITING para prevenir ataques de fuerza bruta // bootstrap/app.php RateLimiter::for('login', function (Request $request) { return Limit::perMinute(5)->by( $request->input('email') . '|' . $request->ip() )->response(function () { return response('Demasiados intentos. Espera un minuto.', 429); }); }); // 5. ENCRIPTACIÓN DE DATOS SENSIBLES class Usuario extends Model { protected function casts(): array { return [ 'password' => 'hashed', 'dni' => 'encrypted', // Encriptado en BD 'datos_bancarios' => 'encrypted:array', ]; } } // 6. HEADERS DE SEGURIDAD - Middleware personalizado class HeadersSeguridad { 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', 'SAMEORIGIN'); $response->headers->set('X-XSS-Protection', '1; mode=block'); $response->headers->set('Referrer-Policy', 'strict-origin-when-cross-origin'); $response->headers->set( 'Content-Security-Policy', "default-src 'self'; script-src 'self' 'nonce-" . csp_nonce() . "'" ); $response->headers->set( 'Strict-Transport-Security', 'max-age=31536000; includeSubDomains' ); return $response; } } // 7. VALIDACIÓN ESTRICTA DE UPLOADS $request->validate([ 'documento' => [ 'required', 'file', 'mimes:pdf,doc,docx', 'max:10240', // 10MB function ($attribute, $value, $fail) { // Verificar MIME type real, no solo la extensión $mime = $value->getMimeType(); if (!in_array($mime, ['application/pdf', 'application/msword'])) { $fail('El tipo de archivo no es válido.'); } }, ], ]); // Almacenar fuera de public/ $path = $request->file('documento')->store('documentos', 'private'); ``` Además del código, implementa: autenticación multifactor (2FA), rotación de claves de aplicación, auditoría de acciones sensibles, monitorización de logs en tiempo real, actualizaciones regulares de dependencias (`composer audit`), y revisiones de seguridad periódicas. Herramientas como `enlightn/enlightn` analizan tu aplicación Laravel en busca de problemas de seguridad y rendimiento.

Question 37

¿Cuál es la diferencia entre eager loading, lazy loading y lazy eager loading en Eloquent?

Accepted Answer

Estas tres estrategias determinan cuándo y cómo Eloquent carga las relaciones de un modelo, y elegir la correcta tiene un impacto directo en el rendimiento de tu aplicación.

**Lazy Loading** es el comportamiento por defecto: las relaciones se cargan solo cuando se accede a ellas por primera vez. Esto provoca el famoso problema N+1, donde por cada modelo se ejecuta una consulta adicional.

**Eager Loading** (`with()`) carga las relaciones junto con la consulta principal usando solo una o dos consultas SQL, independientemente del número de registros.

**Lazy Eager Loading** (`load()`) permite cargar relaciones después de haber obtenido los modelos, útil cuando no sabes de antemano qué relaciones necesitarás.

```php
// LAZY LOADING - Problema N+1
// 1 consulta para obtener 100 posts + 100 consultas para cada autor = 101 consultas
$posts = Post::all(); // SELECT * FROM posts
foreach ($posts as $post) {
    echo $post->autor->nombre; // SELECT * FROM users WHERE id = ? (x100)
}

// EAGER LOADING - Solo 2 consultas
$posts = Post::with('autor')->get();
// SELECT * FROM posts
// SELECT * FROM users WHERE id IN (1, 2, 3, ...)
foreach ($posts as $post) {
    echo $post->autor->nombre; // No ejecuta consulta adicional
}

// Eager loading con restricciones
$posts = Post::with(['comentarios' => function ($query) {
    $query->where('aprobado', true)->latest()->limit(5);
}, 'autor:id,nombre,avatar'])->get();

// Eager loading anidado
$posts = Post::with('autor.perfil.redes_sociales')->get();

// LAZY EAGER LOADING - Cargar después
$posts = Post::all();
if ($necesitaAutores) {
    $posts->load('autor'); // Carga la relación para toda la colección
}

// Cargar conteos sin los modelos relacionados
$posts = Post::withCount('comentarios')->get();
// Acceder: $post->comentarios_count

// Prevenir lazy loading en desarrollo para detectar N+1
// AppServiceProvider
public function boot(): void
{
    Model::preventLazyLoading(! app()->isProduction());

// O solo registrar en vez de lanzar excepción
    Model::handleLazyLoadingViolationUsing(function ($model, $relation) {
        Log::warning("Lazy loading detectado: {$model}::{$relation}");
    });
}
```

La regla general es: usa eager loading (`with()`) siempre que sepas qué relaciones necesitarás, especialmente en listas y bucles. Usa lazy eager loading (`load()`) cuando la decisión dependa de condiciones en runtime. Activa `preventLazyLoading()` en desarrollo para detectar problemas N+1 antes de que lleguen a producción.

Question 38

¿Cómo implementarías rate limiting avanzado en una API Laravel?

Accepted Answer

El rate limiting (limitación de tasa) protege tu API contra abuso, ataques DDoS y garantiza un uso justo de los recursos. Laravel incluye un sistema de rate limiting flexible basado en el middleware `throttle` que se puede personalizar por ruta, usuario, plan o combinaciones de estos.

Desde Laravel 11, el rate limiting se configura en `bootstrap/app.php` o en un Service Provider, usando la clase `RateLimiter`.

```php
// AppServiceProvider o bootstrap/app.php
use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

public function boot(): void
{
    // Límite global por IP para la API
    RateLimiter::for('api', function (Request $request) {
        return Limit::perMinute(60)->by(
            $request->user()?->id ?: $request->ip()
        );
    });

// Límite diferente según el plan del usuario
    RateLimiter::for('api-plan', function (Request $request) {
        $usuario = $request->user();

if (!$usuario) {
            return Limit::perMinute(10)->by($request->ip());
        }

return match ($usuario->plan) {
            'enterprise' => Limit::none(), // Sin límite
            'pro'        => Limit::perMinute(300)->by($usuario->id),
            'basic'      => Limit::perMinute(60)->by($usuario->id),
            default      => Limit::perMinute(30)->by($usuario->id),
        };
    });

// Límite estricto para endpoints sensibles
    RateLimiter::for('login', function (Request $request) {
        $clave = $request->input('email') . '|' . $request->ip();

return [
            // 5 intentos por minuto por email+IP
            Limit::perMinute(5)->by($clave),
            // 15 intentos por hora por IP (contra ataques distribuidos)
            Limit::perHour(15)->by($request->ip()),
        ];
    });

// Rate limit para webhooks por proveedor
    RateLimiter::for('webhooks', function (Request $request) {
        return Limit::perMinute(100)
            ->by($request->header('X-Webhook-Provider', $request->ip()))
            ->response(function (Request $request, array $headers) {
                return response()->json([
                    'error' => 'Demasiadas peticiones',
                    'retry_after' => $headers['Retry-After'],
                ], 429, $headers);
            });
    });
}

// Aplicar en rutas
Route::middleware('throttle:api-plan')->group(function () {
    Route::apiResource('articulos', ArticuloController::class);
});

Route::post('/login', LoginController::class)
    ->middleware('throttle:login');

// Rate limiting manual en un controlador
public function enviarCodigo(Request $request)
{
    $clave = 'verificacion:' . $request->user()->id;

if (RateLimiter::tooManyAttempts($clave, 3)) {
        $segundos = RateLimiter::availableIn($clave);
        return response()->json([
            'error' => "Espera {$segundos} segundos antes de solicitar otro código.",
        ], 429);
    }

RateLimiter::hit($clave, 300); // Decae en 5 minutos

// Enviar código...
}
```

Laravel incluye automáticamente headers informativos en las respuestas (`X-RateLimit-Limit`, `X-RateLimit-Remaining`, `Retry-After`) para que los clientes de la API puedan adaptar su comportamiento. En producción, usa Redis como driver de caché para que los contadores sean compartidos entre todos los servidores. Para APIs públicas de alto tráfico, considera añadir rate limiting a nivel de CDN (Cloudflare) o load balancer como primera capa de defensa.

Question 39

¿Qué es Laravel Octane y cuándo deberías usarlo?

Accepted Answer

Laravel Octane es un paquete oficial que mejora drásticamente el rendimiento de las aplicaciones Laravel ejecutándolas sobre servidores de aplicaciones de alto rendimiento como Swoole, RoadRunner o FrankenPHP. A diferencia del modelo tradicional donde PHP inicia y destruye la aplicación en cada petición, Octane mantiene la aplicación en memoria y reutiliza el framework bootstrap entre peticiones.

Esto puede multiplicar el rendimiento entre 2x y 10x dependiendo de la aplicación, ya que elimina el coste de cargar archivos, resolver el contenedor y compilar configuración en cada petición.

```php
// Instalación
// composer require laravel/octane
// php artisan octane:install (elegir Swoole, RoadRunner o FrankenPHP)

// Iniciar servidor Octane
// php artisan octane:start --server=swoole --workers=4
// php artisan octane:start --server=frankenphp

// ⚠️ CUIDADO: Estado compartido entre peticiones
// Lo que NO debes hacer con Octane:

// ❌ Variables estáticas o singletons con estado por petición
class ServicioProblematico
{
    private static array $datos = []; // ¡Se comparte entre peticiones!

public static function agregar(string $dato): void
    {
        static::$datos[] = $dato; // Se acumula entre peticiones = memory leak
    }
}

// ✅ Usar el container con scoped bindings
$this->app->scoped(CarritoService::class, function () {
    return new CarritoService(); // Nueva instancia por petición
});

// ✅ Usar Octane's Concurrent Tasks para paralelizar
use Laravel\Octane\Facades\Octane;

public function dashboard()
{
    [$usuarios, $pedidos, $ingresos] = Octane::concurrently([
        fn () => User::count(),
        fn () => Pedido::whereMonth('created_at', now())->count(),
        fn () => Pedido::whereMonth('created_at', now())->sum('total'),
    ]);

return view('dashboard', compact('usuarios', 'pedidos', 'ingresos'));
}

// ✅ Octane Cache - Caché en memoria ultra-rápida (key-value store de Swoole)
use Laravel\Octane\Facades\Octane;

Octane::cache()->set('visitas_hoy', 0);
Octane::cache()->increment('visitas_hoy');
$visitas = Octane::cache()->get('visitas_hoy');

// ✅ Tick para tareas periódicas
Octane::tick('limpiar-cache', function () {
    Cache::forget('datos_temporales');
})->seconds(60);
```

Deberías usar Octane cuando: necesites alta concurrencia (APIs con mucho tráfico), quieras reducir latencia al mínimo, o necesites ejecutar tareas concurrentes dentro de una petición. No lo uses si: tu aplicación depende mucho de estado global mutable, usas paquetes incompatibles con Octane, o el bottleneck es la base de datos (Octane no acelerará consultas lentas). Siempre testea exhaustivamente tu aplicación bajo Octane, ya que los problemas de estado compartido pueden ser sutiles y difíciles de detectar.

Question 40

¿Qué es el patrón Action en Laravel y cómo lo implementarías?

Accepted Answer

El patrón Action consiste en crear clases dedicadas a ejecutar una única operación de negocio, siguiendo el principio de responsabilidad única (SRP). A diferencia de meter toda la lógica en el controlador, una Action encapsula la operación en una clase reutilizable que puede invocarse desde controladores, comandos Artisan, Jobs o tests.

Una Action básica tiene un método público `handle` con la lógica de la operación:

```php
class CreateInvoiceAction
{
    public function __construct(
        private readonly TaxCalculator $taxCalculator,
    ) {}

public function handle(User $user, array $items): Invoice
    {
        $subtotal = collect($items)->sum('price');
        $tax = $this->taxCalculator->calculate($subtotal);

return Invoice::create([
            'user_id' => $user->id,
            'subtotal' => $subtotal,
            'tax' => $tax,
            'total' => $subtotal + $tax,
        ]);
    }
}

// Desde un controlador
public function store(Request $request, CreateInvoiceAction $action)
{
    $invoice = $action->handle($request->user(), $request->validated('items'));
    return redirect()->route('invoices.show', $invoice);
}
```

Aunque Laravel no incluye un estándar oficial para Actions, el paquete [Laractions](https://github.com/edulazaro/laractions) proporciona una arquitectura completa: generación con `php artisan make:action`, una clase base `Action`, ejecución con `create()->run()`, soporte para vincular Actions a modelos con el trait `HasActions`, ejecución asíncrona mediante colas, trazabilidad y mocking para tests.

```php
use EduLazaro\Laractions\Action;

class SendEmailAction extends Action
{
    public function handle(string $email, string $subject, string $message)
    {
        // Lógica de envío
    }
}

// Ejecutar
SendEmailAction::create()->run('user@example.com', 'Bienvenido', 'Hola');

// O desde un modelo con HasActions
$user->action('send_email')->run('user@example.com', 'Bienvenido', 'Hola');
```

Las Actions son ideales para mantener los controladores ligeros y la lógica de negocio reutilizable y testeable. Son una alternativa más granular que los Service classes cuando cada operación es lo bastante independiente como para vivir en su propia clase.

Preguntas de entrevista Laravel

Prepara tu entrevista de trabajo Laravel