Mit jelent az exception filter (kivétel szűrő)?

Question

Accepted Answer

**Exception filter (kivétel szűrő)** teljes kontroll adja neked a hibák **elkapásáról és válaszokká való átalakításáról**. A request életciklus végén helyezkednek el, elkapják a request során bárhol dobott exceptionöket, és lehetővé teszik a hibaválasz formátumának, státuszának és naplózásának testreszabását.

## Alapvető 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,
    });
  }
}
```

A `@Catch()` dekorátor meghatározza, hogy ez a filter mely exception típusokat kezeli, a `catch()` metódus pedig az exceptiont és a contextet kapja meg — lehetővé téve, hogy bármilyen választ összeállíts.

## Az ÖSSZES exception elkapása (a nem HTTP-ek is)

```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: "..." });
  }
}
```

Egy filter `@Catch()` nélkül (paraméter nélkül) minden exceptiont kezel — a hely az váratlan hibák naplózásához és annak biztosításához, hogy még a nem HTTP hibák is tiszta, biztonságos választ adjanak (anélkül, hogy stack traceket szivárogtatnál ki a kliensek felé).

## Filterek alkalmazása

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

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

A filtereket általában **globálisan** alkalmazzák, hogy egységes hibaformátumot kényszerítsenek az egész API-n.

## Miért használjunk exception filtereket?

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

## Filterek vs exceptionok dobása

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

## Miért fontos

Az exception filterek a NestJS fontos jellemzője a robusztus, professzionális API-k építéséhez **egységes, kontrolált hibakezelés** révén.

Bár a NestJS beépített exception rétege már az eldobott exceptionöket HTTP válaszokká alakítja, az exception filterek teljes kontrollal biztosítanak ahhoz, hogy testreszabhasd ezt a viselkedést — ami több valós szempont miatt fontos: **egységes hibaválasz-forma** érvényesítése az összes végponton (így a kliensek mindig ugyanabban a formátumban kapják meg a hibákat), a **hibanaplózás központosítása** (minden hiba egy helyen történő rögzítése az szétszórt try/catch helyett), a váratlan nem HTTP hibák **biztonságos kezelése** (tiszta 500-as válaszokká való konvertálás összeomlásos vagy részleteket szivárogtatás helyett), és a **biztonság** (belső stack tracek és érzékeny adatok elrejtése a kliensektől, miközben szinten naplózod őket).

Egy globális "mindent elkapó" filter kombinálva azzal, hogy a kódodban specifikus HTTP exceptionöket dobsz, az a standard minta a production-szintű hibakezeléshez.

Az az megértése, hogy mikor és hogyan használjunk filtereket (az exceptionok egyszerű dobása helyett), valamint a globális alkalmazásuk a konzisztencia érdekében, a jól épített NestJS alkalmazások jellemzője és a kifejlett back-end gyakorlatot tükrözi az often-overlooked de kritikus hibakezelés körül.