Ohanterade undantag kan orsaka förvirring och frustration. Rengör dem med undantagsfilter.

Nest.js undantagsfilter ger ett sätt att fånga upp och hantera undantag globalt eller per kontrollant.

De låter dig centralisera felhanteringslogiken, formatera felsvar och tillhandahålla konsekvent felhantering i hela din applikation. Lär dig mer om undantagsfilter och hur du använder dem för att hantera programfel på lämpligt sätt.

Standardfelhantering i Nest.js

Som standard har Nest.js ett undantagslager som hanterar eventuella undantag som din applikationskod inte hanterar.

När ett ohanterat fel uppstår i din applikation fångar Nest.js upp det och returnerar ett 500 internt serverfel till klienten. JSON som Nest.js returnerar i det här fallet ser ut så här:

{
"statusCode": 500,
"message": "Internal server error"
}

Om felobjektet som din kod kastar innehåller en statuskod och a meddelande, kommer Nest.js att returnera dessa värden istället för standardsvaret.

För att undvika detta generiska beteende och skicka ett mer meningsfullt felsvar till klienten måste du noggrant hantera alla fel som kan uppstå i din applikation. Du kan uppnå detta med Nest.js inbyggda eller anpassade undantagsfilter.

instagram viewer

Skapa ett anpassat undantagsfilter

För att demonstrera processen för att skapa ett anpassat undantagsfilter, försök att skapa ett som hanterar alla HTTP-undantag.

Börja med en fil som heter http.exception.ts och lägg till följande importer till den:

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

Denna import tjänar följande syften.

  • ExceptionFilter: Detta är ett gränssnitt som beskriver implementeringen av ett undantagsfilter.
  • Fånga: Det här är en dekoratör som markerar en klass som ett Nest-undantagsfilter.
  • ArgumentHost: Detta gränssnitt tillhandahåller metoder för att hämta argumenten som skickas till en hanterare. Det låter dig välja rätt exekveringskontext (t.ex. HTTP, RPC eller WebSockets) att hämta argument från.
  • HttpException: Det här är en klass som definierar det grundläggande Nest HTTP-undantaget.
  • Begäran & Svar: Dessa är gränssnitten för ett Express.js-förfrågan respektive ett svarsobjekt.

Skapa sedan en klass, HttpExceptionFilter, som genomför ExceptionFilter. Annotera det med Fånga dekorator för att indikera att den hanterar HttpExceptions:

@Catch(HttpException)
exportclassHttpExceptionFilterimplementsExceptionFilter{}

Fyll sedan i klassen med denna kod:

catch(exception: HttpException, host: ArgumentsHost) {
// Get the response object from the arguments host
const ctx = host.switchToHttp();
const response = ctx.getResponse();
// Get the request object from the arguments host
const request = ctx.getRequest();


// Get the status code from the exception
const status = exception.getStatus();
// Send a JSON response using the response object
 response.status(status).json({
 statusCode: status,
 timestamp: newDate().toISOString(),
 path: request.url,
 message:
 exception.message
 || exception.getResponse()['message']
 || 'Internal Server Error',
 });
}

Detta kodblock hämtar begäran och svarsobjekt från ArgumentsHost-objektet och extraherar relevant information från undantaget. Den returnerar ett strukturerat JSON-objektsvar, med detaljer om felet, till klienten.

Bindande undantagsfilter

Du kan binda ett undantagsfilter till en kontroller eller hela din applikation, beroende på dina behov.

För att binda ett undantagsfilter globalt, importera först undantagsfiltret till din main.ts fil. Skicka sedan en instans av ditt undantagsfilter till app.useGlobalFilters metod:

// main.ts
import { NestFactory } from'@nestjs/core';
import { AppModule } from'./app.module';
import { HttpExceptionFilter } from'./exception/http.exception';
asyncfunctionbootstrap() {
const app = await NestFactory.create(AppModule);


// Bind filter to the application
 app.useGlobalFilters(new HttpExceptionFilter());


await app.listen(4050);
}
bootstrap();

För att binda ett undantag till en kontrollant, importera Använd filter dekoratör och ditt undantagsfilter. Annotera din controller-klass med @UseFilters dekoratör och skicka en instans av ditt undantagsfilter som ett argument till dekoratören:

@Controller()
@UseFilters(new HttpExceptionFilter())
exportclassAppController{}

Var du binder ditt filter kommer att avgöra omfattningen av din felhantering. Kontrollerbundna filter kommer bara att tillgodose kontrollenheten du kopplade den till, och programbundna filter kommer att tillgodose hela programmet.

Använda inbyggda undantag för att kasta fel

Nest.js tillhandahåller inbyggda undantagsklasser som du kan använda för att skicka fel.

Till exempel kan du kasta 404 statuskodfel med NotFoundException klass:

 getUserById(id: number) {
const user = users.find((user) => user.id id);
if (!user) {
thrownew NotFoundException({
 message: `User with id ${id} not found`,
 });
 }
 }

Detta kodblock använder ett villkorligt uttalande för att kontrollera om den givna användaren finns. Om inte, ger det ett 404-fel med hjälp av NotFoundException, skicka ett meddelande som ett argument.

Vanliga inbyggda undantagsklasser

Andra inbyggda undantagsklasser inkluderar, men är inte begränsade till, följande.

  • BadRequestException: Kastar ett undantag som indikerar en dålig begäran med en statuskod på 400. Du kan använda detta undantag när klientens begäran är ogiltig eller felaktig, och servern inte kan behandla den på grund av klientens fel. Det innebär vanligtvis att klienten måste ändra begäran för att göra den giltig.
  • UnauthorizedException: Kastar ett undantag som indikerar obehörig åtkomst med en statuskod på 401. Du kan använda detta undantag när en användare inte är autentiserad eller saknar nödvändiga behörigheter för att komma åt en resurs.
  • Förbjudet undantag: Kastar ett undantag som indikerar förbjuden åtkomst med en statuskod på 403. Du kan använda detta undantag när en användare är det autentiserade men inte auktoriserade att utföra en specifik åtgärd.
  • RequestTimeoutException: Kastar ett undantag som indikerar att begäran har tagit timeout med en statuskod på 408. Du kan använda detta undantag när en server avslutar en begäran eftersom det tog för lång tid att bearbeta.
  • ConflictException: Kastar ett undantag som indikerar en konflikt med en statuskod på 409. Du kan använda detta undantag där det finns en konflikt mellan klientens begäran och resursens aktuella tillstånd, till exempel när du försöker skapa en resurs som redan finns.
  • InternalServerErrorException: Kastar ett undantag som indikerar ett internt serverfel med statuskoden på 500. Du kan använda detta undantag när ett oväntat fel inträffar på serversidan, vilket indikerar att servern inte kan uppfylla begäran på grund av ett internt problem.

Bästa metoder för felhantering i Nest.js

När du hanterar fel i Nest.js, se till att använda undantagsfilter för att fånga och hantera undantag globalt eller per kontrollenhet. Du kan också skapa anpassade filter för specifika undantagstyper.

Se dessutom till att du använder lämpliga inbyggda undantagsklasser för att skapa korrekta och meningsfulla fel. Dessa metoder kan avsevärt förbättra tillförlitligheten för dina Nest.js-appar.