NestJS tiene una capa de excepciones integrada que automáticamente captura errores no controlados y los convierte en respuestas HTTP apropiadas. Señalas errores lanzando excepciones (a menudo clases de excepción HTTP integradas), y Nest las formatea en respuestas JSON estructuradas con el código de estado correcto.
{ , , } ;
()
() {
user = ..(id);
(!user) {
();
}
user;
}
NestJS proporciona clases de excepción que se asignan a códigos de estado HTTP, y lanzar una produce una respuesta correcta y estructurada automáticamente:
{ "statusCode": 404, "message": "User not found", "error": "Not Found" }
BadRequestException → 400
UnauthorizedException → 401
ForbiddenException → 403
NotFoundException → 404
ConflictException → 409
UnprocessableEntityException → 422
InternalServerErrorException → 500
Hay una clase para cada error HTTP común — usa la apropiada para comunicar el estado correcto.
// custom status + body via the base HttpException
throw new HttpException(
{ status: HttpStatus.FORBIDDEN, error: "custom message" },
HttpStatus.FORBIDDEN,
);
export class UserNotFoundException extends NotFoundException {
constructor(id: string) {
super(`User with id ${id} not found`); // domain-specific, reusable
}
}
throw new UserNotFoundException(id);
If code throws a non-HttpException error (e.g. a plain Error or an unexpected
exception), NestJS's default exception filter catches it and returns a generic
500 Internal Server Error (without leaking internal details to the client).
// a custom exception filter customizes how errors are formatted/logged globally
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
catch(exception: unknown, host: ArgumentsHost) {
// log, format the response, etc.
}
}
app.useGlobalFilters(new AllExceptionsFilter()); // apply app-wide
Para formateo de errores consistente, registro, o manejo de errores no HTTP, usas filtros de excepción (una característica relacionada y más avanzada).
El manejo apropiado de excepciones es esencial para construir APIs confiables, y la capa de excepciones integrada de NestJS lo hace limpio y consistente.
Comprender cómo lanzar excepciones HTTP (NotFoundException, BadRequestException, etc.) es conocimiento cotidiano — es la forma idiomática de señalar errores con los códigos de estado correctos y respuestas JSON estructuradas y amigables para el cliente, sin construir manualmente respuestas de error en cada manejador.
El framework automáticamente captura estas y las formatea, y convierte de forma segura errores inesperados en 500s genéricos sin filtrar detalles internos (importante para la seguridad).
Conocer las clases de excepción comunes, cómo lanzar excepciones/mensajes personalizados, y que los filtros de excepción existen para personalización global (formateo consistente, registro) es fundamental para construir APIs de NestJS robustas y profesionales.
El manejo limpio y consistente de errores es una característica de código back-end de calidad, haciendo esto un aspecto central y frecuentemente usado del framework.