რა არის pipes და როგორ მუშაობს ვალიდაცია?

Question

Accepted Answer

**Pipes** არის კლასები, რომლებიც **ტრансფორმირებენ ან ვალიდირებენ** შეყვანილ მონაცემებს, სანამ ისინი მივიდოდნენ route handler-მდე. ისინი მუშაობენ კონტროლერის მეთოდების არგუმენტებზე — ტრანსფორმირებენ მათ (მაგ. string → number) ან ვალიდირებენ მათ (უარყოფენ არასწორ მონაცემებს). NestJS-ში ვალიდაცია აგებულია pipes-ის ზე.

## Built-in transformation pipes

```ts
@Get(":id")
findOne(@Param("id", ParseIntPipe) id: number) {    // transforms "5" (string) → 5 (number)
  // id is guaranteed to be a number; non-numeric input → 400 error automatically
  return this.usersService.findOne(id);
}
// other built-ins: ParseBoolPipe, ParseUUIDPipe, ParseArrayPipe, DefaultValuePipe
```

Transformation pipes ტრანსფორმირებენ შეყვანილ მონაცემებს სწორ ტიპში (route params/query ყოველთვის string არის), ვერ ხდება 400-თი, თუ ტრანსფორმაცია შეუძლებელია.

## The ValidationPipe — automatic DTO validation

```ts
// enable globally in main.ts
app.useGlobalPipes(new ValidationPipe({
  whitelist: true,              // remove properties not declared in the DTO
  forbidNonWhitelisted: true,   // throw if unknown properties are present
  transform: true,              // turn plain objects into DTO instances, convert types
}));
```

```ts
// with a DTO using class-validator decorators:
export class CreateUserDto {
  @IsEmail() email: string;
  @MinLength(8) password: string;
}

@Post()
create(@Body() dto: CreateUserDto) {   // ValidationPipe validates the body automatically
  // if invalid → 400 with details, BEFORE this runs
}
```

`ValidationPipe` კითხულობს DTO-ს `class-validator` დეკორატორებს და ავტომატურად ვალიდირებს შემოსული მონაცემებს — დაბრუნებით დეტალური 400 შეცდომა წარუმატებლობის შემთხვევაში, ასე რომ handler მხოლოდ სწორი მონაცემებს მიიღებს.

## How pipes fit in the request flow

```text
Request → ...middleware/guards/interceptors... → PIPES (transform/validate) → Handler
Pipes run JUST BEFORE the route handler, operating on its method arguments.
```

## Custom pipes

```ts
@Injectable()
export class TrimPipe implements PipeTransform {
  transform(value: any) {
    return typeof value === "string" ? value.trim() : value;   // custom transformation
  }
}
// usage: @Body(TrimPipe) ...
```

შენ აერთებ `PipeTransform`-ის `transform()` მეთოდს მორგებული ვალიდაციის/ტრანსფორმაციის ლოგიკისთვის.

## Applying pipes at different levels

```ts
@UsePipes(new ValidationPipe())      // method or controller level
@Param("id", ParseIntPipe)            // parameter level
app.useGlobalPipes(new ValidationPipe())   // global (most common for validation)
```

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

Pipes არის NestJS-ის ძირითადი ფუნქცია შეყვანილი მონაცემების დაცვითი გამოყენებისთვის, და ისინი არიან framework-ის **ვალიდაციის სისტემის** საფუძველი.

ამის გაგება აუცილებელია, რადგან თითქმის ყველა API endpoint-ი მოითხოვს შეყვანილი მონაცემების ვალიდაციას და ტრანსფორმაციას: transformation pipes (`ParseIntPipe`, და სხვა) უზრუნველყოფენ, რომ პარამეტრები სწორი ტიპია, და — ყველაზე მნიშვნელოვანი — **`ValidationPipe`** DTO-ს თან გამოყენებული უმოვლებელი და დეკლარატული ვალიდაციას აძლევს request body-ს წინააღმდეგ `class-validator` წესების, უარყოფს არასწორ ან ავადმყოფ შეყვანილ მონაცემებს ნათელი შეცდომებით *სანამ* ის ბიზნეს ლოგიკას მივიდოდა.

ეს კრიტიკული არის უსაფრთხოების (არასანდო შეყვანილი მონაცემების ვალიდაციის/დასახელების, მოულოდნელი თვისებების ამოღება) და მოსახლეობის (handlers მხოლოდ სწორი მონაცემებს იღებენ) ორივე მხრივ.

იმის ცოდნა, თუ როგორ უმოვლებელი გლობალური ვალიდაციის pipe-ი ჩართული ვარიანტებით (`whitelist`, `transform`), ჩაშენებული ტრანსფორმაციის pipes გამოყენება და მორგებული pipes ის წერა არის საფუძველი უსაფრთხო, კარგად სტრუქტურირებული NestJS API-ების აშენებისთვის — pipes და ვალიდაცია არის ყოველდღიური, აუცილებელი კონცეფციები framework-ში.