Apakah itu exception filters?

Question

Accepted Answer

**Exception filters** memberi anda kawalan penuh ke atas cara ralat **ditangkap dan diubah menjadi response**. Ia berada di hujung kitar hayat request, menangkap exceptions yang dilemparkan di mana-mana dalam request dan membolehkan anda menyesuaikan format response ralat, status, dan logging.

## Satu exception filter asas

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

Dekorator `@Catch()` menentukan jenis exception yang dikendalikan oleh filter ini, dan method `catch()` menerima exception berserta context — membolehkan anda mencipta apa-apa response yang anda mahu.

## Menangkap SEMUA exceptions (termasuk bukan-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: "..." });
  }
}
```

Satu filter dengan `@Catch()` (tanpa argumen) mengendalikan setiap exception — tempat untuk mencatat ralat yang tidak dijangka dan memastikan walaupun ralat bukan-HTTP memulangkan response yang bersih dan selamat (tanpa membocorkan stack trace kepada client).

## Menggunakan filters

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

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

Filters biasanya diterapkan secara **global** untuk menguatkuasakan format ralat yang konsisten merentas keseluruhan 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 lwn melemparkan 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 ia penting

Exception filters ialah satu ciri NestJS yang penting untuk membina API yang teguh dan profesional dengan **pengendalian ralat yang konsisten dan terkawal**.

Walaupun lapisan exception terbina NestJS sudah pun mengubah exceptions yang dilemparkan menjadi response HTTP, exception filters memberi anda kawalan penuh untuk menyesuaikan kelakuan itu — yang penting untuk beberapa urusan sebenar: menguatkuasakan **bentuk response-ralat yang konsisten** merentas setiap endpoint (supaya client sentiasa mendapat ralat dalam format yang sama), **memusatkan logging ralat** (menangkap setiap ralat di satu tempat dan bukannya try/catch yang berselerak), **mengendalikan dengan selamat** ralat bukan-HTTP yang tidak dijangka (menukarnya kepada 500 yang bersih dan bukannya terhempas atau membocorkan butiran), dan **keselamatan** (menyembunyikan stack trace dalaman dan butiran sensitif daripada client sambil mencatatnya secara dalaman).

Satu filter "catch-all" global digabungkan dengan melemparkan HTTP exceptions tertentu dalam kod anda ialah corak standard untuk pengendalian ralat bergred-production.

Memahami bila dan bagaimana menggunakan filters (berbanding sekadar melemparkan exceptions), dan menerapkannya secara global untuk konsistensi, ialah tanda aplikasi NestJS yang dibina dengan baik dan mencerminkan amalan back-end yang matang seputar urusan pengendalian ralat yang sering diabaikan tetapi kritikal.