Validation with Class Validator and Class Transformer in NestJS

NestJS has become a favorite framework for building efficient and scalable server-side applications. One essential aspect of backend development is data validation. Proper validation can prevent numerous issues, including vulnerabilities to attacks and errors caused by unexpected user inputs. This is where Class Validator and Class Transformer come into play. In this blog, we'll delve into how to use these libraries in your NestJS applications effectively.

What Are Class Validator and Class Transformer?

Class Validator is a library used to perform validation on object properties using decorators. It provides a huge range of validation options, allowing developers to define rules in a straightforward and declarative manner.
Class Transformer allows the transformation of plain JavaScript objects into class instances and vice versa. It provides decorators to control how objects are transformed, which is helpful in ensuring incoming data matches the expected structure.

Together, these two libraries form a powerful duo in maintaining data integrity.

Setting Up Your NestJS Project

Assuming you already have a NestJS project set up, you can install Class Validator and Class Transformer with the following command:


npm install class-validator class-transformer

Also, ensure you have the @nestjs/class-validator and @nestjs/class-transformer packages installed if you're using the official NestJS integrations for those libraries:


npm install @nestjs/class-validator @nestjs/class-transformer

Creating a DTO (Data Transfer Object)

DTOs are crucial in simplifying data validation. Let’s create a simple DTO for a user registration scenario.


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

export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  username: string;

  @IsEmail()
  @IsNotEmpty()
  email: string;

  @IsString()
  @MinLength(6)
  password: string;
}

In the CreateUserDto, we declare three properties — username, email, and password — with validation rules applied. The decorators handle validation and can throw errors if the incoming data does not conform.

Implementing Validation in a Controller

Now, let's implement our CreateUserDto in a user registration controller. NestJS has built-in support for pipes, which are a powerful feature for input data handling.


import { Body, Controller, Post } from '@nestjs/common';
import { CreateUserDto } from './create-user.dto';

@Controller('users')
export class UsersController {
  @Post('register')
  async register(@Body() createUserDto: CreateUserDto) {
    // If validation fails, a 400 response will be automatically sent
    return createUserDto; // Handle user registration logic.
  }
}

With this setup, if the incoming request body doesn't match the criteria defined in CreateUserDto, NestJS will automatically return a 400 Bad Request response. This makes data validation seamless and integrates well with NestJS’s overall architecture.

Transforming Data with Class Transformer

Class Transformer helps transform incoming data into class instances. Let’s see how we can enhance our previous example.

You can modify your DTO to include transformation rules:


import { Expose, Transform } from 'class-transformer';
import { IsEmail, IsNotEmpty, IsString, MinLength } from 'class-validator';

export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  @Expose()
  username: string;

  @IsEmail()
  @IsNotEmpty()
  @Expose()
  email: string;

  @IsString()
  @MinLength(6)
  @Expose()
  password: string;

  @Transform(({ value }) => value.trim())
  @IsString()
  @IsNotEmpty()
  @Expose()
  comment: string;
}

In this modified DTO, I added a comment field with a transformation rule that trims whitespace. This way, whenever a user submits a comment with extra spaces, the trimmed version will be used without changing the original input structure.

Using the Transformation in the Controller

To ensure the transformation happens during the request handling, you'll want to include the NestJS built-in ValidationPipe with the transform option set to true. Here it is:


import { Body, Controller, Post, UsePipes, ValidationPipe } from '@nestjs/common';
import { CreateUserDto } from './create-user.dto';

@Controller('users')
@UsePipes(new ValidationPipe({ transform: true }))
export class UsersController {
  @Post('register')
  async register(@Body() createUserDto: CreateUserDto) {
    return createUserDto; // Handle user registration logic.
  }
}

Now, whenever a user registers, the request body will be transformed into an instance of CreateUserDto, allowing you to work with typed properties and simplified logic without worrying about lower-level JavaScript objects.

Key Benefits of Using Class Validator and Class Transformer

Cleaner Code: By consolidating validation and transformation logic in a declarative manner, your controllers will be much cleaner and easier to maintain.
Type Safety: TypeScript types ensure that you’re using your DTOs in a type-safe way, reducing the likelihood of runtime errors.
Automatic Error Handling: The built-in mechanisms provided by NestJS for handling validation errors simplify error management.
Flexible transformations: Easily transform incoming data to meet the required format by customizing transformer decorators.

By employing Class Validator and Class Transformer, developers can significantly enhance the reliability and maintainability of their NestJS applications. Implementing these libraries allows for cleaner code, better type safety, and a smoother workflow when managing user input.