તમે NestJS માં અપવાદો (Exceptions) કેવી રીતે સંભાળો છો?

Question

Accepted Answer

NestJS માં **built-in exception layer** છે જે આપમેળે આવતા અપ્રતિક્ષિત ભૂલોને પકડે છે અને તેમને યોગ્ય HTTP પ્રતિક્રિયાઓમાં રૂપાંતરિત કરે છે. તમે **exceptions throw કરીને** ભૂલોનો સંકેત આપો છો (ઘણીવાર built-in HTTP exception classes), અને Nest તેમને યોગ્ય status code સાથે structured JSON responses માં ફોર્મેટ કરે છે।

## 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 exception classes પ્રદાન કરે છે જે HTTP status codes સાથે mappings ધરાવે છે, અને તેમાંથી એક throw કરવાથી આપમેળે યોગ્ય, 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 કરવા માટે યોગ્ય એક વાપરો।

## 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 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 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 સંભાળવા માટે, તમે **exception filters** વાપરો છો (એક સંબંધિત, વધુ advanced feature)।

## શા માટે તે મહત્વપૂર્ણ છે

યોગ્ય exception handling reliable APIs બનાવવા માટે આવશ્યક છે, અને NestJS નો built-in exception layer તે સ્વચ્છ અને સુસંગત બનાવે છે।

**HTTP exceptions throw કરવાનું** (`NotFoundException`, `BadRequestException`, વગેરે) કેવી રીતે કરવું તે સમજવું એ દૈનિક જ્ઞાન છે — તે યોગ્ય status codes અને structured, client-friendly JSON responses સાથે ભૂલોનો સંકેત આપવાનું idiomatic રીત છે, દરેક handler માં મેનુવલી error responses બાંધ્યા વિના।

Framework આપમેળે આને પકડે છે અને ફોર્મેટ કરે છે, અને તે અનિચ્છનીય ભૂલોને generic 500s માં સુરક્ષિત રીતે રૂપાંતરિત કરે છે આંતરિક વિગતો leak કર્યા વિના (security માટે મહત્વપૂર્ણ)।

Common exception classes જાણવું, custom messages/exceptions throw કરવું, અને તે જાણવું કે **exception filters** global customization (consistent formatting, logging) માટે અસ્તિત્વમાં છે તે robust, professional NestJS APIs બનાવવા માટે મૌલિક છે।

સ્વચ્છ, સુસંગત error handling એ quality back-end code ની નિશાની છે, આ framework ના આ core, frequently-used પાસાને બનાવે છે।