Hur man använder Nest.js undantagsfilter för att hantera fel

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

Genom att centralisera logiken för felhantering kan utvecklare effektivisera sina processer genom att konsolidera all felrelaterad kod på ett ställe. Detta förenklar inte bara felsökningen utan ger också en mer organiserad presentation av felmeddelanden för slutanvändarna. Genom att använda undantagsfilter kan utvecklare effektivt hantera fel som uppstår i en applikation, vilket ger en sammanhängande svarsmekanism som säkerställer enhetlighet i hela systemet.

Standardfelhantering i Nest.js

Nest.js innehåller en inbyggd mekanism för hantering av undantag som tar hand om ohanterade undantag som genereras av applikationens kod.

När ett undantag går obemärkt förbi under körning i din applikation som utvecklats med Nest.js-ramverket, svarar systemet automatiskt med en HTTP-statuskod på 500 Internal Server Error tillsammans med en fördefinierad JSON-nyttolast som innehåller information om felets uppkomst. Detta format är utformat för att vara enkelt att använda för utvecklare som enkelt kan spåra orsaken till problemet med hjälp av den information som tillhandahålls.

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

Om ett felobjekt som skapas av din kod innehåller både en statuskod och ett meddelande, kommer Nest.js att använda dessa värden istället för att tillhandahålla standardsvaret.

För att förhindra generisk hantering av fel och istället ge ett mer informativt svar till klienter är det viktigt att noggrant hantera alla potentiella fel i din applikation. Detta kan åstadkommas genom att antingen använda Nest.js befintliga undantagsfilter eller skapa anpassade filter som är skräddarsydda för dina specifika behov.

Skapa ett anpassat undantagsfilter

För att illustrera proceduren för att utveckla ett skräddarsytt undantagsfilter, försök att konstruera ett som kan hantera alla HTTP-undantag.

Överväg att börja med ett dokument med titeln “http.exception.ts”, och därefter införliva de efterföljande importsatserna i det:

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

import { Request, Response } from 'express';

Dessa importer tjänar följande syften.

Ett undantagsfilter, som implementeras genom detta gränssnitt, används för att fånga upp och hantera undantag som uppstår under programkörning.

Catch-dekoratorn innebär att en klass betecknas som en mekanism för filtrering av undantag inom Nest-ramverket.

Gränssnittet ArgumentsHost innehåller en uppsättning metoder som gör det lättare att samla in argument som skickas till en viss hanterare. Genom att använda detta ramverk kan man välja en lämplig exekveringskontext som HTTP, RPC eller WebSockets för att extrahera nämnda argument från.

HttpException utgör grunden för alla Nest HTTP-undantag och omfattar en standardiserad struktur för hantering av fel i webbapplikationer.

request- och response-objekten. Det förra representerar inkommande klientförfrågningar, medan det senare används för att skicka tillbaka svar på dessa förfrågningar.

För att implementera ett undantagsfilter för hantering av HttpException s i vår ASP.NET Core-applikation, kan vi skapa en ny klass med namnet HttpExceptionFilter . Denna klass bör ärva från ExceptionFilterAttribute och annoteras med Catch attributet för att hantera undantag av denna typ.

 @Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {}

Fyll sedan klassen med den här koden:

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

    // Get the request object from the arguments host
    const request = ctx.getRequest<Request>();

    // 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: new Date().toISOString(),
      path: request.url,
      message:
        exception.message
       || exception.getResponse()['message']
       || 'Internal Server Error',
    });
}

Den här implementeringen hämtar parametrarna för begäran och svar från ArgumentsHost-instansen och analyserar undantagen för att hitta relevanta data. Resultatet är ett organiserat JSON-formaterat svar som innehåller informativt innehåll om felet som vidarebefordras till slutanvändaren.

Bindning av undantagsfilter

Du har möjlighet att tillämpa ett undantagsfilter antingen på enskilda styrenheter eller i hela applikationen, beroende på vad som passar dina behov bäst.

Om du vill använda ett globalt undantagsfilter överallt ska du först integrera undantagsfiltret i din primära main.ts fil. Därefter presenterar du en instansiering av ditt undantagsfilter för metoden app.useGlobalFilters() .

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

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

  await app.listen(4050);
}

bootstrap();

För att associera ett undantag med en styrenhet är det nödvändigt att använda dekoratorn “UseFilters” tillsammans med det motsvarande undantagsfiltret. Processen innebär att dekoratorn “UseFilters” och det specifika undantagsfiltret importeras. Därefter måste controllerklassen annoteras med hjälp av dekoratorn “@UseFilters”, samtidigt som en instans av undantagsfiltret skickas som ett argument till dekoratorn.

 @Controller()
@UseFilters(new HttpExceptionFilter())
export class AppController {}

Den plats där ett filter tillämpas kommer att diktera dess utbud av felhanteringsfunktioner. Om ett filter är bundet till en viss styrenhet gäller det endast för den styrenheten, medan ett filter som gäller för hela applikationen omfattar hela applikationen.

Använda inbyggda undantag för att kasta fel

Nest.js erbjuder en rad fördefinierade undantagskategorier som kan användas för att kasta fel, som är utformade för att förenkla felhantering och effektivisera applikationsutveckling genom att tillhandahålla en standardiserad metod för att hantera undantag på ett organiserat sätt.

Man kan använda klassen NotFoundException för att generera ett 404-statuskodfel som svar på förfrågningar som inte kan uppfyllas av servern. Detta undantag används ofta när man försöker komma åt en resurs eller sida som inte finns på servern. Genom att kasta detta undantag kan servern indikera för klienten att det begärda innehållet inte är tillgängligt och ge information om varför begäran misslyckades.

   getUserById(id: number) {
    const user = users.find((user) => user.id === id);

    if (!user) {
      throw new NotFoundException({
        message: `User with id ${id} not found`,
      });
    }
  }

Ovanstående kodsegment använder ett villkorligt uttryck för att kontrollera om den angivna användaren är närvarande. Om så inte är fallet skapas ett 404-undantag genom att använda klassen NotFoundException och ange ett motsvarande meddelande som argument.

Vanliga inbyggda undantagsklasser

Ytterligare fördefinierade undantagskategorier omfattar, men är inte begränsade till, följande exempel.

BadRequestException är ett specialiserat undantag inom programvaruutveckling som representerar ett HTTP-svar med statuskod 400. Undantaget aktiveras när en klients begäran anses vara ogiltig eller felaktigt formaterad av servern, vilket gör att den inte kan bearbetas. Den huvudsakliga innebörden av detta undantag är att klienten måste justera sin begäran för att rätta till eventuella fel eller oegentligheter.

Klassen UnauthorizedException kastar ett undantag som innebär obehörig åtkomst, åtföljt av en HTTP-statuskod på 401. Undantaget kan uppstå i situationer där en användare inte har autentiserats eller inte har de rättigheter som krävs för att få tillgång till en viss resurs.

Klassen ForbiddenException representerar ett undantag som innebär obehörig åtkomst, åtföljt av en HTTP-statuskod på 403. Undantaget kan uppstå i situationer där en användare har autentiserats men saknar nödvändiga behörigheter för att utföra en viss åtgärd.

RequestTimeoutException är ett Java-baserat undantag som skapas när en begäran har överskridit den angivna tidsgränsen, vilket resulterar i en HTTP-statuskod på 408. Undantaget kan användas av servrar för att avsluta förfrågningar som har tagit längre tid än beräknat att behandla.

Klassen ConflictException representerar ett undantag som uppstår på grund av en konflikt i statuskoden 409. Den här typen av undantag kan uppstå när klientens begäran strider mot det aktuella tillståndet för den resurs som hanteras, t.ex. när man försöker skapa en resurs som redan har skapats.

InternalServerErrorException är en typ av undantag som representerar ett oförutsett fel som inträffar inom infrastrukturen på serversidan, vilket resulterar i oförmåga att uppfylla den begärda uppgiften. Detta undantag har en associerad HTTP-statuskod på 500 och bör användas när ett oväntat problem uppstår på serversidan som hindrar den från att uppfylla klientens krav.

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

För att effektivt hantera fel i en Nest.js-applikation är det viktigt att använda undantagsfilter som antingen fångar upp globala undantag eller sådana som är specifika för enskilda styrenheter. Dessutom kan man skapa anpassade undantagsfilter som är skräddarsydda för särskilda feltyper.

Dessutom är det viktigt att använda lämpliga inbyggda undantagsklasser för att skapa korrekta och signifikanta felmeddelanden. Detta tillvägagångssätt bidrar väsentligt till att öka tillförlitligheten hos dina Nest.js-applikationer.