Middlewares

Qué es un Middleware en Nest

Un middleware en NestJS es una función que se ejecuta durante el ciclo de vida de una petición HTTP, específicamente entre la recepción de la solicitud y la respuesta final. Estos componentes actúan como interceptores que pueden modificar, validar o procesar tanto las peticiones entrantes como las respuestas salientes.

Los middlewares en NestJS siguen el mismo patrón que Express.js, ya que NestJS está construido sobre este framework. Esto significa que tienen acceso completo a los objetos request y response, así como a la función next() que permite continuar con el siguiente middleware en la cadena.

Características fundamentales

Los middlewares en NestJS pueden realizar múltiples operaciones críticas:

• Ejecutar código personalizado antes de que la petición llegue al controlador
• Modificar los objetos request y response
• Terminar el ciclo de petición-respuesta prematuramente
• Llamar al siguiente middleware en la pila mediante next()
• Validar permisos o autenticación antes del procesamiento
• Registrar información sobre las peticiones para auditoría

Tipos de middleware disponibles

NestJS ofrece diferentes enfoques para implementar middlewares:

1 - Middleware funcional:

import { Request, Response, NextFunction } from 'express';

export function logger(req: Request, res: Response, next: NextFunction) {
  console.log(`${req.method} ${req.url} - ${new Date().toISOString()}`);
  next();
}

2 - Middleware basado en clases:

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`Petición recibida: ${req.method} ${req.originalUrl}`);
    next();
  }
}

Flujo de ejecución

El orden de ejecución en NestJS sigue una secuencia específica que es importante comprender:

1. Middlewares globales (aplicados a toda la aplicación)
2. Middlewares de módulo (configurados en módulos específicos)
3. Guards (protección de rutas)
4. Interceptors (antes del controlador)
5. Pipes (transformación y validación)
6. Controlador (manejo de la petición)
7. Interceptors (después del controlador)
8. Filtros de excepción (si ocurre un error)

Casos de uso comunes

Los middlewares son especialmente útiles para implementar funcionalidades transversales:

• Logging y auditoría: Registrar todas las peticiones HTTP con detalles como IP, timestamp y duración
• Autenticación básica: Verificar tokens o credenciales antes de procesar la petición
• Validación de headers: Comprobar que las peticiones incluyan headers obligatorios
• Rate limiting: Controlar la frecuencia de peticiones por usuario o IP
• Transformación de datos: Modificar el formato de los datos antes de llegar al controlador

Configuración en módulos

Para aplicar un middleware en NestJS, debes configurarlo en el módulo correspondiente implementando la interfaz NestModule:

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './logger.middleware';
import { UsersController } from './users.controller';

@Module({
  controllers: [UsersController],
})
export class UsersModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('users');
  }
}

Esta configuración permite un control granular sobre qué rutas y métodos HTTP serán afectados por cada middleware, proporcionando flexibilidad en la arquitectura de tu aplicación.