Middlewares, Guards y Filters en NestJS

En NestJS, los middlewares son funciones que se ejecutan antes de llegar a los controladores y pueden modificar la solicitud (req) y la respuesta (res). Son útiles para tareas como la autenticación, el registro de actividades (logging), o la modificación de datos de la solicitud.

Middlewares

Los middlewares son funciones que se ejecutan antes de que una ruta sea manejada por su controlador. Se utilizan para transformar la solicitud, agregar lógica común o realizar validaciones previas.

Casos de uso:

• Registro de logs de solicitudes.
• Validación o transformación de datos antes de que lleguen a un controlador.
• Autenticación básica.

Ejemplo de Middleware:

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(`Request... ${req.method} ${req.url}`);
    next(); // Llamar a la siguiente función o controlador
  }
}

Cómo aplicar el Middleware

import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common';

@Module({})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path: '*', method: RequestMethod.ALL });
  }
}

Guards

Los Guards determinan si una solicitud puede o no continuar hacia el siguiente paso en el ciclo de ejecución (controlador o middleware). Generalmente se usan para gestionar autorización.

Casos de uso

• Verificar si un usuario tiene los permisos adecuados.
• Implementar lógica de autorización personalizada.
• Restringir acceso a rutas protegidas.

Ejemplo de Guard

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    return user && user.isAuthenticated; // Validar si el usuario está autenticado
  }
}

Cómo aplicar el Guard

import { Controller, Get, UseGuards } from '@nestjs/common';

@Controller('protected')
export class ProtectedController {
  @Get()
  @UseGuards(AuthGuard)
  getProtectedResource() {
    return 'This is a protected resource!';
  }
}

Filters

Los Filters manejan errores que ocurren en el ciclo de solicitud-respuesta. Capturan excepciones y permiten personalizar la respuesta que se envía al cliente.

Casos de uso

• Crear mensajes de error personalizados.
• Manejar excepciones específicas.
• Controlar errores globalmente en toda la aplicación.

Ejemplo de Filter

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      message: exception.message,
    });
  }
}

Cómo aplicar el Filter

A nivel de controlador:

import { Controller, Get, UseFilters } from '@nestjs/common';

@Controller('example')
export class ExampleController {
  @Get()
  @UseFilters(HttpExceptionFilter)
  throwError() {
    throw new HttpException('Forbidden', 403);
  }
}

Globalmente:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { HttpExceptionFilter } from './http-exception.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpExceptionFilter());
  await app.listen(3000);
}
bootstrap();