పైప్‌లు అంటే ఏమిటి మరియు ధృవీకరణ ఎలా పనిచేస్తుంది?

Question

Accepted Answer

**పైప్‌లు** అనేవి **రూపాంతరణ లేదా ధృవీకరణ** చేసే తరగతులు, ఇవి మార్గ హ్యాండ్లర్‌కు చేరుకోవడానికి ముందు ఇన్‌పుట్ డేటాను రూపాంతరం లేదా ధృవీకరిస్తాయి. ఇవి నియంత్రకం పద్ధతుల వాదనలపై ఆపరేట్ చేస్తాయి — వాటిని రూపాంతరం చేస్తాయి (ఉదా string → number) లేదా వాటిని ధృవీకరిస్తాయి (చెల్లని డేటాను తిరస్కరిస్తాయి). 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
```

రూపాంతరణ పైప్‌లు ఇన్‌పుట్‌ను సరైన రకంలోకి మార్చుకుంటాయి (మార్గ params/query ఎల్లప్పుడు స్ట్రింగ్‌లు), రూపాంతరం సాధ్యం కాకపోతే 400 వైఫల్యంతో విఫలమవుతాయి.

## The 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 APIs నిర్మించడానికి ఆధారమైనది — పైప్‌లు మరియు ధృవీకరణ ఫ్రేమ్‌వర్క్‌లో రోజువారీ, తప్పనిసరిగా తెలుసుకోవాల్సిన భావనలు.