DTO และไปป์ตรวจสอบข้อมูล

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.

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:

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.

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!

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.

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

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.

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.

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.

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.