Skip to content

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:

Image

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:

Image

Image

Image

Image

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.