Summary
This chapter explains how to define and use Data Transfer Objects (DTOs) to enforce and extract structured, typed data within your application. It shows creating a DTO class and applying it with decorators to ensure incoming data matches the expected schema.

General domain of usage
RESTful API development


Create a new file in the `src` folder:

```ts id="dtofile"
create-user.dto.ts
```

Add the following code:

```ts id="dto5"
export class CreateUserDto {
  name: string;
  age: number;
}
```

This DTO defines the structure of the data your application expects.

Now use it in your controller:

```ts id="dto6"
import { Controller, Post, Body } from '@nestjs/common';
import { CreateUserDto } from './create-user.dto';

@Controller('users')
export class UsersController {
  @Post()
  createUser(@Body() body: CreateUserDto) {
    return body;
  }
}
```

Here is what is happening:

* `CreateUserDto`: defines required fields;
* `@Body()`: extracts request data;
* `CreateUserDto`: ensures the data follows the defined structure.

Now send a request with data:

```json id="dto7"
{
  "name": "Alice",
  "age": 30
}
```

The controller receives structured data based on the DTO.

Using DTOs keeps your data consistent and avoids repeating type definitions across your application.


Where is a DTO typically used in Nest.js?

Learn how to build structured backend applications with Nest.js. Organize your code using controllers, services, and modules, handle requests and data validation, and create a complete API using a scalable architecture.

Set up your first Nest.js application and understand how it is structured. Learn how the main files work together to handle requests and organize backend logic.

Learn how to handle requests in Nest.js using controllers and routes. Define endpoints, work with route and query parameters, and control how your backend responds to client requests.

Learn how to organize backend logic using services. Move business logic out of controllers, structure your code properly, and understand how different parts of your application work together.

Learn how Nest.js organizes applications using modules and dependency injection. Understand how different parts of your backend connect and how to structure your code into scalable, maintainable features.

Learn how to handle and validate data in Nest.js. Work with request body data, define structured DTOs, and ensure incoming data is correct using validation pipes.

Summarize what you have learned throughout the track and reinforce your understanding of backend development. Review key concepts and see how they come together into a complete, structured application.

Creating and Using DTOs