Hvad er exception filters?

Question

Accepted Answer

**Exception filters** giver dig fuld kontrol over, hvordan fejl **fanges og transformeres til responses**. De sidder ved slutningen af request-livscyklussen, fanger exceptions, der kastes hvor som helst i request'et, og lader dig tilpasse fejlresponseformatet, status og logging.

## Et grundlæggende exception filter

```ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from "@nestjs/common";

@Catch(HttpException)                    // catch HttpExceptions specifically
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception.getStatus();

// build a CUSTOM error response shape
    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    });
  }
}
```

Decoratøren `@Catch()` specificerer, hvilke exception-typer dette filter håndterer, og metoden `catch()` modtager exceptionen plus konteksten — hvilket lader dig skabe en hvilken som helst response, du ønsker.

## Fange ALLE exceptions (inklusive ikke-HTTP)

```ts
@Catch()                                 // no argument = catch EVERYTHING
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const status = exception instanceof HttpException
      ? exception.getStatus()
      : 500;                              // unknown errors → 500
    // log the full error internally, return a safe message to the client
    this.logger.error(exception);
    ctx.getResponse().status(status).json({ statusCode: status, message: "..." });
  }
}
```

Et filter med `@Catch()` (uden argument) håndterer enhver exception — stedet til at logge uventede fejl og sikre, at selv ikke-HTTP-fejl returnerer en ren, sikker response (uden at læk stack traces til klienter).

## Anvende filters

```ts
@UseFilters(HttpExceptionFilter)         // method or controller level
export class UsersController {}

app.useGlobalFilters(new AllExceptionsFilter());   // GLOBAL — app-wide, most common
```

Filters anvendes normalt **globalt** for at håndhæve et konsistent fejlformat på tværs af hele API'en.

## Hvorfor bruge exception filters?

```text
✓ Consistent error response format across ALL endpoints (a standard shape)
✓ Centralized error LOGGING (log every error in one place)
✓ Handle non-HTTP errors safely (turn unexpected errors into clean 500s)
✓ Hide internal details from clients (no leaked stack traces — security)
✓ Add context (request path, timestamp, correlation IDs) to error responses
```

## Filters vs at kaste exceptions

```text
Throwing exceptions (NotFoundException, etc.) → SIGNALS an error with a status
Exception filters → control HOW those errors are FORMATTED/logged into responses
→ You throw exceptions in your code; filters customize the resulting response globally.
```

## Hvorfor det betyder noget

Exception filters er en vigtig NestJS-funktion til at bygge robuste, professionelle API'er med **konsekvent, kontrolleret fejlhåndtering**.

Skønt NestJS's indbyggede exception-lag allerede omdanner kastede exceptions til HTTP-responses, giver exception filters dig fuld kontrol til at tilpasse den adfærd — hvilket betyder noget for flere praktiske hensyn: at håndhæve et **konsekvent fejlresponseformat** på tværs af hvert endpoint (så klienter altid får fejl i samme format), **centralisere fejllogging** (fange enhver fejl ét sted i stedet for spredt rundt om try/catch), sikkert **håndtere uventede ikke-HTTP-fejl** (konvertere dem til rene 500'ere i stedet for at krasje eller læk detaljer), og **sikkerhed** (skjule interne stack traces og følsomme detaljer fra klienter, mens du logger dem internt).

Et globalt "catch-all"-filter kombineret med at kaste specifikke HTTP-exceptions i din kode er standardmønsteret for produktionsklar fejlhåndtering.

At forstå, hvornår og hvordan man bruger filters (versus blot at kaste exceptions), og anvende dem globalt for konsistens, er kendetegnet på velbyggede NestJS-applikationer og afspejler moden back-end-praksis omkring det ofte-overset, men kritiske aspekt af fejlhåndtering.