Apa sing dimaksud exception filters?

Question

Accepted Answer

**Exception filters** menehi sampeyan kontrol lengkap babagan carane kesalahan **ditangkap lan diowahi dadi tanggapan**. Loro ing pungkasan siklus request, nakarit pengecualian sing dilempar ing manawa-manawa ing request lan menehi sampeyan kesempatan kanggo ngrancang format, status, lan logging tanggapan kasalahan.

## Filter pengecualian dhasar

```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()` nemtokake tipe pengecualian apa sing ditangani filter iki, lan metode `catch()` narima pengecualian plus konteks — menehi sampeyan kesempatan kanggo nggawe tanggapan apa wae sing sampeyan kepingin.

## Nakarit KABEH pengecualian (kaasil 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 karo `@Catch()` (tanpa argumen) nangani saben pengecualian — panggonan kanggo log kasalahan sing ora diperkirakake lan mesthikake malah kesalahan non-HTTP bali tanggapan sing bersih lan aman (tanpa bocoring stack traces marang klien).

## Menerapake filter

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

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

Filter biasane diterapake **global** kanggo ngrampungake format kasalahan sing konsisten ing kabeh API.

## Napa nggunakake 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 versus melempar pengecualian

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

## Napa iki penting

Exception filters minangka fitur NestJS sing penting kanggo mbangun API sing kuat lan profesional karo **consistent, controlled error handling**.

Kadangkala built-in exception layer NestJS wis ngowahi pengecualian sing dilempar dadi tanggapan HTTP, exception filters menehi sampeyan kontrol lengkap kanggo ngrancang prilaku kuwi — apa sing penting kanggo pirang-pirang kepedulian nyata: ngrampungake **consistent error-response shape** ing saben endpoint (supaya klien tansah nampa kesalahan ing format sing padha), **centralizing error logging** (nakarit saben kesalahan ing sawijining panggonan tinimbang sebare ing try/catch), kanthi aman **handling unexpected non-HTTP errors** (ngowahi menyang clean 500s tinimbang bangkruk utawa bocoring detail), lan **security** (ndhelikke internal stack traces lan detail sensitif saking klien nalika nalogging nang njobo).

Global "catch-all" filter sing digabung karo melempar pengecualian HTTP khusus ing kode sampeyan minangka pola standar kanggo production-grade error handling.

Pahami kapan lan kepiye nggunakake filters (tinimbang mung melempar pengecualian), lan nerapake global kanggo konsistensi, minangka tandha aplikasi NestJS sing dbangun kanthi apik lan nggayutake praktek back-end sing mature babagan kepedulian kasalahan sing asring dilalekake nanging kritis.