1---
2title: Use Pipes for Input Transformation
3impact: MEDIUM
4impactDescription: Pipes ensure clean, validated data reaches your handlers
5tags: api, pipes, validation, transformation
6---
7 
8## Use Pipes for Input Transformation
9 
10Use built-in pipes like `ParseIntPipe`, `ParseUUIDPipe`, and `DefaultValuePipe` for common transformations. Create custom pipes for business-specific transformations. Pipes separate validation/transformation logic from controllers.
11 
12**Incorrect (manual type parsing in handlers):**
13 
14```typescript
15// Manual type parsing in handlers
16@Controller('users')
17export class UsersController {
18  @Get(':id')
19  async findOne(@Param('id') id: string): Promise<User> {
20    // Manual validation in every handler
21    const uuid = id.trim();
22    if (!isUUID(uuid)) {
23      throw new BadRequestException('Invalid UUID');
24    }
25    return this.usersService.findOne(uuid);
26  }
27 
28  @Get()
29  async findAll(
30    @Query('page') page: string,
31    @Query('limit') limit: string,
32  ): Promise<User[]> {
33    // Manual parsing and defaults
34    const pageNum = parseInt(page) || 1;
35    const limitNum = parseInt(limit) || 10;
36    return this.usersService.findAll(pageNum, limitNum);
37  }
38}
39 
40// Type coercion without validation
41@Get()
42async search(@Query('price') price: string): Promise<Product[]> {
43  const priceNum = +price; // NaN if invalid, no error
44  return this.productsService.findByPrice(priceNum);
45}
46```
47 
48**Correct (use built-in and custom pipes):**
49 
50```typescript
51// Use built-in pipes for common transformations
52@Controller('users')
53export class UsersController {
54  @Get(':id')
55  async findOne(@Param('id', ParseUUIDPipe) id: string): Promise<User> {
56    // id is guaranteed to be a valid UUID
57    return this.usersService.findOne(id);
58  }
59 
60  @Get()
61  async findAll(
62    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
63    @Query('limit', new DefaultValuePipe(10), ParseIntPipe) limit: number,
64  ): Promise<User[]> {
65    // Automatic defaults and type conversion
66    return this.usersService.findAll(page, limit);
67  }
68 
69  @Get('by-status/:status')
70  async findByStatus(
71    @Param('status', new ParseEnumPipe(UserStatus)) status: UserStatus,
72  ): Promise<User[]> {
73    return this.usersService.findByStatus(status);
74  }
75}
76 
77// Custom pipe for business logic
78@Injectable()
79export class ParseDatePipe implements PipeTransform<string, Date> {
80  transform(value: string): Date {
81    const date = new Date(value);
82    if (isNaN(date.getTime())) {
83      throw new BadRequestException('Invalid date format');
84    }
85    return date;
86  }
87}
88 
89@Get('reports')
90async getReports(
91  @Query('from', ParseDatePipe) from: Date,
92  @Query('to', ParseDatePipe) to: Date,
93): Promise<Report[]> {
94  return this.reportsService.findBetween(from, to);
95}
96 
97// Custom transformation pipes
98@Injectable()
99export class NormalizeEmailPipe implements PipeTransform<string, string> {
100  transform(value: string): string {
101    if (!value) return value;
102    return value.trim().toLowerCase();
103  }
104}
105 
106// Parse comma-separated values
107@Injectable()
108export class ParseArrayPipe implements PipeTransform<string, string[]> {
109  transform(value: string): string[] {
110    if (!value) return [];
111    return value.split(',').map((v) => v.trim()).filter(Boolean);
112  }
113}
114 
115@Get('products')
116async findProducts(
117  @Query('ids', ParseArrayPipe) ids: string[],
118  @Query('email', NormalizeEmailPipe) email: string,
119): Promise<Product[]> {
120  // ids is already an array, email is normalized
121  return this.productsService.findByIds(ids);
122}
123 
124// Sanitize HTML input
125@Injectable()
126export class SanitizeHtmlPipe implements PipeTransform<string, string> {
127  transform(value: string): string {
128    if (!value) return value;
129    return sanitizeHtml(value, { allowedTags: [] });
130  }
131}
132 
133// Global validation pipe with transformation
134app.useGlobalPipes(
135  new ValidationPipe({
136    whitelist: true, // Strip non-DTO properties
137    transform: true, // Auto-transform to DTO types
138    transformOptions: {
139      enableImplicitConversion: true, // Convert query strings to numbers
140    },
141    forbidNonWhitelisted: true, // Throw on extra properties
142  }),
143);
144 
145// DTO with transformation decorators
146export class FindProductsDto {
147  @IsOptional()
148  @Type(() => Number)
149  @IsInt()
150  @Min(1)
151  page?: number = 1;
152 
153  @IsOptional()
154  @Type(() => Number)
155  @IsInt()
156  @Min(1)
157  @Max(100)
158  limit?: number = 10;
159 
160  @IsOptional()
161  @Transform(({ value }) => value?.toLowerCase())
162  @IsString()
163  search?: string;
164 
165  @IsOptional()
166  @Transform(({ value }) => value?.split(','))
167  @IsArray()
168  @IsString({ each: true })
169  categories?: string[];
170}
171 
172@Get()
173async findAll(@Query() dto: FindProductsDto): Promise<Product[]> {
174  // dto is already transformed and validated
175  return this.productsService.findAll(dto);
176}
177 
178// Pipe error customization
179@Injectable()
180export class CustomParseIntPipe extends ParseIntPipe {
181  constructor() {
182    super({
183      exceptionFactory: (error) =>
184        new BadRequestException(`${error} must be a valid integer`),
185    });
186  }
187}
188 
189// Or use options on built-in pipes
190@Get(':id')
191async findOne(
192  @Param(
193    'id',
194    new ParseIntPipe({
195      errorHttpStatusCode: HttpStatus.NOT_ACCEPTABLE,
196      exceptionFactory: () => new NotAcceptableException('ID must be numeric'),
197    }),
198  )
199  id: number,
200): Promise<Item> {
201  return this.itemsService.findOne(id);
202}
203```
204 
205Reference: [NestJS Pipes](https://docs.nestjs.com/pipes)
206