class-validator

Validation groups allow you to apply different validation rules to the same class depending on the context (e.g., 'registration' vs 'admin').

• Assign groups to decorators using the groups option: @Min(12, { groups: ['registration'] }).
• Specify active groups in the validate method: validate(user, { groups: ['registration'] }).
• Use the always: true option in a decorator to ensure that validation is applied regardless of which group is active.

Warning: If you provide a group combination that matches no decorators, it will result in an unknown value error.

import { validate, Min, Length } from 'class-validator';

export class User {
  @Min(12, { groups: ['registration'] })
  age: number;

  @Length(2, 20, { groups: ['registration', 'admin'] })
  name: string;
}

let user = new User();
user.age = 10;
user.name = 'Alex';

// Only validates 'age' (and it will fail because age is 10)
validate(user, { groups: ['registration'] });

// Only validates 'name' (and it will pass)
validate(user, { groups: ['admin'] });

To use class-validator, define a class and apply validation decorators (like @IsInt, @IsEmail, @Min, etc.) to its properties. You can then validate an instance of the class using the validate function or validateOrReject function.

• validate(object): Returns a Promise that resolves to an array of ValidationError objects. If validation succeeds, the array is empty.
• validateOrReject(object): Returns a Promise that resolves if validation succeeds, or rejects with an array of ValidationError objects if validation fails.

import {
  validate,
  validateOrReject,
  Contains,
  IsInt,
  Length,
  IsEmail,
  IsFQDN,
  IsDate,
  Min,
  Max,
} from 'class-validator';

export class Post {
  @Length(10, 20)
  title: string;

  @Contains('hello')
  text: string;

  @IsInt()
  @Min(0)
  @Max(10)
  rating: number;

  @IsEmail()
  email: string;

  @IsFQDN()
  site: string;

  @IsDate()
  createDate: Date;
}

let post = new Post();
post.title = 'Hello'; // should not pass

// Using validate()
validate(post).then(errors => {
  if (errors.length > 0) {
    console.log('validation failed. errors: ', errors);
  } else {
    console.log('validation succeed');
  }
});

// Using validateOrReject()
async function validateOrRejectExample(input) {
  try {
    await validateOrReject(input);
  } catch (errors) {
    console.log('Caught promise rejection (validation failed). Errors: ', errors);
  }
}

To implement custom validation logic, create a class that implements the ValidatorConstraintInterface and decorate it with @ValidatorConstraint.

1. Define the Constraint: Implement validate(value, args) (can be async) and optionally defaultMessage(args).
2. Use the Constraint: Apply it to a property using the @Validate(ConstraintClass, [args], options) decorator.
3. Access Arguments: Inside the validate method, you can access passed constraints via validationArguments.constraints.

If you provide a name to @ValidatorConstraint({ name: '...' }), that name will be used as the error type in the ValidationError object.

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

@ValidatorConstraint({ name: 'customText', async: false })
export class CustomTextLength implements ValidatorConstraintInterface {
  validate(text: string, args: ValidationArguments) {
    // Access constraints passed via @Validate(CustomTextLength, [min, max])
    const min = args.constraints[0] || 0;
    const max = args.constraints[1] || 100;
    return text.length > min && text.length < max;
  }

  defaultMessage(args: ValidationArguments) {
    return 'Text is too short or too long!';
  }
}

export class Post {
  @Validate(CustomTextLength, [3, 20], { message: 'Wrong post title' })
  title: string;
}

You can provide custom error messages directly in the decorator options. You can also provide a function that receives ValidationArguments for more complex logic.

Special Tokens in Messages:

• $value: The value being validated.
• $property: The name of the property being validated.
• $target: The name of the class being validated.
• $constraint1, $constraint2, ... $constraintN: The specific constraints defined by the validator (e.g., the minimum length value).

ValidationArguments properties:

• value: The value being validated.
• constraints: Array of constraints defined by the specific validation type.
• targetName: Name of the object's class.
• object: The object being validated.
• property: The name of the property being validated.

import { MinLength, MaxLength, ValidationArguments } from 'class-validator';

export class Post {
  @MinLength(10, {
    // Using tokens
    message: 'Title is too short. Minimal length is $constraint1 characters, but actual is $value',
  })
  @MaxLength(50, {
    // Using a function for granular messages
    message: (args: ValidationArguments) => {
      if (args.value.length === 1) {
        return 'Too short, minimum length is 1 character';
      } else {
        return 'Too short, minimum length is ' + args.constraints[0] + ' characters';
      }
    },
  })
  title: string;
}