Pipes ni nini na validation hufanya kazi vipi?

Question

Accepted Answer

**Pipes** ni classes ambazo **hubadilisha au kuthibitisha (transform or validate)** data ya input kabla haijafika kwa route handler. Hufanya kazi kwenye arguments za methods za controller — ama kuzibadilisha (mfano string → number) au kuzithibitisha (kukataa data isiyo halali). Validation katika NestJS imejengwa juu ya pipes.

## Transformation pipes zilizojengwa ndani

```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 hubadilisha input kuwa aina sahihi (route params/query daima ni strings), zikishindwa kwa kosa la 400 iwapo ubadilishaji hauwezekani.

## ValidationPipe — validation ya DTO kiotomatiki

```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` husoma decorators za `class-validator` za DTO na huthibitisha data inayoingia kiotomatiki — ikirudisha kosa la 400 lenye maelezo iwapo itashindikana, hivyo handler yako daima hupokea data halali pekee.

## Jinsi pipes zinavyoingia katika mtiririko wa request

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

Unatekeleza method ya `transform()` ya `PipeTransform` kwa logic yako maalum ya validation/transformation.

## Kutumia pipes katika viwango tofauti

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

## Kwa nini ni muhimu

Pipes ni kipengele muhimu cha NestJS cha kushughulikia input kwa usalama, na ndizo msingi wa **mfumo wa validation** wa framework.

Kuzielewa ni muhimu kwa sababu karibu kila API endpoint inahitaji kuthibitisha na kubadilisha input: transformation pipes (`ParseIntPipe`, n.k.) huhakikisha parameters ni za aina sahihi, na — muhimu zaidi — **`ValidationPipe`** ikiunganishwa na DTOs hutoa validation ya kutangaza, kiotomatiki ya request bodies dhidi ya kanuni za `class-validator`, ikikataa input isiyo halali au yenye nia ovu kwa makosa wazi *kabla* haijafika kwenye business logic yako.

Hili ni muhimu kwa usalama (kuthibitisha/kusafisha input isiyoaminika, kuondoa properties zisizotarajiwa) na uimara (handlers hupokea data halali pekee).

Kujua jinsi ya kuwezesha global validation pipe yenye chaguo mwafaka (`whitelist`, `transform`), kutumia transformation pipes zilizojengwa ndani, na kuandika custom pipes ni msingi kwa kujenga API za NestJS salama na zilizopangwa vizuri — pipes na validation ni dhana za kila siku zinazopaswa kujulikana katika framework hii.