Master NestJS unntaksfiltre: Feilhåndtering for proffer

by
Tweet
Share
Share
Pin
0 Shares

I Nest.js tilbyr unntaksfiltre en mekanisme for å fange opp og behandle feil enten på globalt nivå eller spesifikt for hver kontroller.

Dette muliggjør sentralisert feilhåndteringslogikk, formatering av feilresponser og sikrer konsekvent feilhåndtering i hele applikasjonen. La oss utforske hvordan unntaksfiltre fungerer og hvordan du effektivt kan bruke dem til å håndtere applikasjonsfeil.

Standard feilhåndtering i Nest.js

Som standard har Nest.js et innebygd feilhåndteringslag som tar seg av eventuelle feil som applikasjonskoden din ikke eksplisitt fanger opp.

Når en ubehandlet feil oppstår i applikasjonen din, vil Nest.js fange opp denne og returnere en 500 Internal Server Error-melding til klienten. Den JSON-strukturen som Nest.js returnerer i et slikt tilfelle, ser typisk slik ut:

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

Dersom feilobjektet fra koden din inneholder en statuskode og en feilmelding, vil Nest.js prioritere disse verdiene over standardresponsen.

For å unngå denne generiske oppførselen og i stedet sende en mer informativ respons til klienten, er det nødvendig å håndtere alle potensielle feil grundig. Dette kan gjøres ved å bruke Nest.js sine innebygde eller egendefinerte unntaksfiltre.

Opprettelse av et tilpasset unntaksfilter

La oss gå gjennom prosessen med å lage et tilpasset unntaksfilter, og for eksempelets skyld, la oss lage et filter som håndterer alle HTTP-relaterte unntak.

Start med å opprette en fil, for eksempel `http.exception.ts`, og legg til følgende import-setninger:

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

Disse importene har følgende formål:

  • `ExceptionFilter`: Et grensesnitt som definerer kravene for et unntaksfilter.
  • `Catch`: En dekoratør som markerer en klasse som et Nest-unntaksfilter.
  • `ArgumentsHost`: Et grensesnitt som gir metoder for å hente argumentene som blir sendt til en behandler. Dette tillater å velge riktig kjøringskontekst (f.eks. HTTP, RPC eller WebSockets).
  • `HttpException`: En klasse som representerer et basis-HTTP-unntak i Nest.
  • `Request` og `Response`: Grensesnitt for Express.js sine request- og response-objekter.

Deretter oppretter du en klasse, `HttpExceptionFilter`, som implementerer `ExceptionFilter`. Bruk `@Catch`-dekoratøren for å indikere at denne klassen håndterer `HttpException`:

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

Fyll så klassen med følgende kode:

 catch(exception: HttpException, host: ArgumentsHost) {
  const ctx = host.switchToHttp();
  const response = ctx.getResponse<Response>();
  const request = ctx.getRequest<Request>();
  const status = exception.getStatus();

  response.status(status).json({
   statusCode: status,
   timestamp: new Date().toISOString(),
   path: request.url,
   message:
   exception.message
   || exception.getResponse()['message']
   || 'Intern serverfeil',
  });
}

Denne kodeblokken henter forespørsels- og svarobjekter fra `ArgumentsHost`-objektet, og trekker ut relevant informasjon fra unntaket. Den returnerer deretter en strukturert JSON-respons med detaljer om feilen.

Tilknytning av unntaksfiltre

Du kan knytte et unntaksfilter til enten en spesifikk kontroller eller hele applikasjonen, avhengig av behovene dine.

For å knytte et unntaksfilter globalt, importer filteret inn i `main.ts`-filen. Deretter sender du en instans av filteret til `app.useGlobalFilters`-metoden:

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);
  app.useGlobalFilters(new HttpExceptionFilter());
  await app.listen(4050);
}

bootstrap();

For å knytte et filter til en spesifikk kontroller, importer `UseFilters`-dekoratøren og unntaksfilteret. Bruk `@UseFilters`-dekoratøren på kontrollerklassen din og send en instans av filteret som et argument:

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

Omfanget av feilhåndteringen vil avhenge av hvor du knytter filteret. Kontrollerbundne filtre håndterer kun feil innenfor den spesifikke kontrolleren, mens globalt bundne filtre gjelder for hele applikasjonen.

Bruk av innebygde unntak for å generere feil

Nest.js leveres med et sett av innebygde unntaksklasser som du kan bruke for å generere feil.

For eksempel kan du kaste en 404-statuskode med `NotFoundException`-klassen:

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

  if (!user) {
   throw new NotFoundException({
    message: `Bruker med id ${id} ikke funnet`,
   });
  }
 }

Denne kodeblokken sjekker om en bruker med et gitt ID eksisterer. Hvis ikke, genereres en 404-feil ved bruk av `NotFoundException` med en tilpasset melding.

Vanlige innebygde unntaksklasser

Andre tilgjengelige unntaksklasser inkluderer, men er ikke begrenset til:

  • `BadRequestException`: Genererer en feil som indikerer en dårlig forespørsel (statuskode 400). Brukes når en klient sender en ugyldig eller feilformet forespørsel.
  • `UnauthorizedException`: Indikerer uautorisert tilgang (statuskode 401). Brukes når en bruker ikke er autentisert eller mangler nødvendige tillatelser.
  • `ForbiddenException`: Indikerer en forbudt handling (statuskode 403). Brukes når en bruker er autentisert, men ikke autorisert til å utføre den spesifikke handlingen.
  • `RequestTimeoutException`: Genereres når en forespørsel bruker for lang tid (statuskode 408). Brukes når serveren avbryter en forespørsel som overskrider tidsfristen.
  • `ConflictException`: Indikerer en konflikt (statuskode 409). Brukes når det er en konflikt mellom klientens forespørsel og ressursens nåværende tilstand.
  • `InternalServerErrorException`: Genereres for interne serverfeil (statuskode 500). Brukes ved uventede feil på serversiden.

Beste praksis for feilhåndtering i Nest.js

Ved feilhåndtering i Nest.js bør du benytte unntaksfiltre for å håndtere feil på globalt nivå eller per kontroller. Det er også fordelaktig å lage egne filtre for spesifikke unntakstyper.

Husk å bruke de korrekte innebygde unntaksklassene for å generere presise og informative feil. Ved å følge disse retningslinjene kan du øke påliteligheten til dine Nest.js applikasjoner betraktelig.