Bagaimana Anda menangani exception di NestJS?

Question

Accepted Answer

NestJS memiliki **built-in exception layer** yang secara otomatis menangkap error yang tidak ditangani dan mengubahnya menjadi HTTP response yang tepat. Anda memberi sinyal error dengan **melempar exception** (sering kali menggunakan built-in HTTP exception classes), dan Nest memformatnya menjadi structured JSON response dengan status code yang benar.

## Melempar built-in HTTP exceptions

```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 exception classes yang memetakan ke HTTP status codes, dan melempar satu menghasilkan response yang benar dan terstruktur secara otomatis:

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

## Common built-in HTTP exceptions

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

Ada satu class untuk setiap HTTP error yang umum — gunakan yang sesuai untuk mengkomunikasikan status yang tepat.

## Custom messages dan generic HttpException

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

## Custom exception classes

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

## Unhandled errors menjadi 500s

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

## Exception filters untuk customization 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 consistent error formatting, logging, atau handling non-HTTP errors, Anda menggunakan **exception filters** (fitur yang terkait, lebih advanced).

## Mengapa ini penting

Proper exception handling adalah essential untuk membangun reliable APIs, dan built-in exception layer NestJS membuatnya clean dan consistent.

Memahami cara **melempar HTTP exceptions** (`NotFoundException`, `BadRequestException`, dll.) adalah everyday knowledge — ini adalah cara idiomatic untuk memberi sinyal error dengan status codes yang benar dan structured, client-friendly JSON responses, tanpa secara manual mengonstruksi error responses di setiap handler.

Framework secara otomatis menangkap ini dan memformatnya, dan ia dengan aman mengkonversi unexpected errors menjadi generic 500s tanpa leak internal details (penting untuk security).

Mengetahui common exception classes, cara melempar custom messages/exceptions, dan bahwa **exception filters** ada untuk global customization (consistent formatting, logging) adalah fundamental untuk membangun robust, professional NestJS APIs.

Clean, consistent error handling adalah hallmark dari quality back-end code, menjadikan ini core, frequently-used aspect dari framework.