როგორ მართავთ გამონაკლისებს NestJS-ში?

Question

Accepted Answer

NestJS აქვს **ჩაშენებული გამონაკლისი სამფენი**, რომელიც ავტომატურად ჩაჭერს დაუმუშავებელ შეცდომებს და მათ აკეთებს სწორ HTTP პასუხებად. თქვენ სიგნალ აცემთ შეცდომებს **გამონაკლისების გამოწოდებით** (ხშირად ჩაშენებული HTTP გამონაკლისი კლასებით), და Nest მათ ფორმატირებს სტრუქტურირებულ JSON პასუხებად სწორი სტატუსის კოდით.

## ჩაშენებული HTTP გამონაკლისების გამოწოდება

```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 სტატუსის კოდებზე, და ერთის გამოწოდება ქმნის სწორ, სტრუქტურირებულ პასუხს ავტომატურად:

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

## ჩვენი ჩაშენებული HTTP გამონაკლისი

```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,
);
```

## სამეცნიერო გამონაკლისი კლასები

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

## გამონაკლისი ფილტრი გლობალური მორგების

```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 შეცდომის დამუშავებისთვის, თქვენ იყენებთ **გამონაკლისი ფილტრებს** (დაკავშირებული, უფრო მოწინავე ფუნქცია).

## რატომ არის ეს მნიშვნელოვანი

თანამედროვე გამონაკლისი დამუშავება აუცილებელია საიმედო API-ების აგებისთვის, და NestJS-ის ჩაშენებული გამონაკლისი სამფენი აკეთებს მას სუფთა და თანმიმდევრულ.

გაგება როგორ **გამოწოდება HTTP გამონაკლისი** (`NotFoundException`, `BadRequestException`, და სხვა) არის ყოველდღიური ცოდნა — ეს არის იდიომატური გზა შეცდომების სიგნალიზაციისთვის სწორი სტატუსის კოდებით და სტრუქტურირებული, კლიენტ-მეგობრული JSON პასუხებით, თითოეული დამუშავებელში შეცდომის პასუხების ხელით კონსტრუქციის გარეშე.

ჩარჩო ავტომატურად ჩაჭერს ამ და ფორმატირებს მათ, და უსაფრთხოდ ახელოვს მოულოდნელი შეცდომები ზოგად 500-ებში შიდა დეტალების გაჟონვის გარეშე (მნიშვნელოვანი უსაფრთხოებისთვის).

გავრცელებული გამონაკლისი კლასების ცოდნა, როგორ გამოწოდება შეტყობინება/გამონაკლისები, და რომ **გამონაკლისი ფილტრები** არსებობენ გლობალური მორგებისთვის (თანმიმდევრული ფორმატირება, ჟურნალი) არის ფუნდამენტალური გამრთელი, რომელიც აკეთებს NestJS API-ებს შეზღუდული, პროფესიონალური.

სუფთა, თანმიმდევრული შეცდომის დამუშავება არის ხარისხის უკან-დასკვნის კოდის მახასიათებელი, რაც ამას ფრეიმვორკის ძირითადი, ხშირად გამოყენებული ასპექტი.