class-validator#ValidatorConstraint TypeScript Examples

@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;
    }
}

@ValidatorConstraint({ async: true })
export class UniqueTitleConstrainsts implements ValidatorConstraintInterface {
  constructor() {}

  async validate(title: string, args: ValidationArguments): Promise<boolean> {
    const postRepo: Repository<PostEntity> = await (
      await import('../posts.entity')
    ).default;

    return !!!(await postRepo.findOne({ where: { title } }));
  }
}

/**
 * Validator for Strings containing scope strings
 */
@ValidatorConstraint({ name: 'ApplicationScopes', async: false })
export class ApplicationScopes implements ValidatorConstraintInterface {
  validate(scopes: string) {
    try {
      const validScopes = ['name', 'registrationNumber', 'github', 'twitter', 'linkedIn', 'previousEvents'];
      const decodedString = decodeURI(scopes);
      decodedString.split(' ').forEach((str) => {
        if (!validScopes.includes(str)) {
          throw new Error('invalid scope');
        }
      });
      return true;
    } catch (e) {
      return false;
    }
  }

  defaultMessage() {
    return 'Invalid application scopes';
  }
}

/**
 * Validator for Registration Number as a decorator
 */
@ValidatorConstraint({ name: 'RegistrationNumber', async: false })
export class RegistrationNumber implements ValidatorConstraintInterface {
  validate(reg: string) {
    try {
      const instance = new RegistrationValidator(reg);
      return instance !== undefined;
    } catch (e) {
      return false;
    }
  }

  defaultMessage() {
    return 'Invalid Registration Nuber';
  }
}

@ValidatorConstraint({ name: "validateColor", async: false })
class ValidateColor implements ValidatorConstraintInterface {
  validate(text: string, args: ValidationArguments) {
    return !isColorTooDark(text);
  }

  defaultMessage(args: ValidationArguments) {
    return "Color value ($value) is too dark";
  }
}

@ValidatorConstraint({ name: 'entityExists', async: true })
@Injectable()
export class EntityExists {
  constructor(private connection: Connection) {}

  async validate(id: number, args: ValidationArguments) {
    const found = await this.connection
      .getRepository(args.constraints[0])
      .findOne(id);
    if (!found) return false;
    return true;
  }

  defaultMessage(args: ValidationArguments) {
    return `Foreign-key constraint error on ${args.constraints[0].name}.`;
  }
}

@ValidatorConstraint({ async: true })
export class IsEntityConstraint implements ValidatorConstraintInterface {
  constructor(private readonly connection: Connection) {}

  getEntity(entity, property, value) {
    try {
      return this.connection.manager
        .createQueryBuilder(entity, 'target')
        .where(`LOWER(${property}) = LOWER(:value)`, { value })
        .getOne()
    } catch (error) {
      console.log(error) // eslint-disable-line no-console

      return null
    }
  }

  async validate(value: any, args: any) {
    const [options, check] = args.constraints

    const entity = options instanceof Function ? options : options.entity

    const result = await this.getEntity(entity, options.field || args.property, value)

    return check === !!result
  }
}

@ValidatorConstraint({ name: 'dataRetentionDays', async: false })
export class DataRetentionDays implements ValidatorConstraintInterface {
    validate(v: number) {
        return typeof v === 'number' && v >= -1  // for async validations you must return a Promise<boolean> here
    }

    defaultMessage(args: ValidationArguments) {
        // here you can provide default error message if validation failed
        return 'Data Retention must be an integer greater than or equal to -1';
    }
}

@ValidatorConstraint({ async: true })
export class IsEmailAlreadyExistConstraint implements ValidatorConstraintInterface {
  async validate(email: any) {
    const query = getRepository<User>(User).createQueryBuilder().where('email = :email', { email });
    const result = await query.getOne(); // return true if user exists
    if (result) return false;
    return true;
  }
}

@ValidatorConstraint({ async: true })
export class IsUsernameAlreadyExistConstraint implements ValidatorConstraintInterface {
  async validate(username: any) {
    const query = getRepository<User>(User).createQueryBuilder().where('username = :username', { username });
    const result = await query.getOne(); // return true if user exists
    if (result) return false;
    return true;
  }
}

@ValidatorConstraint({name: 'signatureId', async: false})
export class SignatureIdValidator implements ValidatorConstraintInterface {
    public defaultMessage(validationArguments?: ValidationArguments) {
        return 'Either signatureId, or privateKey/fromPrivateKey must be present.';
    }

    public validate(value: any, validationArguments?: ValidationArguments) {
        const data = validationArguments?.object as any;
        if (data.fromPrivateKey && data.signatureId) {
            return false;
        }
        if (data.privateKey && data.signatureId) {
            return false;
        }
        return true;
    }

}

@ValidatorConstraint({ async: false })
export class IsFieldEqualConstraint implements ValidatorConstraintInterface {
  async validate(value: string, args: ValidationArguments) {
    const [target] = args.constraints

    return value === args.object[target]
  }
}