Hva er exception filters?

Question

Accepted Answer

**Exception filters** gir deg full kontroll over hvordan feil blir **fanget og transformert til responses**. De sitter på slutten av request-livssyklusen, fanger exceptions kastet hvor som helst i requesten og lar deg tilpasse error-response-formatet, status og logging.

## Et grunnleggende 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,
    });
  }
}
```

`@Catch()`-dekoratøren spesifiserer hvilke exception-typer dette filteret håndterer, og `catch()`-metoden mottar exceptionen pluss konteksten — som lar deg lage enhver response du vil.

## Å fange ALLE exceptions (inkludert non-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()` (uten argument) håndterer hver exception — stedet å logge uventede feil og sikre at selv non-HTTP-feil returnerer en ren, sikker response (uten å lekke 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 brukes vanligvis **globalt** for å håndheve et konsistent error-format på tvers av hele APIet.

## Hvorfor bruke 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 å 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 betyr noe

Exception filters er en viktig NestJS-funksjon for å bygge robuste, profesjonelle APIer med **konsistent, kontrollert error-håndtering**.

Mens NestJS's innebygde exception-lag allerede gjør kastet exceptions om til HTTP-responses, gir exception filters deg full kontroll til å tilpasse denne atferden — som betyr noe for flere praktiske bekymringer: å håndheve en **konsistent error-response-form** på tvers av hvert endepunkt (slik at klienter alltid får feil i samme format), **å sentralisere error-logging** (å fange hver feil på ett sted i stedet for spredt try/catch), å trygt **håndtere uventede non-HTTP-feil** (konvertere dem til rene 500-er i stedet for å krasje eller lekke detaljer), og **sikkerhet** (å skjule interne stack traces og sensitiv informasjon fra klienter mens du logger dem internt).

Et globalt "catch-all"-filter kombinert med å kaste spesifikke HTTP-exceptions i koden din er standardmønsteret for production-grade error-håndtering.

Å forstå når og hvordan du bruker filters (versus bare å kaste exceptions), og å anvende dem globalt for konsistens, er et tegn på velbyggede NestJS-applikasjoner og reflekterer moden back-end-praksis rundt den ofte-oversette men kritiske bekymringen rundt error-håndtering.