Pipes என்றால் என்ன மற்றும் validation எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Pipes** என்பது input data ஒரு route handler-ஐ அடைவதற்கு முன் அதை **transform அல்லது validate** செய்யும் classes. அவை controller methods-இன் arguments-இல் செயல்படுகின்றன — அவற்றை transform செய்வது (எ.கா. string → number) அல்லது validate செய்வது (தவறான data-ஐ நிராகரிப்பது). NestJS-இல் validation 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 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 எப்போதும் valid 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 செய்கிறீர்கள்.

## வெவ்வேறு levels-இல் 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`, etc.) parameters சரியான type ஆக இருப்பதை உறுதி செய்கின்றன, மற்றும் — மிக முக்கியமாக — **`ValidationPipe`** DTOs-உடன் இணைந்து `class-validator` விதிகளுக்கு எதிராக request bodies-இன் தானியங்கி, declarative validation-ஐ வழங்குகிறது, தவறான அல்லது தீங்கிழைக்கும் input-ஐ அது உங்கள் business logic-ஐ அடைவதற்கு *முன்* தெளிவான errors-உடன் நிராகரிக்கிறது.

இது security (untrusted input-ஐ validate/sanitize செய்தல், எதிர்பாராத properties-ஐ strip செய்தல்) மற்றும் robustness (handlers valid data-ஐ மட்டுமே பெறுதல்) இரண்டிற்கும் முக்கியமானது.

Global validation pipe-ஐ sensible options-உடன் (`whitelist`, `transform`) எவ்வாறு enable செய்வது, built-in transformation pipes-ஐ பயன்படுத்துவது, மற்றும் custom pipes எழுதுவது எவ்வாறு என்பதை அறிவது பாதுகாப்பான, நன்கு கட்டமைக்கப்பட்ட NestJS APIs-ஐ உருவாக்க அடிப்படை — pipes மற்றும் validation framework-இல் தினசரி, அவசியம் அறிய வேண்டிய கருத்துக்கள்.