0Pricing
NestJS Enterprise Backend APIs · Aula

DTOs e Pipes de Validação

Implemente Objetos de Transferência de Dados (DTOs) e use pipes de validação para garantir que os dados recebidos nas requisições atendam aos critérios definidos.

DTOs e Pipes de Validação é uma aula grátis de NestJS Enterprise Backend APIs no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de NestJS Enterprise Backend APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de NestJS Enterprise Backend APIs inclui 3 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Why Data Transfer Objects?

When building APIs, your application receives data from users. This data needs to be structured and safe.

Data Transfer Objects (DTOs) are plain classes that define the expected shape of the data coming into your application (e.g., from a request body) or going out (e.g., as a response).

Using DTOs helps with:

  • Clarity: Clearly shows what data is expected.
  • Consistency: Ensures data adheres to a specific format.
  • Security: Prevents unexpected or malicious data from being processed.

Defining a Simple DTO

A DTO is essentially a TypeScript class with properties that match the data you expect. It's a blueprint for your data.

Here's a basic example for creating a new product:

export class CreateProductDto {
  name: string;
  description: string;
  price: number;
}

DTOs in NestJS Context

In a NestJS application, you'll typically create DTO files in a dto folder within your module (e.g., src/products/dto/create-product.dto.ts).

These classes are then used in your controllers to type the incoming request body.

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

@Controller('products')
export class ProductsController {
  @Post()
  create(@Body() createProductDto: CreateProductDto) {
    // createProductDto will have 'name', 'description', 'price'
    console.log(createProductDto);
    return 'Product created!';
  }
}

Why Validate Input?

Just defining a DTO isn't enough. What if a user sends invalid data?

  • A name that's too short?
  • A price that's negative or not a number?
  • Missing required fields?

Without validation, your application could:

  • Store bad data.
  • Crash unexpectedly.
  • Be vulnerable to security exploits.

This is where NestJS Validation Pipes come in!

Introducing Validation Pipes

A Validation Pipe is a special type of middleware in NestJS that automatically validates incoming request data against your DTO definitions.

If the data doesn't match the rules you've set, the pipe will automatically throw an error, preventing invalid data from reaching your controller logic.

The Validation Duo: `class-validator` & `class-transformer`

NestJS leverages two powerful libraries for DTO validation:

  • class-validator: Provides decorators (like @IsString(), @IsInt()) to define validation rules directly on your DTO properties.
  • class-transformer: Helps convert plain JavaScript objects (from the request body) into instances of your DTO classes, which is crucial for class-validator to work correctly.

You'll need to install them:

npm i class-validator class-transformer

Decorating Your DTOs for Validation

Let's add some validation rules to our CreateProductDto using decorators from class-validator.

These decorators ensure that the incoming data meets specific criteria, like being a string, a number, or not empty.

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

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

  @IsString()
  @IsNotEmpty()
  description: string;

  @IsNumber()
  @IsPositive()
  price: number;
}

Applying `ValidationPipe` to a Route

Now that our DTO has validation decorators, we need to tell NestJS to use the ValidationPipe for a specific route.

You can apply it using the @UsePipes() decorator on your controller method. This makes the pipe active only for that particular route.

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

@Controller('products')
export class ProductsController {
  @Post()
  @UsePipes(new ValidationPipe()) // Apply pipe here
  create(@Body() createProductDto: CreateProductDto) {
    // If validation fails, this code won't run
    return `Product '${createProductDto.name}' created!`;
  }
}

Global Validation Pipe

Applying @UsePipes(new ValidationPipe()) to every method can be repetitive. For consistency, you can register the ValidationPipe globally in your main.ts file.

This will apply the validation pipe to all incoming requests across your entire application, simplifying your code and ensuring consistent validation.

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe()); // Apply pipe globally
  await app.listen(3000);
}
bootstrap();

Check Your Knowledge

Time to test what you've learned about DTOs and Validation Pipes!

Recap: DTOs & Validation Pipes

You've mastered DTOs and Validation Pipes!

  • DTOs are TypeScript classes that define the structure of data for your API.
  • They bring clarity, consistency, and security to your data handling.
  • Validation Pipes automatically enforce rules defined by class-validator decorators.
  • class-transformer ensures incoming data is converted to DTO instances for validation.
  • Pipes can be applied per-route with @UsePipes() or globally in main.ts.

This ensures your NestJS API always receives and processes clean, valid data.

Perguntas Frequentes

A aula “DTOs e Pipes de Validação” é grátis?

Sim — o texto completo de “DTOs e Pipes de Validação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de NestJS Enterprise Backend APIs, atualize para CoddyKit PRO. O curso de NestJS Enterprise Backend APIs inclui 3 aulas no total.

O que vou aprender em “DTOs e Pipes de Validação”?

Implemente Objetos de Transferência de Dados (DTOs) e use pipes de validação para garantir que os dados recebidos nas requisições atendam aos critérios definidos. Você pratica NestJS Enterprise Backend APIs com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar NestJS Enterprise Backend APIs?

Nenhuma experiência prévia é necessária. NestJS Enterprise Backend APIs no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “DTOs e Pipes de Validação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de NestJS Enterprise Backend APIs?

Sim. Cada aula de NestJS Enterprise Backend APIs inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Injeção de Dependências Explicada
  2. DTOs e Pipes de Validação
  3. Fundamentos da Integração com TypeORM
← Voltar para NestJS Enterprise Backend APIs