तपाई NestJS मा exceptions कसरी handle गर्नु हुन्छ?

Question

Accepted Answer

NestJS मा **built-in exception layer** छ जसले स्वचालित रूपमा unhandled errors लाई पक्रेर सही HTTP responses मा परिणत गर्छ। तपाई exceptions फेंक्न (अक्सर built-in HTTP exception classes) द्वारा errors सिग्नल गर्नु हुन्छ, र Nest तिनलाई सही status code सहितको structured JSON responses मा format गर्छ।

## Throwing 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 ले HTTP status codes को साथ mapped exception classes प्रदान गर्छ, र एउटा फेंकिएको exception स्वचालित रूपमा सही, structured response उत्पन्न गर्छ:

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

प्रत्येक common HTTP error को लागि एउटा class छ — सही status communicate गर्न appropriate एउटा प्रयोग गर्नु हुन्छ।

## Custom messages र 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 become 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 for global customization

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

Consistent error formatting, logging, वा non-HTTP errors को handling को लागि, तपाई **exception filters** (एक सम्बन्धित, अधिक advanced feature) प्रयोग गर्नु हुन्छ।

## यो किन महत्त्वपूर्ण छ

सही exception handling विश्वस्त APIs निर्माण गर्न आवश्यक छ, र NestJS को built-in exception layer यसलाई सफा र consistent बनाउँछ।

**कसरी HTTP exceptions फेंक्ने** (`NotFoundException`, `BadRequestException`, आदि) बुझ्नु भनेको दैनिक ज्ञान हो — यो सही status codes र structured, client-friendly JSON responses सहितको errors signal गर्न idiomatic तरिका हो, प्रत्येक handler मा manually error responses निर्माण गरिएको बिना।

Framework स्वचालित रूपमा यिनलाई पक्रेर format गर्छ, र यसले unexpected errors लाई सुरक्षित रूपमा generic 500s मा परिणत गर्छ internal details को खुलासा गरिएको बिना (security को लागि महत्त्वपूर्ण)।

Common exception classes बुझ्नु, custom messages/exceptions कसरी फेंक्ने, र **exception filters** global customization (consistent formatting, logging) को लागि अस्तित्व मा छन् भनेर जान्नु भनेको robust, professional NestJS APIs निर्माण गर्न fundamental हो।

सफा, consistent error handling भनेको quality back-end code को विशेषता हो, यसलाई framework को core, frequently-used पक्ष बनाएको।