Bagaimana anda menangani pengecualian di NestJS?

Question

Accepted Answer

NestJS mempunyai **lapisan pengecualian bawaan** yang secara automatik menangkap kesalahan yang tidak ditangani dan mengubahnya menjadi respons HTTP yang tepat. Anda memberi isyarat kesalahan dengan **melempar pengecualian** (sering kali kelas pengecualian HTTP bawaan), dan Nest memformatnya ke dalam respons JSON terstruktur dengan kod status yang benar.

## Melempar pengecualian HTTP bawaan

```ts
import { NotFoundException, BadRequestException, UnauthorizedException } from "@nestjs/common";

@Get(":id")
findOne(@Param("id") id: string) {
  const user = this.usersService.findOne(id);
  if (!user) {
    throw new NotFoundException("User not found");   // → 404 with a JSON error body
  }
  return user;
}
```

NestJS menyediakan kelas pengecualian yang dipetakan ke kod status HTTP, dan melempar satu menghasilkan respons yang benar dan terstruktur secara automatik:

```json
{ "statusCode": 404, "message": "User not found", "error": "Not Found" }
```

## Pengecualian HTTP bawaan yang biasa

```text
BadRequestException        → 400
UnauthorizedException      → 401
ForbiddenException         → 403
NotFoundException          → 404
ConflictException          → 409
UnprocessableEntityException → 422
InternalServerErrorException → 500
```

Ada kelas untuk setiap kesalahan HTTP biasa — gunakan yang sesuai untuk mengkomunikasikan status yang benar.

## Pesan khusus dan HttpException generik

```ts
// custom status + body via the base HttpException
throw new HttpException(
  { status: HttpStatus.FORBIDDEN, error: "custom message" },
  HttpStatus.FORBIDDEN,
);
```

## Kelas pengecualian khusus

```ts
export class UserNotFoundException extends NotFoundException {
  constructor(id: string) {
    super(`User with id ${id} not found`);   // domain-specific, reusable
  }
}
throw new UserNotFoundException(id);
```

## Kesalahan yang tidak ditangani menjadi 500

```text
If code throws a non-HttpException error (e.g. a plain Error or an unexpected
exception), NestJS's default exception filter catches it and returns a generic
500 Internal Server Error (without leaking internal details to the client).
```

## Filter pengecualian untuk penyesuaian global

```ts
// a custom exception filter customizes how errors are formatted/logged globally
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // log, format the response, etc.
  }
}
app.useGlobalFilters(new AllExceptionsFilter());   // apply app-wide
```

Untuk pemformatan kesalahan yang konsisten, pengelogan, atau penanganan kesalahan non-HTTP, anda menggunakan **filter pengecualian** (fitur terkait yang lebih maju).

## Mengapa ini penting

Penanganan pengecualian yang tepat adalah penting untuk membina API yang boleh dipercayai, dan lapisan pengecualian bawaan NestJS menjadikannya bersih dan konsisten.

Memahami cara **melempar pengecualian HTTP** (`NotFoundException`, `BadRequestException`, dll.) adalah pengetahuan sehari-hari — ini adalah cara idiomatik untuk memberi isyarat kesalahan dengan kod status yang benar dan respons JSON yang terstruktur dan mesra-klien, tanpa membina respons kesalahan secara manual dalam setiap pengendalian.

Kerangka kerja secara automatik menangkap ini dan memformatkannya, dan dengan aman mengubah kesalahan yang tidak dijangka menjadi 500 generik tanpa membocorkan butiran dalaman (penting untuk keselamatan).

Memahami kelas pengecualian biasa, cara melempar pesan/pengecualian khusus, dan bahawa **filter pengecualian** wujud untuk penyesuaian global (pemformatan konsisten, pengelogan) adalah asas untuk membina API NestJS yang kukuh dan profesional.

Penanganan kesalahan yang bersih dan konsisten adalah ciri kod belakang berkualiti tinggi, menjadikan ini aspek teras dan sering digunakan bagi rangka kerja.