Standardize and Validate Incoming Data Using Pipes in NestJS

Thien Pham — Sat, 26 Oct 2024 04:05:19 +0000

If you want to validate & transform the incoming Data before they go into the routes, then you can use Pipes.

Sample git repo: nest-pipes
More information: pipes
Class validator: class-validator
Zod: Zod

Transform & Validate Incoming Data

1. Firstly, Create CatService

export type Cat = {
  id: number;
  name: string;
};

@Injectable()
export class CatService {
  cats: Cat[] = [
    { id: 1, name: 'Cat 1' },
    { id: 2, name: 'Cat 2' },
    { id: 3, name: 'Cat 3' },
  ];

  findOne(id: number): Cat {
    return this.cats.find(cat => cat.id === id);
  }
}

2. Creates CatController

@Controller('cat')
export class CatController {
  constructor(private readonly catService: CatService) {}

  @Get(':id')
  getCat(@Param('id') id: number): Cat {
    return this.catService.findOne(id);
  }
}

3. First call, the response will be empty because the `id` is a string `("1")`

4. Utilize `ParseIntPipe` for Transformation and Validation

 @Get(':id')
 getCat(@Param('id', ParseIntPipe) id: number): Cat {
   return this.catService.findOne(id);
 }

The response is correct now. This means that when we use ParseIntPipe, it will transform the param from string to number

If you pass a string abc, the ParseIntPipe will validate & throw an error back to the client. This means that the pipe validates for us.

You can also use Pipe for a @Query().

  @Get(':id')
  getCat(@Query('id', ParseIntPipe) id: number): Cat {
    return this.catService.findOne(id);
  }

There are many built-in Pipes:

- ValidationPipe
- ParseIntPipe
- ParseFloatPipe
- ParseBoolPipe
- ParseArrayPipe
- ParseUUIDPipe
- ParseEnumPipe
- DefaultValuePipe
- ParseFilePipe

Custom Pipes

1. Update CatService to add a phone for cats =))

export type Cat = {
  id: number;
  name: string;
  phone?: string;
};

@Injectable()
export class CatService {
  cats: Cat[] = [
    { id: 1, name: 'Cat 1' },
    { id: 2, name: 'Cat 2' },
    { id: 3, name: 'Cat 3' },
  ];

  findOne(id: number): Cat {
    return this.cats.find(cat => cat.id === id);
  }

  addPhone(id: number, phone: string): Cat {
    const cat = this.findOne(id);
    cat.phone = phone;
    return cat;
  }
}

2. Create a custom pipe `PhoneValidatePipe`

import { ArgumentMetadata, PipeTransform } from '@nestjs/common';

export class PhoneValidatePipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    if (!value) {
      throw new Error('Phone number is required');
    }
    if (value.length !== 10) {
      throw new Error('Phone number must be 10 digits');
    }
    return '+' + value; // Transform
  }
}

3. Add a new method to `CatController`

 @Post(':id/phone')
  addPhone(
    @Param('id', ParseIntPipe) id: number,
    @Body('phone', new PhoneValidatePipe()) phone: string,
  ): Cat {
    return this.catService.addPhone(id, phone);
  }

4. Check the response

With a wrong phone number

With a correct phone number

So, the Pipes is helping use to validate & transform the incoming data.

Validate a Schema

If you want to validate an object, there are two solutions:

Use class-validator
Use Zod

Use class-validator

$ npm i --save class-validator class-transformer

1. Create a Dto

import { IsNotEmpty, IsOptional, IsString } from 'class-validator';

export class CreateCatDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsOptional()
  phone?: string;
}

2. Update CatController & CatService to add a new Cat

CatService

  create(cat: CreateCatDto): Cat {
    const newCat = {
      id: this.cats.length + 1,
      ...cat,
    };
    this.cats.push(newCat);
    return newCat;
  }

CatController

  @Post()
  async createCat(@Body() cat: CreateCatDto) {
    return this.catService.create(cat);
  }

3. Create `RequestValidationPipe` & extends it from `PipeTransform` like the `PhoneValidatePipe` above to validate and transform data

import { ArgumentMetadata, PipeTransform } from '@nestjs/common';
import { validateOrReject, ValidationError } from 'class-validator';
import { plainToInstance } from 'class-transformer';

export class RequestValidationPipe implements PipeTransform {
  async transform(value: any, { metatype }: ArgumentMetadata) {
    try {
      // validateOrReject & plainToInstance to validate the incoming data
      await validateOrReject(plainToInstance(metatype, value));
    } catch (e) {
      // Format the message response to clients
      if (!(e instanceof Array)) throw e;
      const errors = e.map(errorItem => {
        if (!(errorItem instanceof ValidationError)) throw e;
        return errorItem;
      });
      const message = errors
        .map(error => Object.values(error.constraints))
        .join(', ');
      throw new Error(message);
    }
    return value;
  }
}

4. Use the new custom pipes in the controller

  @Post()
  @UsePipes(new RequestValidationPipe())
  async createCat(@Body() cat: CreateCatDto) {
    return this.catService.create(cat);
  }

4. Result

It'll return error if there is missing fields

Successfully response

Use Zod

npm install --save zod

1. Create Zod Dto

export const createCatSchema = z
  .object({
    name: z.string(),
    phone: z.string().optional(),
  })
  .required();

export type ZodCreateCatDto = z.infer<typeof createCatSchema>;

2. Create `ZodValidationPipe` & still extends from `PipeTransform`

import {
  ArgumentMetadata,
  BadRequestException,
  PipeTransform,
} from '@nestjs/common';
import { ZodSchema } from 'zod';

export class ZodValidationPipe implements PipeTransform {
  constructor(private schema: ZodSchema) {}

  transform(value: unknown, metadata: ArgumentMetadata) {
    try {
      return this.schema.parse(value);
    } catch (error) {
      throw new BadRequestException('Validation failed');
    }
  }
}

3. Update CatController

 @Post()
  @UsePipes(new ZodValidationPipe(createCatSchema))
  async createCat(@Body() cat: CreateCatDto) {
    return this.catService.create(cat);
  }

4. Result

Without name, it'll return the bad request message

With name, it'll return successful response

Summary

Both class-validator and Zod enhance data validation in NestJS by providing robust, flexible, and type-safe mechanisms, ultimately leading to cleaner code and better error management. Choosing between them often depends on specific project requirements and developer preferences.

DEV Community: Thien Pham

Standardize and Validate Incoming Data Using Pipes in NestJS

Transform & Validate Incoming Data

1. Firstly, Create CatService

2. Creates CatController

3. First call, the response will be empty because the id is a string ("1")

4. Utilize ParseIntPipe for Transformation and Validation

Custom Pipes

1. Update CatService to add a phone for cats =))

2. Create a custom pipe PhoneValidatePipe

3. Add a new method to CatController

4. Check the response

Validate a Schema

Use class-validator

1. Create a Dto

2. Update CatController & CatService to add a new Cat

3. Create RequestValidationPipe & extends it from PipeTransform like the PhoneValidatePipe above to validate and transform data

4. Use the new custom pipes in the controller

4. Result

Use Zod

1. Create Zod Dto

2. Create ZodValidationPipe & still extends from PipeTransform

3. Update CatController

4. Result

Summary

3. First call, the response will be empty because the `id` is a string `("1")`

4. Utilize `ParseIntPipe` for Transformation and Validation

2. Create a custom pipe `PhoneValidatePipe`

3. Add a new method to `CatController`

3. Create `RequestValidationPipe` & extends it from `PipeTransform` like the `PhoneValidatePipe` above to validate and transform data

2. Create `ZodValidationPipe` & still extends from `PipeTransform`