Laravel Pipelines: La Guía Definitiva para Escribir Código Modular, Limpio y Extensible

Los Pipelines en Laravel son una de esas características avanzadas del framework que permiten transformar datos o ejecutar una secuencia de tareas sobre un objeto, paso a paso y de forma totalmente modular. Aunque no siempre son tan mencionados como los Jobs, Events o Middleware, los Pipelines representan una solución elegante para mantener un código limpio, desacoplado y altamente mantenible.

Este patrón es especialmente útil cuando tienes múltiples operaciones encadenadas sobre un mismo elemento y quieres desacoplar la lógica en pequeñas unidades reutilizables.

En esta guía aprenderás:

• Qué es un Pipeline y cómo funciona en Laravel

• Cuándo deberías usarlo

• Cómo implementarlo paso a paso

• Un ejemplo real orientado a negocios, útil para tus proyectos

• Buenas prácticas en proyectos profesionales

¿Qué es un Pipeline?

Un Pipeline es una cadena de tareas que se ejecutan en orden sobre un objeto o datos determinados. Cada etapa del Pipeline recibe el resultado de la anterior, lo procesa y lo envía al siguiente paso.

En Laravel, el componente

Illuminate\Pipeline\Pipeline

app(Pipeline::class)
    ->send($input)
    ->through([Paso1::class, Paso2::class, Paso3::class])
    ->thenReturn();

Es decir:

1. send()

   → Envia los datos iniciales

2. through()

   → Define los pasos a ejecutar

3. thenReturn()

   → Devuelve el resultado final

¿Cuándo deberías usar un Pipeline?

Los Pipelines son ideales cuando:

✔ Tienes procesos con múltiples pasos secuenciales

Ejemplo: validación → normalización → transformación → persistencia.

✔ Necesitas mantener el código desacoplado

Cada paso vive en su propia clase.

✔ Quieres activar/desactivar pasos según configuraciones

Muy útil en aplicaciones escalables.

✔ Estás procesando datos importados, pagos, pedidos, etc.

Ejemplo real: Procesar una orden antes de guardarla

Caso real de negocio

Imagina que en tu aplicación de ventas necesitas procesar un pedido antes de guardarlo en la base de datos:

1. Validar que los productos existan

2. Aplicar descuentos automáticos del cliente

3. Calcular impuestos

4. Normalizar los totales

5. Registrar el pedido

Con Pipelines tendrás esto desacoplado en pasos pequeños, ordenados y mantenibles.

1. Crear los pasos del Pipeline

Paso 1: Validar los productos

namespace App\Pipelines\Order;

class ValidateProducts
{
    public function handle($order, $next)
    {
        if (empty($order['items'])) {
            throw new \Exception("La orden no tiene productos.");
        }

        // Validar existencias...
        // Product::findOrFail(...)...

        return $next($order);
    }
}

Paso 2: Aplicar descuentos

namespace App\Pipelines\Order;

class ApplyDiscounts
{
    public function handle($order, $next)
    {
        $order['discount'] = $order['subtotal'] > 2000 ? 0.10 : 0;

        return $next($order);
    }
}

Paso 3: Calcular impuestos

namespace App\Pipelines\Order;

class CalculateTaxes
{
    public function handle($order, $next)
    {
        $order['tax'] = ($order['subtotal'] - ($order['subtotal'] * $order['discount'])) * 0.16;

        return $next($order);
    }
}

Paso 4: Normalizar totales

namespace App\Pipelines\Order;

class NormalizeTotals
{
    public function handle($order, $next)
    {
        $order['total'] = ($order['subtotal'] - ($order['subtotal'] * $order['discount'])) + $order['tax'];

        return $next($order);
    }
}

2. Ejecutar el Pipeline

use Illuminate\Pipeline\Pipeline;
use App\Pipelines\Order\{
    ValidateProducts,
    ApplyDiscounts,
    CalculateTaxes,
    NormalizeTotals
};

class ProcessOrderService
{
    public function handle(array $order)
    {
        return app(Pipeline::class)
            ->send($order)
            ->through([
                ValidateProducts::class,
                ApplyDiscounts::class,
                CalculateTaxes::class,
                NormalizeTotals::class,
            ])
            ->thenReturn();
    }
}

3. Usarlo en un controlador

public function store(Request $request)
{
    $order = (new ProcessOrderService)->handle($request->all());

    Order::create($order);

    return response()->json([
        'message' => 'Orden procesada correctamente',
        'order' => $order
    ]);
}

Beneficios reales en producción

✔ Código ultra limpio

Sin controladores gigantes ni servicios monolíticos.

✔ Pasos reutilizables

Puedes usar

ApplyDiscounts

✔ Fácil de cambiar o extender

Solo agregas o quitas pasos en el

through()

✔ Ideal para lógica empresarial compleja

Pedidos, pagos, importaciones, campañas, etc.

Conclusión

Laravel Pipelines te permiten escribir código altamente modular, flexible y elegante. Si tu aplicación procesa datos a través de múltiples pasos, este patrón te dará una arquitectura limpia digna de aplicaciones empresariales.

Implementarlos correctamente mejorará:

• mantenibilidad

• escalabilidad

• reusabilidad

• claridad

Es un patrón esencial si buscas escribir código profesional, especialmente en entornos de alta demanda.