પાઈપ્સ શું છે અને ભૂલસુધાર કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

**પાઈપ્સ** એવી ક્લાસો છે જે **ઇનપુટ ડેટાને રૂપાંતરિત અથવા ભૂલસુધાર** કરે છે તે રૂટ હેન્ડલર સુધી પહોંચે તે પહેલાં. તેઓ કંટ્રોલર મેથડોના આર્ગ્યુમેન્ટ્સ પર કાર્ય કરે છે — કાં તો તેમને રૂપાંતરિત કરે છે (દા.તા. સ્ટ્રિંગ → નંબર) અથવા તેમને ભૂલસુધાર કરે છે (અમાન્ય ડેટા અસ્વીકાર કરે છે). NestJS માં ભૂલસુધાર પાઈપ્સ પર બનેલો છે.

## બિલ્ટ-ઇન ટ્રાન્સફોર્મેશન પાઈપ્સ

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

ટ્રાન્સફોર્મેશન પાઈપ્સ ઇનપુટને યોગ્ય પ્રકારમાં રૂપાંતરિત કરે છે (રૂટ પેરામ્સ/ક્વેરી હંમેશા સ્ટ્રિંગ્સ હોય છે), રૂપાંતરણ શક્ય ન હોય તો 400 સાથે નિષ્ફળ થાય છે.

## ValidationPipe — સ્વયંચાલિત DTO ભૂલસુધાર

```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 ભૂલ પરત કરે છે, તેથી તમારો હેન્ડલર ફક્ત માન્ય ડેટા જ પ્રાપ્ત કરે છે.

## પાઈપ્સ વિનંતી પ્રવાહમાં કેવી રીતે ફિટ થાય છે

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

## કસ્ટમ પાઈપ્સ

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

તમે કસ્ટમ ભૂલસુધાર/રૂપાંતરણ તર્કક માટે `PipeTransform` ની `transform()` મેથડ લાગુ કરો છો.

## પાઈપ્સને વિવિધ સ્તરોમાં લાગુ કરવું

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

## તેનું મહત્વ

પાઈપ્સ ઇનપુટને સુરક્ષિત રીતે હેન્ડલ કરવા માટે NestJS નું મુખ્ય લક્ષણ છે, અને તેઓ ફ્રેમવર્ક ની **ભૂલસુધાર સિસ્ટમ** નો આધાર છે.

તેમને સમજવું આવશ્યક છે કારણ કે લગભગ દરેક API એન્ડપોઇન્ટને ઇનપુટ ભૂલસુધાર અને રૂપાંતર કરવાની જરૂર છે: ટ્રાન્સફોર્મેશન પાઈપ્સ (`ParseIntPipe`, વગેરે) પેરામીટર્સ સાચા પ્રકારના છે તે સુનિશ્ચિત કરે છે, અને — સૌથી મહત્વનું — **`ValidationPipe`** DTO સાથે મળીને વિનંતી બોડીનું `class-validator` નિયમો વિરુદ્ધ સ્વયંચાલિત, ઘોષણાત્મક ભૂલસુધાર પ્રદાન કરે છે, અમાન્ય અથવા દૂષિત ઇનપુટ અને તમારા બિઝનેસ તર્કમાં પહોંચે તે પહેલાં સ્પષ્ટ ભૂલો સાથે અસ્વીકાર કરે છે.

તે સુરક્ષા (અવિશ્વસનીય ઇનપુટ ભૂલસુધાર/સ્વચ્છતા કરવી, અપ્રતિબંધિત ગુણધર્મો દૂર કરવી) અને મજબૂતાઈ (હેન્ડલર્સ ફક્ત માન્ય ડેટા જ પ્રાપ્ત કરે છે) બંને માટે નિર્ણાયક છે.

વૈશ્વિક ભૂલસુધાર પાઈપને સમજદારીપૂર્ણ વિકલ્પો (`whitelist`, `transform`) સાથે સક્ષમ કરવું, બિલ્ટ-ઇન ટ્રાન્સફોર્મેશન પાઈપ્સ વાપરવું, અને કસ્ટમ પાઈપ્સ લખવું સુરક્ષિત, સુવ્યવસ્થિત NestJS API બનાવવા માટે મૌલિક છે — પાઈપ્સ અને ભૂલસુધાર ફ્રેમવર્કમાં રોજિંદા, આવશ્યક ખ્યાલો છે.