In modern web application development, ensuring that the data passed between the client and server is structured, validated, and secure is paramount. One of the tools that help achieve this is the DTO (Data Transfer Object) design pattern. In NestJS, DTOs are frequently used to define the structure of request and response bodies, while also integrating data validation to ensure that the data meets specific requirements.

In this blog post, we will explore what DTOs are, how to create and use them in NestJS, and how they help manage the flow of data in your application.

What is a DTO (Data Transfer Object)? 🤔

A Data Transfer Object (DTO) is a design pattern that is used to transfer data between different layers of an application. Typically, DTOs are used to encapsulate data that is sent over a network, whether it's in an API request or response. DTOs are especially helpful in:

• Defining the structure of the data 📊
• Performing data validation to ensure data integrity ✅
• Preventing issues like over-fetching or under-fetching of data 🔒

In NestJS, DTOs are usually classes with decorators that define the structure and validation rules for the data. They ensure that the incoming and outgoing data is well-formed, validated, and serialized properly.

Creating a Simple DTO in NestJS ✨

In NestJS, you create a DTO by defining a class. You can then use decorators provided by libraries like class-validator and class-transformer to define validation rules and transform the data.

Example 1: Simple DTO for User Registration 👤

Let’s say you are building a user registration API and need a DTO to validate the data the user sends.

import { IsString, IsEmail, IsInt, Min, Max } from 'class-validator';

export class CreateUserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;

  @IsInt()
  @Min(18)
  @Max(120)
  age: number;
}

In this DTO:

• The @IsString() decorator ensures that the name property is a string. ✍️
• The @IsEmail() decorator ensures that the email property is a valid email address 📧.
• The @IsInt(), @Min(18), and @Max(120) decorators validate that the age is an integer between 18 and 120 🧑‍🤝‍🧑.

Enabling Validation with the Validation Pipe 💪

NestJS integrates the class-validator library for validation and class-transformer for transforming data. To use validation, you need to enable the ValidationPipe globally in your app.

In the main.ts file, add the following code to activate the global validation pipe:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Enable global validation
  app.useGlobalPipes(new ValidationPipe());

  await app.listen(3000);
}
bootstrap();

This will ensure that every incoming request is validated according to the rules defined in your DTOs. 🎯

Using DTOs in Controllers 🧑‍💻

Once the DTO is created and validation is enabled, you can use it in your controllers. For example, you might have a POST endpoint to register a new user, which would accept a CreateUserDto.

Example 2: Controller Using DTO 🚀

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

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
}

In the above example:

• The @Body() decorator extracts the body of the incoming request and automatically maps it to the CreateUserDto. 📥
• The ValidationPipe ensures that any invalid data will result in a 400 HTTP error response ⚠️.

Using DTOs for Responses 🔄

DTOs are not only useful for request validation but also for shaping the data that your application returns in response to the client. This helps prevent exposing unnecessary or sensitive data and ensures that the response format remains consistent.

Example 3: Response DTO for User Data 📨

export class UserResponseDto {
  id: number;
  name: string;
  email: string;
}

In your controller, you can use this response DTO to return a user object:

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto) {
    const newUser = await this.usersService.create(createUserDto);

    // Return a response with the UserResponseDto
    return new UserResponseDto(newUser);
  }
}

In this case, the UserResponseDto ensures that only the id, name, and email properties are included in the response, excluding any other internal data (like passwords). 🔐

Partial DTOs for Updates 🔄

When dealing with updates (such as with a PATCH request), not all fields are required to be provided. NestJS allows you to define optional fields in your DTOs using the @IsOptional() decorator.

Example 4: DTO for Updating a User ✍️

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

export class UpdateUserDto {
  @IsOptional()
  @IsString()
  name?: string;

  @IsOptional()
  @IsEmail()
  email?: string;
}

In this UpdateUserDto:

• The @IsOptional() decorator allows fields to be omitted from the request body. If the client does not provide a name or email, they won’t trigger validation errors. ✅

Nesting DTOs 🔗

DTOs can be nested when you have complex data structures. For example, a user might have an address, which is itself a DTO.

Example 5: Nesting DTOs for User and Address 🏡

export class AddressDto {
  @IsString()
  street: string;

  @IsString()
  city: string;

  @IsString()
  postalCode: string;
}

export class CreateUserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;

  @IsInt()
  age: number;

  @IsOptional()
  @Type(() => AddressDto)  // Use the Type decorator for nested objects
  address?: AddressDto;
}

Here, the CreateUserDto includes an AddressDto. The @Type() decorator (from class-transformer) is used to ensure that the nested AddressDto is properly transformed and validated. 🛠️

Conclusion 🎉

DTOs in NestJS are a powerful tool to help ensure that the data flowing through your application is structured, validated, and secure. They provide several benefits:

• Data Validation: Ensures incoming data meets the required format and constraints. ✅
• Consistency: Standardizes how data is structured, both for requests and responses. 📏
• Security: Helps prevent issues like over-fetching of sensitive data. 🔐

By using DTOs, you ensure that your NestJS applications are scalable, secure, and maintainable. Whether you're validating user input or shaping API responses, DTOs play an essential role in modern NestJS development. 🚀