feat: add decorator to check if two properties match #486

mrpharderwijk · 2019-12-09T07:15:22Z

First of all, thanks for the awesome validation solution! I use class-validator in my NestJS setup. Now I want to know if and how it is possible to check if two values match with eachother. Let's say I have a dto setup like this:

export class UserCreateDto {
  @IsString()
  @IsNotEmpty()
   firstName: string;

   @IsEmail()
   emailAddress: string;

   @DoesMatch(o => o.emailAddress === o.emailAddressConfirm) // <---- check if email's match
   @IsEmail()
   emailAddressConfirm: string;
}

The text was updated successfully, but these errors were encountered:

rubiin · 2019-12-15T18:10:14Z

@vlapo

rubiin · 2019-12-20T07:32:34Z

@vlapo how can we achieve something like this??

vlapo · 2020-01-10T12:54:51Z

We do not have validator for this. Feel free open PR.

joelcoronah · 2020-02-28T15:06:05Z

Hi guys, any update @vlapo?

sevosevo · 2020-03-22T15:27:02Z

Is there a way to make custom validator get access to other properties

PieroMacaluso · 2020-03-31T17:29:46Z

Hi! I am posting there the solution I found to implement this control. It refers to my question/answer on StackOverflow. I am going to provide a suitable solution for this particular issue.

user-create.dto.ts

export class UserCreateDto {
   @IsString()
   @IsNotEmpty()
   firstName: string;

   @IsEmail()
   emailAddress: string;

   @Match('emailAddress')
   @IsEmail()
   emailAddressConfirm: string;
}

match.decorator.ts

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

export function Match(property: string, validationOptions?: ValidationOptions) {
    return (object: any, propertyName: string) => {
        registerDecorator({
            target: object.constructor,
            propertyName,
            options: validationOptions,
            constraints: [property],
            validator: MatchConstraint,
        });
    };
}

@ValidatorConstraint({name: 'Match'})
export class MatchConstraint implements ValidatorConstraintInterface {

    validate(value: any, args: ValidationArguments) {
        const [relatedPropertyName] = args.constraints;
        const relatedValue = (args.object as any)[relatedPropertyName];
        return value === relatedValue;
    }

}

I managed to solve a similar problem on my personal project. Hope it helps!

mrpharderwijk · 2020-04-22T18:21:10Z

Added a custom message to your solution like this:

@ValidatorConstraint({name: 'Match'})
export class MatchConstraint implements ValidatorConstraintInterface {

    validate(value: any, args: ValidationArguments) {
        const [relatedPropertyName] = args.constraints;
        const relatedValue = (args.object as any)[relatedPropertyName];
        return value === relatedValue;
    }

   defaultMessage(args: ValidationArguments) {
     const [relatedPropertyName] = args.constraints;
     return `${relatedPropertyName} and ${args.property} don't match`;
  }
}

gimerstedt · 2020-11-24T12:38:46Z

force the property to exist on the class:

export function Match<K extends string, T extends { [$K in K]: any }>(
  property: K,
  validationOptions?: ValidationOptions,
) {
  return (object: T, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [property],
      validator: MatchConstraint,
    });
  };
}

LeonardoRosaa · 2020-12-15T01:45:50Z

@mrpharderwijk and @PieroMacaluso, it's works for me. Thanks!!

Full code:

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

export function Match(property: string, validationOptions?: ValidationOptions) {
    return (object: any, propertyName: string) => {
        registerDecorator({
            target: object.constructor,
            propertyName,
            options: validationOptions,
            constraints: [property],
            validator: MatchConstraint,
        });
    };
}

@ValidatorConstraint({name: 'Match'})
export class MatchConstraint implements ValidatorConstraintInterface {

    validate(value: any, args: ValidationArguments) {
        const [relatedPropertyName] = args.constraints;
        const relatedValue = (args.object as any)[relatedPropertyName];
        return value === relatedValue;
    }

    defaultMessage(args: ValidationArguments) {
      const [relatedPropertyName] = args.constraints;
      return `${relatedPropertyName} and ${args.property} don't match`;
    }
}

hnbnh · 2021-07-28T17:21:51Z

Thanks everyone for a good solution, but there's a problem with type linting.

We could make a spelling mistake like:

@Match('passwordd')
//              👆

So I would like to make it more strict

import { ClassConstructor } from "class-transformer";

export const Match = <T>(
  type: ClassConstructor<T>,
  property: (o: T) => any,
  validationOptions?: ValidationOptions,
) => {
  return (object: any, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [property],
      validator: MatchConstraint,
    });
  };
};

@ValidatorConstraint({ name: "Match" })
export class MatchConstraint implements ValidatorConstraintInterface {
  validate(value: any, args: ValidationArguments) {
    const [fn] = args.constraints;
    return fn(args.object) === value;
  }

  defaultMessage(args: ValidationArguments) {
    const [constraintProperty]: (() => any)[] = args.constraints;
    return `${constraintProperty} and ${args.property} does not match`;
  }
}

Usage:

@Match(SignUpDto, (s) => s.password)
passwordConfirm: string;

allanvobraun · 2021-12-09T11:24:50Z

Thanks everyone for a good solution, but there's a problem with type linting.

We could make a spelling mistake like:

@Match('passwordd')
//              👆

So I would like to make it more strict

export const Match = <T>(
  type: ClassConstructor<T>,
  property: (o: T) => any,
  validationOptions?: ValidationOptions,
) => {
  return (object: any, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [property],
      validator: MatchConstraint,
    });
  };
};

@ValidatorConstraint({ name: "Match" })
export class MatchConstraint implements ValidatorConstraintInterface {
  validate(value: any, args: ValidationArguments) {
    const [fn] = args.constraints;
    return fn(args.object) === value;
  }

  defaultMessage(args: ValidationArguments) {
    const [constraintProperty]: (() => any)[] = args.constraints;
    return `${constraintProperty} and ${args.property} does not match`;
  }
}

Usage:

@Match(SignUpDto, (s) => s.password)
passwordConfirm: string;

Really good!
This example should be in the docs!

bato3 · 2022-01-16T13:43:09Z

@hnbnh Cam you show ClassConstructor definition?

hnbnh · 2022-01-17T01:19:26Z

@bato3 I forgot to mention it, you have to import it from "class-transformer" like so:

import { ClassConstructor } from "class-transformer";

kuriel-trivu · 2022-06-28T22:22:18Z

Just a bit improvements, if you like it:

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

export const MatchesWithProperty = <T>(
  type: ClassConstructor<T>,
  property: (o: T) => any,
  validationOptions?: ValidationOptions,
) => {
  return (object: any, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [property],
      validator: MatchConstraint,
    });
  };
};

@ValidatorConstraint({name: 'Match'})
export class MatchConstraint implements ValidatorConstraintInterface {
  validate(value: any, args: ValidationArguments) {
    const [fn] = args.constraints;
    return fn(args.object) === value;
  }
  
  defaultMessage(args: ValidationArguments) {
    const [constraintProperty]: Array<() => any> = args.constraints;
    return `${(constraintProperty + '').split('.')[1]} and ${args.property} does not match`;
  }
}

ghost · 2022-11-07T12:56:24Z

This should be in-house I guess. The solution of @PieroMacaluso is very nice.

peixotoleonardo · 2023-01-15T13:35:34Z

We can receive the name of the property like string, to avoid typo we can use keyof:

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

export const Match =
  <T>(property: keyof T, options?: ValidationOptions) =>
  (object: unknown, propertyName: string) =>
    registerDecorator({
      target: object.constructor,
      propertyName,
      options,
      constraints: [property],
      validator: MatchConstraint,
    });
    
@ValidatorConstraint({ name: 'Match' })
export class MatchConstraint implements ValidatorConstraintInterface {
  validate(value: any, validationArguments?: ValidationArguments): boolean {
    return equals(validationArguments.constraints[0], value);
  }

  defaultMessage(validationArguments?: ValidationArguments): string {
    return `${validationArguments.constraints[0]} and ${validationArguments.property} does not match`;
  }
}


  defaultMessage(validationArguments?: ValidationArguments): string {
    const [propertyNameToCompare] = validationArguments.constraints;

    return `${validationArguments.property} and ${propertyNameToCompare} does not match`;
  }
}

huzaifarif · 2023-11-11T11:49:49Z

Some slight corrections to @peixotoleonardo's really nice approach above, the complete code looks like this:

Validator:

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

export const Match =
  <T>(property: keyof T, options?: ValidationOptions) =>
  (object: any, propertyName: string) =>
    registerDecorator({
      target: object.constructor,
      propertyName,
      options,
      constraints: [property],
      validator: MatchConstraint,
    });

@ValidatorConstraint({ name: 'Match' })
export class MatchConstraint implements ValidatorConstraintInterface {
  validate(value: any, args?: ValidationArguments): boolean {
    const [propertyNameToCompare] = args?.constraints || [];
    const propertyValue = (args?.object as any)[propertyNameToCompare];
    return equals(value, propertyValue);
  }

  defaultMessage(args?: ValidationArguments): string {
    const [propertyNameToCompare] = args?.constraints || [];

    return `${args?.property} does not match the ${propertyNameToCompare}`;
  }
}

Usage:

@Match<SignupDto>('password')
confirmPassword: string;

Thanks @hnbnh and other for the solutions, this works like a charm!

vlapo mentioned this issue Jan 10, 2020

check if two fields values are equal #493

Closed

vlapo added the type: feature Issues related to new features. label Jan 10, 2020

NoNameProvided changed the title ~~How do I check if two values match?~~ feat: add decorator to check if two properties match Aug 8, 2020

NickKelly1 mentioned this issue Aug 16, 2020

question: How to compare properties with decorators? #690

Closed

jbjhjm mentioned this issue Mar 28, 2022

[Info/Question] Incorrect validity state when using validator that depends on another property EndyKaufman/ngx-dynamic-form-builder#202

Closed

vincentvis mentioned this issue Jan 5, 2023

Ry/current games crud Liryvian/ft_transcendence#48

Merged

MamadTvl added a commit to MamadTvl/class-validator that referenced this issue Apr 14, 2024

feat: add decorator to check if two properties match typestack#486

88695a0

MamadTvl added a commit to MamadTvl/class-validator that referenced this issue Apr 14, 2024

feat: add decorator to check if two properties match typestack#486

01099f8

MamadTvl added a commit to MamadTvl/class-validator that referenced this issue Apr 14, 2024

feat: add decorator to check if two properties match typestack#486

5f2312a

MamadTvl linked a pull request Apr 14, 2024 that will close this issue

Add decorator to check if two properties match or property follows a custom condition. #2462

Open

6 tasks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat: add decorator to check if two properties match #486

feat: add decorator to check if two properties match #486

mrpharderwijk commented Dec 9, 2019

rubiin commented Dec 15, 2019

rubiin commented Dec 20, 2019

vlapo commented Jan 10, 2020

joelcoronah commented Feb 28, 2020

sevosevo commented Mar 22, 2020

PieroMacaluso commented Mar 31, 2020

mrpharderwijk commented Apr 22, 2020

gimerstedt commented Nov 24, 2020

LeonardoRosaa commented Dec 15, 2020

hnbnh commented Jul 28, 2021 •

edited

allanvobraun commented Dec 9, 2021

bato3 commented Jan 16, 2022

hnbnh commented Jan 17, 2022

kuriel-trivu commented Jun 28, 2022

ghost commented Nov 7, 2022

peixotoleonardo commented Jan 15, 2023

huzaifarif commented Nov 11, 2023 •

edited

feat: add decorator to check if two properties match #486

feat: add decorator to check if two properties match #486

Comments

mrpharderwijk commented Dec 9, 2019

rubiin commented Dec 15, 2019

rubiin commented Dec 20, 2019

vlapo commented Jan 10, 2020

joelcoronah commented Feb 28, 2020

sevosevo commented Mar 22, 2020

PieroMacaluso commented Mar 31, 2020

user-create.dto.ts

match.decorator.ts

mrpharderwijk commented Apr 22, 2020

gimerstedt commented Nov 24, 2020

LeonardoRosaa commented Dec 15, 2020

hnbnh commented Jul 28, 2021 • edited

allanvobraun commented Dec 9, 2021

bato3 commented Jan 16, 2022

hnbnh commented Jan 17, 2022

kuriel-trivu commented Jun 28, 2022

ghost commented Nov 7, 2022

peixotoleonardo commented Jan 15, 2023

huzaifarif commented Nov 11, 2023 • edited

hnbnh commented Jul 28, 2021 •

edited

huzaifarif commented Nov 11, 2023 •

edited