NestJS లో మీరు exceptions ను ఎలా నిర్వహిస్తారు?

Question

Accepted Answer

NestJS ఒక **built-in exception layer** కలిగి ఉంది, ఇది స్వయంచాలకంగా నిర్వహించని errors ని పట్టుకుని వాటిని సరైన HTTP responses లకు మార్చుతుంది. మీరు **exceptions ని throw** చేయడం ద్వారా errors ను సిగ్నల్ చేస్తారు (తరచుగా built-in HTTP exception classes), మరియు Nest వాటిని సరైన status code కలిగిన నిర్మాణాత్మక JSON responses లకు ఫార్మాట్ చేస్తుంది.

## Built-in 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" }
```

## సాధారణ built-in HTTP exceptions

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

ప్రతి సాధారణ HTTP error కోసం ఒక class ఉంది — సరైన status ను సంప్రේషించడానికి తగిన దానిని ఉపయోగించండి.

## కస్టమ్ messages మరియు generic HttpException

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

## కస్టమ్ 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);
```

## నిర్వహించని errors 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

```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 ఫార్మాటింగ్, logging, లేదా non-HTTP errors ని నిర్వహించడం కోసం, మీరు **exception filters** (సంబంధిత, మరింత advanced feature) ని ఉపయోగిస్తారు.

## ఇది ఎందుకు ముఖ్యమైనది

నమ్మకమైన APIs ని నిర్మించడానికి సరైన exception handling అත్యవश్యకమైనది, మరియు NestJS యొక్క built-in exception layer దీనిని స్వచ్ఛమైన మరియు సంગతമైనదిగా చేస్తుంది.

**HTTP exceptions** (`NotFoundException`, `BadRequestException`, మొదలైనవి) ని throw చేయడం ఎలా చేయాలో అర్థం చేసుకోవడం రోజువారీ జ్ఞానం — ఇది సరైన status codes మరియు నిర్మాణాత్మక, client-friendly JSON responses లతో errors ను సిగ్నల్ చేసే idiomatic మార్గం, ప్రతి handler లో manually error responses ని నిర్మించకుండా.

ఫ్రేమ్‌వర్క్ ఆటోమేటిక్‌గా ఈవిటిని పట్టుకుని ఫార్మాట్ చేస్తుంది, మరియు ఇది unexpected errors ను generic 500s లకు సురక్షితంగా మార్చుతుంది, గుప్తమైన వివరాలను లీక్ చేయకుండా (భద్రత కోసం ముఖ్యమైనది).

సాధారణ exception classes, కస్టమ్ messages/exceptions ని throw చేయడం ఎలా చేయాలో, మరియు **exception filters** విశ్వ వ్యక్తిగతీకరణ కోసం ఉనికిలో ఉన్నాయని తెలుసుకోవడం (స్థిరమైన ఫార్మాటింగ్, logging) robust, professional NestJS APIs ని నిర్మించడానికి ప్రాథమికమైనది.

స్వచ్ఛమైన, సంగత error handling అనేది quality back-end code యొక్క లక్షణం, ఇది ఫ్రేమ్‌వర్క్ యొక్క ప్రధాన, తరచుగా-ఉపయోగించిన అంశం.