NestJS में आप exceptions को कैसे संभालते हैं?

Question

Accepted Answer

NestJS में एक **बिल्ट-इन exception layer** है जो स्वचालित रूप से unhandled errors को पकड़कर उन्हें उचित HTTP responses में बदल देती है। आप **exceptions throw करके** (अक्सर बिल्ट-इन HTTP exception classes) errors का संकेत देते हैं, और Nest उन्हें सही status code के साथ संरचित JSON responses में formats कर देता है।

## बिल्ट-इन HTTP exceptions throw करना

```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 से मैप होने वाली exception classes प्रदान करता है, और किसी एक को throw करने से स्वचालित रूप से एक सही, संरचित response उत्पन्न होता है:

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

## आम बिल्ट-इन HTTP exceptions

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

हर आम HTTP error के लिए एक class है — सही status संप्रेषित करने के लिए उपयुक्त को इस्तेमाल करें।

## Custom messages और सामान्य 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 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).
```

## Global customization के लिए exception filters

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

सुसंगत error formatting, logging, या गैर-HTTP errors को संभालने के लिए, आप **exception filters** (एक संबंधित, अधिक उन्नत feature) का उपयोग करते हैं।

## यह क्यों महत्वपूर्ण है

विश्वसनीय APIs बनाने के लिए उचित exception handling आवश्यक है, और NestJS की बिल्ट-इन exception layer इसे स्वच्छ और सुसंगत बनाती है।

**HTTP exceptions throw करना** (`NotFoundException`, `BadRequestException`, आदि) कैसे है यह समझना रोज़मर्रा का ज्ञान है — यह सही status codes और संरचित, client-अनुकूल JSON responses के साथ errors का संकेत देने का आदर्श तरीका है, बिना हर handler में मैनुअल रूप से error responses बनाए।

Framework इन्हें स्वचालित रूप से पकड़कर format करता है, और यह अप्रत्याशित errors को आंतरिक विवरण लीक किए बिना सुरक्षित रूप से सामान्य 500 में बदल देता है (security के लिए महत्वपूर्ण)।

आम exception classes को जानना, custom messages/exceptions कैसे throw करें, और यह कि global customization (सुसंगत formatting, logging) के लिए **exception filters** मौजूद हैं — यह मज़बूत, पेशेवर NestJS APIs बनाने के लिए मौलिक है।

स्वच्छ, सुसंगत error handling गुणवत्तापूर्ण back-end code की पहचान है, जिससे यह framework का एक मूल, बार-बार उपयोग होने वाला पहलू बन जाता है।