7. El ciclo de vida de una solicitud
Entre la llegada de una solicitud y la ejecución de la acción, [NestJS] interviene mediante varios tipos de objetos, cada uno con un rol específico. Ya nos hemos topado con algunos: los middleware ([res.locals], [cookie-parser]) y los pipes ([ParseIntPipe], [ValidationPipe]). El caso de estudio utiliza los cinco:

Objeto | Rol | En el caso de estudio |
middleware | prepara la solicitud; todavía no conoce la acción | lectura de cookies, idioma, mensaje flash |
guardia (guard) | autoriza o deniega el acceso a la acción | Autenticación (JWT), roles |
interceptor | código antes y después de la acción | el usuario conectado, expuesto a las vistas |
pipe | convierte y valida un parámetro | [ParseIntPipe] |
filtro de excepciones | convierte una excepción en una respuesta | Páginas de error HTML, redirección a /login |
7.1. Ejemplo 24: los cinco pasos
El ejemplo 24 tiene una acción que calcula el cuadrado de un número y un objeto de cada tipo. Cada uno escribe una línea en la consola, de modo que podamos ver el orden en que ocurren.
El archivo [src/logger.middleware.ts]:
| import { Injectable, NestMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
// 1. el MIDDLEWARE: el primero en ver la solicitud. Aún no sabe
// qué acción la atenderá
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
use(req: Request, res: Response, next: NextFunction): void {
console.log(`\n--- ${req.method} ${req.originalUrl}`);
console.log('1. middleware');
next(); // cedemos el control al resto de la cadena
}
}
|
- Línea 7: un middleware de [NestJS] es una clase que implementa [NestMiddleware]. Una simple función, como en los ejemplos anteriores, también funcionaría;
- Línea 11: el middleware debe llamar a [next()] para pasar el control al siguiente paso (o enviar él mismo una respuesta). De lo contrario, la solicitud queda bloqueada.
El archivo [src/app.module.ts]:
| import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { CalcController } from './calc.controller';
import { LoggerMiddleware } from './logger.middleware';
@Module({
controllers: [CalcController],
})
export class AppModule implements NestModule {
// un middleware de clase se registra en el módulo
configure(consumer: MiddlewareConsumer): void {
consumer.apply(LoggerMiddleware).forRoutes('*');
}
}
|
Líneas 10–12: un middleware basado en una clase se registra en un módulo que implementa [NestModule]. [forRoutes('*')] lo aplica a todas las rutas.
El archivo [src/block.guard.ts]:
| import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { Request } from 'express';
// 2. el GUARD: decide si la solicitud puede llegar a la acción.
// false -> NestJS lanza una ForbiddenException (403)
@Injectable()
export class BlockGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean {
const req = context.switchToHttp().getRequest<Request>();
// el guard conoce la acción de destino (que el middleware no conocía)
console.log(`2. guard (targeted action: ${context.getHandler().name})`);
return req.query.block !== '1';
}
}
|
- línea 7: un guardia implementa [CanActivate];
- línea 8: su método [canActivate] recibe el contexto de ejecución y devuelve [true] (la solicitud continúa) o [false] ([NestJS] lanza una [ForbiddenException], código 403);
- línea 11: a diferencia del middleware, el guardia conoce la acción de destino ([getHandler()]) y su controlador ([getClass()]). Esto es lo que permite que un guardia lea los decoradores aplicados a la acción (véase [@Roles], en el próximo capítulo).
El archivo [src/timing.interceptor.ts]:
| import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable, tap } from 'rxjs';
// 3. el INTERCEPTOR: código ANTES de la acción, y DESPUÉS de ella
@Injectable()
export class TimingInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
console.log('3. interceptor (before)');
const start = Date.now();
// next.handle() ejecuta lo que sigue: pipes y luego la acción. El resultado
// de la acción llega en el flujo devuelto (Observable)
return next.handle().pipe(tap(() => console.log(`6. interceptor (after, ${Date.now() - start} ms)`)));
}
}
|
- línea 6: un interceptor implementa [NestInterceptor];
- línea 8: el código colocado antes de [next.handle()] se ejecuta antes de la acción;
- línea 12: [next.handle()] ejecuta el resto (los pipes seguidos de la acción) y devuelve un flujo [RxJS] ([Observable]) que producirá el resultado de la acción. El operador [tap] ejecuta código después de la acción, sin modificar su resultado (el operador [map] permitiría modificarlo).
El archivo [src/integer.pipe.ts]:
| import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
// 4. el PIPE: convierte y valida un parámetro de la acción
@Injectable()
export class IntegerPipe implements PipeTransform<string, number> {
transform(value: string): number {
console.log(`4. pipe (received value: "${value}")`);
const n = Number(value);
if (!Number.isInteger(n)) {
throw new BadRequestException(`"${value}" is not an integer`);
}
return n;
}
}
|
Un pipe similar a [ParseIntPipe] (véase el ejemplo 12).
El archivo [src/error-page.filter.ts]:
| import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from '@nestjs/common';
import { Response } from 'express';
// x. el FILTRO DE EXCEPCIONES: recibe cualquier excepción no controlada, provenga de donde
// provenga (guard, pipe, acción...), y construye la respuesta.
// @Catch() sin argumento: todas las excepciones
@Catch()
export class ErrorPageFilter implements ExceptionFilter {
catch(exception: unknown, host: ArgumentsHost): void {
const res = host.switchToHttp().getResponse<Response>();
const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;
const message = exception instanceof HttpException ? exception.message : 'Internal error';
console.log(`x. exception filter (${status}: ${message})`);
// una página HTML en lugar de la respuesta JSON predeterminada de NestJS
res.status(status).render('error', { status, message });
}
}
|
- Línea 7: [@Catch()] sin argumento: el filtro recibe todas las excepciones. [@Catch(HttpException)] lo limitaría a las excepciones HTTP;
- Línea 9: el método [catch] recibe la excepción y un objeto [host] que da acceso a la solicitud y a la respuesta;
- Línea 11: una [HttpException] contiene su código de estado. Cualquier otra excepción (un error de programación, una base de datos inaccesible) produce un error 500;
- línea 15: en lugar del JSON predeterminado, el filtro muestra una página HTML con el código de estado correcto.
El archivo [src/main.ts]:
| import { NestFactory } from '@nestjs/core';
import { NestExpressApplication } from '@nestjs/platform-express';
import { dirname, join } from 'path';
import { AppModule } from './app.module';
import { TimingInterceptor } from './timing.interceptor';
import { ErrorPageFilter } from './error-page.filter';
async function bootstrap() {
const app = await NestFactory.create<NestExpressApplication>(AppModule, { logger: ['error', 'warn'] });
app.useStaticAssets(join(dirname(require.resolve('bootstrap/package.json')), 'dist'), { prefix: '/bootstrap/' });
app.setBaseViewsDir(join(__dirname, '..', 'views'));
app.setViewEngine('hbs');
// un interceptor y un filtro GLOBALES: se aplican a todas las rutas
app.useGlobalInterceptors(new TimingInterceptor());
app.useGlobalFilters(new ErrorPageFilter());
await app.listen(3000);
console.log('Server started on http://localhost:3000');
}
bootstrap();
|
- línea 9: filtramos los mensajes de [NestJS] para dejar solo errores y advertencias, de modo que veamos los nuestros con mayor claridad;
- líneas 14–15: el interceptor y el filtro son globales; se aplican a todas las acciones.
El archivo [src/calc.controller.ts]:
| import { Controller, Get, Param, Render, UseGuards } from '@nestjs/common';
import { BlockGuard } from './block.guard';
import { IntegerPipe } from './integer.pipe';
@Controller('square')
@UseGuards(BlockGuard) // el guard se aplica a todas las acciones del controlador
export class CalcController {
@Get(':n')
@Render('square')
square(@Param('n', IntegerPipe) n: number): object {
console.log(`5. action square(${n})`);
if (n === 13) {
throw new Error('13 brings bad luck'); // un error "inesperado"
}
return { n, square: n * n };
}
}
|
- línea 6: [@UseGuards] aplica un guardia a todas las acciones del controlador (también puede aplicarse a una sola acción);
- línea 10: el pipe convierte el parámetro;
- líneas 12–14: un error «inesperado», para ver el filtro en acción.
Cuatro solicitudes: un cálculo normal, un parámetro no válido, una solicitud bloqueada por el guardia y el error inesperado. La consola del servidor:
| --- GET /square/7
1. middleware
2. guard (targeted action: square)
3. interceptor (before)
4. pipe (received value: "7")
5. action square(7)
6. interceptor (after, 2 ms)
--- GET /square/abc
1. middleware
2. guard (targeted action: square)
3. interceptor (before)
4. pipe (received value: "abc")
x. exception filter (400: "abc" is not an integer)
--- GET /square/7?block=1
1. middleware
2. guard (targeted action: square)
x. exception filter (403: Forbidden resource)
--- GET /square/13
1. middleware
2. guard (targeted action: square)
3. interceptor (before)
4. pipe (received value: "13")
5. action square(13)
x. exception filter (500: Internal error)
|
Este registro muestra:
- el orden de los pasos: middleware, guardia, interceptor (antes), pipe, acción, interceptor (después);
- una excepción interrumpe la cadena, donde sea que ocurra, y el filtro genera la respuesta: el guardia deniega el acceso (403), el pipe lo deniega (400), la acción falla (500).
Las páginas resultantes:




El filtro de excepciones del caso de estudio ([web/html-exception.filter.ts]) sigue este patrón, con una excepción: un error 401 (usuario no conectado) no muestra una página de error, sino que redirige a la página de inicio de sesión.