DTO class creation in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a NestJS DTO class is used for validation?

Consider this DTO class in NestJS using class-validator decorators. What will happen if the input object misses the email property?

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

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

  @IsEmail()
  email: string;
}

A Validation passes because only the name property is required.

B Validation fails because the email property is missing.

C Validation fails because name is missing, not email.

D Validation passes and email is set to null automatically.

💡 Hint

Think about what happens when a required decorated property is missing in the input.

The @IsEmail() decorator requires the email property to be present and valid. Missing it causes validation to fail.

📝 Syntax

intermediate

Which DTO class syntax is correct for optional properties in NestJS?

You want to create a DTO class where the age property is optional. Which code snippet correctly defines this?

A

export class PersonDto {
  @IsOptional()
  @IsNumber()
  age?: number;
}

B

export class PersonDto {
  @IsNumber()
  age?: number;
}

C

export class PersonDto {
  @IsOptional()
  age: number;
}

D

export class PersonDto {
  age: number | undefined;
}

💡 Hint

Optional properties need a special decorator to skip validation if missing.

The @IsOptional() decorator tells the validator to ignore the property if it is not present. The property must also be marked optional with ?.

🔧 Debug

advanced

Why does this DTO class cause a runtime error in NestJS?

Look at this DTO class code. Why does it cause a runtime error when used in a controller?

export class ProductDto {
  name: string;
  price: number;

  constructor() {
    this.name = '';
  }
}

A NestJS DTO classes should not have constructors; this causes runtime errors.

B The constructor does not initialize the price property, causing an error.

C Missing decorators on properties cause runtime errors.

D The constructor overwrites the name property, causing validation to fail.

💡 Hint

Think about how NestJS creates instances of DTO classes and how constructors affect this.

NestJS uses plain objects and class-transformer to create DTO instances. Having a constructor can interfere with this process and cause runtime errors.

❓ state_output

advanced

What is the value of the isActive property after validation?

Given this DTO class and input object, what will be the value of isActive after validation?

import { IsBoolean, IsOptional } from 'class-validator';

export class StatusDto {
  @IsBoolean()
  @IsOptional()
  isActive?: boolean = true;
}

const input = {};

A true, because the default value is used when property is missing.

B false, because missing boolean defaults to false.

C Validation fails because isActive is missing.

D undefined, because the input does not provide isActive.

💡 Hint

Default values in DTO classes do not apply automatically during validation.

class-validator does not assign default values during validation. The property remains undefined if missing in input.

🧠 Conceptual

expert

Which statement best describes the role of DTO classes in NestJS?

Choose the most accurate description of what DTO classes do in NestJS applications.

A DTO classes are used to store data permanently in the database.

B DTO classes automatically generate API documentation without extra tools.

C DTO classes define the shape of data and enable validation and transformation before it reaches business logic.

D DTO classes replace entity classes and contain all business logic.

💡 Hint

Think about how data flows from outside requests into your app.

DTO classes specify how input data should look and help validate and transform it before use. They do not store data or contain business logic.

Practice

1. What is the main purpose of a DTO class in a NestJS application?

easy

A. To handle database connections and queries

B. To create UI components for the frontend

C. To define the shape and validation rules of data transferred between layers

D. To manage application routing and middleware

Solution

1. Step 1: Understand the role of DTOs

   DTO stands for Data Transfer Object, used to define how data should look when sent or received.

2. Step 2: Identify what DTOs do in NestJS

   In NestJS, DTOs specify the structure and validation of data between client and server or between app layers.

3. Final Answer:

   To define the shape and validation rules of data transferred between layers -> Option C

4. Quick Check:

   DTO = Data shape and validation [OK]

Hint: DTOs organize and validate data structure in NestJS [OK]

Common Mistakes:

• Confusing DTOs with database models
• Thinking DTOs handle routing or UI
• Assuming DTOs manage middleware

2. Which of the following is the correct way to declare a required string property name in a NestJS DTO class using class-validator decorators?

easy

A. @IsString() name: string;

B. name: string;

C. @IsOptional() name: string;

D. @IsNumber() name: string;

Solution

1. Step 1: Identify the decorator for string validation

   The @IsString() decorator from class-validator ensures the property is a string and required by default.

2. Step 2: Check other options

   name: string; lacks validation, C marks it optional, and D wrongly uses number validation.

3. Final Answer:

   @IsString() name: string; -> Option A

4. Quick Check:

   Use @IsString() for required string fields [OK]

Hint: Use @IsString() to require string fields in DTOs [OK]

Common Mistakes:

• Omitting validation decorators
• Using @IsOptional() for required fields
• Applying wrong type decorators like @IsNumber()

3. Given this DTO class, what will be the result of validating an object { name: "Alice", age: 25 }?

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

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

  @IsInt()
  @IsOptional()
  age?: number;
}

medium

A. Validation passes because name is string and age is optional integer

B. Validation fails because age is required but missing

C. Validation fails because name is not optional

D. Validation passes only if age is a string

Solution

1. Step 1: Analyze the DTO decorators

   Name is required string, age is optional integer due to @IsOptional() and @IsInt().

2. Step 2: Check the input object

   Input has name as string "Alice" and age as number 25, matching the DTO rules.

3. Final Answer:

   Validation passes because name is string and age is optional integer -> Option A

4. Quick Check:

   Required string + optional int with valid data = pass [OK]

Hint: Optional fields pass validation if present and valid [OK]

Common Mistakes:

• Assuming optional fields must be present
• Confusing @IsOptional() effect
• Thinking validation fails if optional field is present

4. Identify the error in this DTO class that causes validation to always fail for the email property:

import { IsEmail } from 'class-validator';

export class EmailDto {
  @IsEmail
  email: string;
}

medium

A. Should import IsString instead of IsEmail

B. email property should be optional

C. email property type should be number

D. Missing parentheses after @IsEmail decorator

Solution

1. Step 1: Check decorator usage

   @IsEmail is a function decorator and must be called with parentheses: @IsEmail()

2. Step 2: Understand effect of missing parentheses

   Without parentheses, the decorator is not applied properly, causing validation to fail.

3. Final Answer:

   Missing parentheses after @IsEmail decorator -> Option D

4. Quick Check:

   Decorators need () even if no args [OK]

Hint: Always add () after decorators like @IsEmail() [OK]

Common Mistakes:

• Forgetting parentheses on decorators
• Changing property type incorrectly
• Using wrong decorators for email

5. You want to create a DTO class CreateProductDto with these rules:
- title is a required string
- price is a required positive number
- description is an optional string
Which of the following DTO class definitions correctly implements these rules?

hard

A. import { IsString, IsNumber, IsPositive, IsOptional } from 'class-validator';

export class CreateProductDto {
@IsString()
title?: string;

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

@IsOptional()
@IsString()
description?: string;
}

B. import { IsString, IsNumber, IsPositive, IsOptional } from 'class-validator';

export class CreateProductDto {
@IsString()
title: string;

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

@IsOptional()
@IsString()
description?: string;
}

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

export class CreateProductDto {
@IsString()
title: string;

@IsNumber()
price: number;

@IsString()
description: string;
}

D. import { IsString, IsNumber, IsPositive, IsOptional } from 'class-validator';

export class CreateProductDto {
@IsString()
title: string;

@IsNumber()
price: number;

@IsOptional()
description?: string;
}

Solution

1. Step 1: Check required string property

   Title is required string, so @IsString() with no @IsOptional() is correct.

2. Step 2: Check required positive number property

   Price must be number and positive, so @IsNumber() and @IsPositive() are needed without @IsOptional().

3. Step 3: Check optional string property

   Description is optional string, so @IsOptional() and @IsString() with optional property syntax (?) is correct.

4. Final Answer:

   DTO with @IsString() title, @IsNumber() + @IsPositive() price, and optional @IsOptional() description -> Option B

5. Quick Check:

   Required fields no @IsOptional(), optional fields with @IsOptional() [OK]

Hint: Use @IsOptional() only on optional fields [OK]

Common Mistakes:

• Marking required fields as optional
• Missing @IsPositive() for positive number
• Omitting @IsOptional() on optional fields