Vad är exception filters?

Question

Accepted Answer

**Exception filters** ger dig full kontroll över hur fel **fångas och transformeras till responses**. De sitter i slutet av request-livscykeln, fångar undantag som kastas någonstans i requesten och låter dig anpassa felresponsformatet, statuskod och loggning.

## En grundläggande 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,
    });
  }
}
```

Decoratorn `@Catch()` specifierar vilka undantagstyper som denna filter hanterar, och metoden `catch()` tar emot undantaget plus kontexten — vilket låter dig skapa vilket svar du vill.

## Fånga ALLA undantag (inklusive icke-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: "..." });
  }
}
```

En filter med `@Catch()` (utan argument) hanterar alla undantag — platsen för att logga oväntade fel och säkerställa att även icke-HTTP-fel returnerar ett rent, säkert svar (utan att läcka stack traces till klienter).

## Applicera filters

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

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

Filters tillämpas vanligtvis **globalt** för att genomdriva ett konsekvent felformat över hela API:et.

## Varför använda 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 kontra att kasta undantag

```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.
```

## Varför det spelar roll

Exception filters är en viktig NestJS-funktion för att bygga robusta, professionella API:er med **konsekvent, kontrollerad felhantering**.

Even om NestJS's inbyggda exception layer redan förvandlar kastade undantag till HTTP-responses, ger exception filters dig full kontroll för att anpassa det beteendet — vilket spelar roll för flera verkliga bekymmer: tvinga en **konsekvent felrespons-form** över varje endpoint (så klienter alltid får fel i samma format), **centralisera felloggning** (fånga alla fel på ett ställe istället för spridda try/catch), säkert **hantera oväntade icke-HTTP-fel** (konvertera dem till rena 500:or istället för att krascha eller läcka detaljer), och **säkerhet** (dölja interna stack traces och känslig information från klienter medan du loggar dem internt).

Ett globalt "catch-all" filter kombinerat med att kasta specifika HTTP-undantag i din kod är standardmönstret för felhantering i produktionskvalitet.

Att förstå när och hur man använder filters (kontra att bara kasta undantag), och applicera dem globalt för konsistens, är ett kännetecken på väl byggda NestJS-applikationer och återspeglar mogen back-end-praktik kring det ofta förbisedda men kritiska problemet med felhantering.