Custom validation decorators in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when validating a DTO with this custom decorator?

Given this NestJS custom validation decorator and DTO, what will be the validation result if the input value is 'abc123'?

NestJS

import { registerDecorator, ValidationOptions, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments } from 'class-validator';

@ValidatorConstraint({ async: false })
export class IsAlphaOnlyConstraint implements ValidatorConstraintInterface {
  validate(text: string, args: ValidationArguments) {
    return /^[A-Za-z]+$/.test(text);
  }
  defaultMessage(args: ValidationArguments) {
    return 'Text ($value) must contain only letters';
  }
}

export function IsAlphaOnly(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsAlphaOnlyConstraint,
    });
  };
}

class SampleDto {
  @IsAlphaOnly({ message: 'Only letters allowed!' })
  name: string;
}

// Input: { name: 'abc123' }

A Validation throws a runtime error

B Validation passes successfully

C Validation fails with message: 'Text (abc123) must contain only letters'

D Validation fails with message: 'Only letters allowed!'

💡 Hint

Think about what the regex /^[A-Za-z]+$/ checks for and what input 'abc123' contains.

The regex /^[A-Za-z]+$/ only allows letters from A to Z (uppercase or lowercase). The input 'abc123' contains digits, so the validation fails. The custom message provided in the decorator options is used, so the error message is 'Only letters allowed!'.

📝 Syntax

intermediate

Which option correctly registers a custom validator in NestJS?

You want to create a custom validation decorator using class-validator in NestJS. Which of the following code snippets correctly registers the validator?

A registerDecorator({ target: object.constructor, propertyName, validator: MyValidator, options: validationOptions });

B registerDecorator({ target: object.constructor, propertyName, validator: new MyValidator(), options: validationOptions });

C registerDecorator({ target: object.constructor, propertyName, validator: MyValidator });

D registerDecorator({ target: object, propertyName, validator: MyValidator, options: validationOptions });

💡 Hint

Remember the target should be the constructor of the object, not the object instance itself.

The registerDecorator function requires the target to be the constructor of the class, which is object.constructor. The propertyName and validator class are also required. The options are optional but recommended for custom messages.

🔧 Debug

advanced

Why does this custom validator always pass validation?

Consider this custom validator code in NestJS. Why does it always pass validation regardless of input?

NestJS

import { ValidatorConstraint, ValidatorConstraintInterface } from 'class-validator';

@ValidatorConstraint({ async: false })
export class AlwaysTrueValidator implements ValidatorConstraintInterface {
  validate(value: any) {
    return true;
  }
  defaultMessage() {
    return 'This should never fail';
  }
}

// Used in a decorator but validation never fails

A The validator class is not decorated with @Injectable().

B The validate method always returns true, so validation never fails.

C The defaultMessage method is not called.

D The decorator is missing the registerDecorator call.

💡 Hint

Look at the return value of the validate method.

The validate method always returns true, which means the validation always passes no matter the input.

❓ state_output

advanced

What is the validation error message for this input?

Given this custom validator and DTO, what error message will be shown if the input is { age: 17 }?

NestJS

import { registerDecorator, ValidationOptions, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments } from 'class-validator';

@ValidatorConstraint({ async: false })
export class IsAdultConstraint implements ValidatorConstraintInterface {
  validate(age: number, args: ValidationArguments) {
    return age >= 18;
  }
  defaultMessage(args: ValidationArguments) {
    return `Age must be at least 18, but got ${args.value}`;
  }
}

export function IsAdult(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsAdultConstraint,
    });
  };
}

class UserDto {
  @IsAdult({ message: 'User must be adult!' })
  age: number;
}

// Input: { age: 17 }

A Validation fails with message: 'User must be adult!'

B Validation passes successfully

C Validation fails with message: 'Age must be at least 18, but got 17'

D Validation throws a runtime error

💡 Hint

Check which message is prioritized when both defaultMessage and options.message exist.

The custom message passed in the decorator options ('User must be adult!') overrides the defaultMessage method. So the validation error shows the custom message.

🧠 Conceptual

expert

Which statement about custom validation decorators in NestJS is TRUE?

Select the correct statement about creating and using custom validation decorators with class-validator in NestJS.

A The defaultMessage method is required and must return a string synchronously.

B Custom validators must always be asynchronous and return a Promise<boolean>.

C The validate method can be synchronous or asynchronous, but the decorator must specify async: true if asynchronous.

D Custom decorators cannot use constructor injection for dependencies.

💡 Hint

Think about how async validation is handled in class-validator.

The validate method can be synchronous or asynchronous. If asynchronous, the @ValidatorConstraint decorator must have async: true. The defaultMessage method is optional. Custom validators can use constructor injection if properly configured.