ਤੁਸੀਂ NestJS ਵਿੱਚ exceptions ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹੋ?

Question

Accepted Answer

NestJS ਕੋਲ ਇੱਕ **ਬਿਲਤ-ਇਨ exception layer** ਹੈ ਜੋ ਆਪਣੇ ਆਪ ਨੂੰ ਸੰਭਾਲੀ ਗਈ ਗਲਤੀਆਂ ਨੂੰ ਫੜਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਸਹੀ HTTP ਜਵਾਬਾਂ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ **exceptions ਨੂੰ throw** ਕਰਕੇ ਗਲਤੀਆਂ ਨੂੰ ਸੰਕੇਤ ਕਰਦੇ ਹੋ (ਅਕਸਰ ਬਿਲਤ-ਇਨ HTTP exception ਕਲਾਸਾਂ), ਅਤੇ Nest ਉਨ੍ਹਾਂ ਨੂੰ ਸਠੀਕ ਸਥਿਤੀ ਕੋਡ ਦੇ ਨਾਲ ਢਾਂਚਾਗਤ JSON ਜਵਾਬਾਂ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰਦਾ ਹੈ।

## ਬਿਲਤ-ਇਨ 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 ਸਥਿਤੀ ਕੋਡਾਂ ਨਾਲ ਮੇਲ ਖਾਣ ਵਾਲੀਆਂ exception ਕਲਾਸਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਨੂੰ throw ਕਰਨਾ ਆਪਣੇ ਆਪ ਇੱਕ ਸਹੀ, ਢਾਂਚਾਗਤ ਜਵਾਬ ਪੈਦਾ ਕਰਦਾ ਹੈ:

```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 ਗਲਤੀ ਲਈ ਇੱਕ ਕਲਾਸ ਹੈ — ਸਹੀ ਸਥਿਤੀ ਨੂੰ ਸੰਚਾਰ ਕਰਨ ਲਈ ਢੁਕਵੀਂ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ।

## ਕਸਟਮ ਸੁਨੇਹੇ ਅਤੇ ਜੈਨਰਿਕ HttpException

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

## ਕਸਟਮ exception ਕਲਾਸਾਂ

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

## ਸੰਭਾਲੀ ਗਈ ਗਲਤੀਆਂ 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).
```

## ਵਿਸ਼ਵਵਿਆਪੀ ਕਸਟਮਾਈਜੇਸ਼ਨ ਲਈ 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
```

ਇਕਸਾਰ ਗਲਤੀ ਫਾਰਮੈਟਿੰਗ, ਲਾਗਿੰਗ, ਜਾਂ ਗੈਰ-HTTP ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਤੁਸੀਂ **exception filters** (ਇੱਕ ਸਬੰਧਤ, ਹੋਰ ਉਨੱਤ ਫਿਚਰ) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ।

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਸਹੀ exception ਹ੍ਰਿਦਾ ਭਰੋਸੇਮੰਦ APIs ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ NestJS ਦੀ ਬਿਲਤ-ਇਨ exception ਲੇਅਰ ਇਸ ਨੂੰ ਸਾਫ ਅਤੇ ਇਕਸਾਰ ਬਣਾਉਂਦੀ ਹੈ।

**HTTP exceptions** (`NotFoundException`, `BadRequestException`, ਆਦਿ) ਨੂੰ ਕਿਵੇਂ throw ਕਰਨਾ ਹੈ ਇਹ ਸਮਝਨਾ ਰੋਜ਼ਾਨਾ ਦਾ ਗਿਆਨ ਹੈ — ਇਹ ਸਹੀ ਸਥਿਤੀ ਕੋਡਾਂ ਨਾਲ ਗਲਤੀਆਂ ਨੂੰ ਸੰਕੇਤ ਕਰਨ ਅਤੇ ਢਾਂਚਾਗਤ, ਕਲਾਈਂਟ-ਅਨੁਕੂਲ JSON ਜਵਾਬ ਦੇਣ ਦਾ idiomatic ਤਰੀਕਾ ਹੈ, ਹਰੇਕ ਹ੍ਰਿਦਾ ਵਿੱਚ ਜਵਾਬ ਨੂੰ ਹੱਥੀ ਨਾਲ ਬਣਾਏ ਬਿਨਾਂ।

ਫ੍ਰੇਮਵਰਕ ਆਪਣੇ ਆਪ ਉਨ੍ਹਾਂ ਨੂੰ ਫੜਦਾ ਹੈ ਅਤੇ ਫਾਰਮੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਅਪ੍ਰਤੀਸ਼ਿਤ ਗਲਤੀਆਂ ਨੂੰ ਜੈਨਰਿਕ 500 ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ ਬਿਨਾਂ ਅੰਦਰੂਨੀ ਵੇਰਵਿਆਂ ਨੂੰ ਲੀਕ ਕੀਤੇ (ਸੁਰੱਖਿਆ ਲਈ ਮਹੱਤਵਪੂਰਨ)।

ਆਮ exception ਕਲਾਸਾਂ ਨੂੰ ਜਾਣਨਾ, ਕਸਟਮ ਸੁਨੇਹੇ/exceptions ਨੂੰ ਕਿਵੇਂ throw ਕਰਨਾ ਹੈ, ਅਤੇ ਇਹ ਕਿ **exception filters** ਵਿਸ਼ਵਵਿਆਪੀ ਕਸਟਮਾਈਜੇਸ਼ਨ (ਇਕਸਾਰ ਫਾਰਮੈਟਿੰਗ, ਲਾਗਿੰਗ) ਲਈ ਮੌਜੂਦ ਹਨ ਭਰੋਸੇਮੰਦ, ਪੇਸ਼ੇਵਰ NestJS APIs ਬਣਾਉਣ ਲਈ ਬਨਿਆਦੀ ਹੈ।

ਸਾਫ, ਇਕਸਾਰ ਗਲਤੀ ਹ੍ਰਿਦਾ ਗੁਣਵੱਤਾ ਵਾਲੇ back-end ਕੋਡ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ, ਇਸ ਨੂੰ ਫ੍ਰੇਮਵਰਕ ਦਾ ਇੱਕ ਮੂਲ, ਵਾਰ-ਵਾਰ-ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਪਹਿਲੂ ਬਣਾਉਂਦਾ ਹੈ।