Pipes क्या होते हैं और validation कैसे काम करता है?

Question

Accepted Answer

**Pipes** ऐसी classes हैं जो किसी route handler तक पहुँचने से पहले input data को **transform या validate** करती हैं। वे controller methods के arguments पर काम करती हैं — या तो उन्हें transform करती हैं (जैसे string → number) या validate करती हैं (अमान्य data को अस्वीकार करते हुए)। NestJS में validation pipes पर ही आधारित है।

## बिल्ट-इन 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 input को सही type में बदल देती हैं (route params/query हमेशा strings होते हैं), और यदि रूपांतरण संभव न हो तो 400 के साथ विफल हो जाती हैं।

## ValidationPipe — स्वचालित 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` decorators को पढ़ता है और आने वाले data को स्वचालित रूप से validate करता है — विफलता पर विस्तृत 400 error लौटाते हुए, ताकि आपके handler को हमेशा केवल मान्य data ही मिले।

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

आप custom validation/transformation logic के लिए `PipeTransform` की `transform()` method को implement करते हैं।

## विभिन्न स्तरों पर pipes लागू करना

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

## यह क्यों महत्वपूर्ण है

Pipes input को सुरक्षित ढंग से संभालने के लिए एक प्रमुख NestJS feature हैं, और वे framework के **validation system** की नींव हैं।

इन्हें समझना आवश्यक है क्योंकि लगभग हर API endpoint को input को validate और transform करने की आवश्यकता होती है: transformation pipes (`ParseIntPipe`, आदि) सुनिश्चित करती हैं कि parameters सही type के हों, और — सबसे महत्वपूर्ण रूप से — DTOs के साथ मिलकर **`ValidationPipe`** request bodies का `class-validator` नियमों के विरुद्ध स्वचालित, declarative validation प्रदान करता है, जो अमान्य या दुर्भावनापूर्ण input को आपके business logic तक पहुँचने से *पहले* स्पष्ट errors के साथ अस्वीकार कर देता है।

यह security (अविश्वसनीय input को validate/sanitize करना, अप्रत्याशित properties हटाना) और मज़बूती (handlers को केवल मान्य data मिलना) दोनों के लिए महत्वपूर्ण है।

समझदार विकल्पों (`whitelist`, `transform`) के साथ global validation pipe को कैसे सक्षम करें, बिल्ट-इन transformation pipes का उपयोग कैसे करें, और custom pipes कैसे लिखें — यह जानना सुरक्षित, सुव्यवस्थित NestJS APIs बनाने के लिए मौलिक है — pipes और validation framework में रोज़मर्रा के, अवश्य-जानने योग्य अवधारणाएँ हैं।