Kepiye cara nangani pengecualian ing NestJS?

Question

Accepted Answer

NestJS nduweni **lapisan pengecualian sing built-in** sing sacara otomatis nemokake kesalahan sing ora ditangani lan ngganti dadi tanggapan HTTP sing tepat. Panjang sinyal kesalahan kanthi **muncul pengecualian** (biasane kelas pengecualian HTTP sing built-in), lan Nest ngganti dadi tanggapan JSON sing terstruktur kanthi kode status sing bener.

## Muncul pengecualian HTTP sing built-in

```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 nyedhiyakake kelas pengecualian sing dipetakake menyang kode status HTTP, lan muncul salah siji ngasilake tanggapan sing bener lan terstruktur sacara otomatis:

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

## Pengecualian HTTP sing built-in sing umum

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

Ana kelas kanggo saben kesalahan HTTP sing umum — nggunakake sing sesuai kanggo nglaporake status sing bener.

## Pesen khusus lan HttpException umum

```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 sing ora ditangani dadi 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 kanggo kustomisasi 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 sing konsisten, pencatatan, utawa nangani kesalahan non-HTTP, sampeyan nggunakake **filter pengecualian** (fitur sing gegandhengan lan luwih maju).

## Kepiye sing penting

Nangani pengecualian sing tepat penting kanggo mbangun API sing andal, lan lapisan pengecualian sing built-in saka NestJS nggawe bersih lan konsisten.

Ngreti kepiye cara **muncul pengecualian HTTP** (`NotFoundException`, `BadRequestException`, lsp.) minangka kawruh setiap hari — iku cara idiomatik kanggo sinyal kesalahan kanthi kode status sing bener lan tanggapan JSON sing terstruktur lan ramah-klien, nang nangane construct tanggapan kesalahan ing saben handler.

Kerangka kerja sacara otomatis nemokake iki lan ngganti, lan kanthi aman ngganti kesalahan sing ora entuk dijupuk dadi 500 generik tanpa kebocoran rincian internal (penting kanggo keamanan).

Ngerti kelas pengecualian umum, kepiye cara muncul pesen/pengecualian khusus, lan yen **filter pengecualian** ana kanggo kustomisasi global (pemformatan konsisten, pencatatan) minangka fundamental kanggo mbangun API NestJS sing kokoh lan profesional.

Nangani kesalahan sing bersih lan konsisten minangka ciri khasiat saka kode backend sing berkualitas, nggawe iki minangka aspek inti lan sering digunakake saka kerangka kerja.