PATRÓN PIPELINE EN LARAVEL

El Patrón Pipeline permite que los datos pasen a través de una serie de clases llamadas "Pipes".

Cada pipe realiza una sola tarea y pasa los datos al siguiente pipe.

Divide tu lógica en pasos pequeños haciendo que el código sea limpio, reutilizable y fácil de probar.

Input → Pipe 1 → Pipe 2 → Pipe 3 → Output

Cómo usar el Patrón Pipeline en Laravel

use Illuminate\Pipeline\Pipeline;

$result = app(Pipeline::class)
    ->send($data)
    ->through([
        ValidateData::class,
        SanitizeData::class,
        SaveData::class,
    ])
    ->thenReturn();

Este código envía los datos a través de varios pipes y devuelve el resultado final.

Ejemplos de Pipes

  1. ValidateData
    class ValidateData
    {
        public function handle($data, $next)
        {
            // validar los datos
            return $next($data);
        }
    }
    

    Valida los datos entrantes.

  2. SanitizeData
    class SanitizeData
    {
        public function handle($data, $next)
        {
            // limpiar y sanitizar los datos
            return $next($data);
        }
    }
    

    Limpia y prepara los datos.

  3. SaveData
    class SaveData
    {
        public function handle($data, $next)
        {
            // guardar en la base de datos
            $model = Model::create($data);
            return $next($model);
        }
    }
    

    Guarda los datos y devuelve el resultado.

¿Por qué usar el Patrón Pipeline?

  • Rompe la lógica grande en pasos pequeños.
  • Fácil de leer y entender.
  • Altamente reutilizable.
  • Fácil de probar cada paso individualmente.
  • Fácil de extender o modificar.

Casos de uso en el mundo real

  • Procesamiento y transformación de datos.
  • Filtrado y validación de peticiones.
  • Flujos de procesamiento de pagos.
  • Operaciones de negocio con múltiples pasos.

Errores comunes de los desarrolladores

  • Poner toda la lógica en un solo controlador.
  • Crear métodos muy grandes con muchos pasos.
  • No utilizar patrones integrados de Laravel.
  • Código difícil de probar y mantener

Si la lógica tiene múltiples pasos con un flujo claro, es mejor usar el Patrón Pipeline.

El código tiene que fluir como un pipeline, no como un gran bloque.