Apa itu exception filters?

Question

Accepted Answer

**Exception filters** memberi Anda kontrol penuh atas cara **kesalahan ditangkap dan diubah menjadi responses**. Mereka berada di akhir lifecycle request, menangkap exception yang dilempar di mana saja dalam request dan membiarkan Anda mengkustomisasi format response error, status, dan logging.

## A basic 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,
    });
  }
}
```

Decorator `@Catch()` menentukan jenis exception mana yang ditangani filter ini, dan method `catch()` menerima exception ditambah context — memungkinkan Anda membuat response apa pun yang Anda inginkan.

## Catching ALL exceptions (including 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: "..." });
  }
}
```

Filter dengan `@Catch()` (tanpa argument) menangani setiap exception — tempat untuk log error yang tidak terduga dan memastikan bahkan error non-HTTP mengembalikan response yang bersih dan aman (tanpa kebocoran stack trace ke klien).

## Applying filters

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

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

Filter biasanya diterapkan **globally** untuk menerapkan format error yang konsisten di seluruh API.

## Mengapa menggunakan 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 throwing 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.
```

## Mengapa ini penting

Exception filters adalah fitur NestJS yang penting untuk membangun API yang robust dan profesional dengan **error handling yang konsisten dan terkontrol**.

Sementara built-in exception layer NestJS sudah mengubah exception yang dilempar menjadi HTTP response, exception filters memberi Anda kontrol penuh untuk mengkustomisasi behavior tersebut — yang penting untuk beberapa kepedulian nyata: menerapkan **consistent error-response shape** di setiap endpoint (sehingga klien selalu mendapatkan error dengan format yang sama), **memusatkan error logging** (menangkap setiap error di satu tempat daripada tersebar di try/catch), dengan aman **menangani unexpected non-HTTP errors** (mengubahnya menjadi clean 500s alih-alih crash atau bocor detail), dan **security** (menyembunyikan internal stack trace dan detail sensitif dari klien sambil mencatatnya secara internal).

Global "catch-all" filter dikombinasikan dengan melempar specific HTTP exceptions dalam kode Anda adalah standard pattern untuk production-grade error handling.

Memahami kapan dan bagaimana menggunakan filters (versus hanya melempar exception), dan menerapkannya globally untuk konsistensi, adalah hallmark dari well-built NestJS applications dan mencerminkan mature back-end practice di sekitar concern error handling yang sering diabaikan namun kritis.