class-validator#ValidationOptions TypeScript Examples

export function MinFileSize(minSizeBytes: number, validationOptions?: ValidationOptions) {

  return ValidateBy({
    name: 'MinFileSize',
    constraints: [minSizeBytes],
    validator: {
      validate(value: StoredFile, args: ValidationArguments) {
        const size: number = args.constraints[0];

        if (isFile(value)) {
          return value.size >= size;
        }

        return false;
      },

      defaultMessage(validationArguments?: ValidationArguments): string {
        return `Maximum file size is ${validationArguments.constraints[0]}`;
      },
    },
  }, validationOptions);

}

export function IsHex(
  options: {
    size?: number;
  } = {},
  validationOptions: ValidationOptions = {},
) {
  return (object: any, propertyName: string) => {
    const { size } = options;
    let message = `${propertyName} must be hex`;

    if (size > 0) {
      message = `${message} with ${size} size`;
    }

    registerDecorator({
      propertyName,
      options: {
        message,
        ...validationOptions,
      },
      name: 'isHex',
      target: object.constructor,
      constraints: [],
      validator: {
        validate(value: string): boolean {
          let result = utils.isHexString(value);

          if (result && size > 0) {
            result = value.length === size * 2 + 2;
          }

          return result;
        },
      },
    });
  };
}

IsInRange = (min: number, max: number, validationOptions?: ValidationOptions) => function (object: Object, propertyName: string) {
  registerDecorator({
    name: 'isInRange',
    target: object.constructor,
    propertyName: propertyName,
    constraints: [min, max],
    options: {
      message: `${propertyName} must be between ${min} and ${max}`,
      ...validationOptions
    },
    validator: {
      validate(value: any) {
        return new BigNumber(value).lte(max) && new BigNumber(value).gte(min)
      },
    },
  });
}

export function IsUsernameAlreadyExist(validationOptions?: ValidationOptions) {
  return function (object: Record<string, any>, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsUsernameAlreadyExistConstraint,
    });
  };
}

export function IsEmailAlreadyExist(validationOptions?: ValidationOptions) {
  return function (object: Record<string, any>, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsEmailAlreadyExistConstraint,
    });
  };
}

export function IsPassword(
  validationOptions?: ValidationOptions,
): PropertyDecorator {
  return (object: any, propertyName: string) => {
    registerDecorator({
      propertyName,
      name: 'isPassword',
      target: object.constructor,
      constraints: [],
      options: validationOptions,
      validator: {
        validate(value: string, _args: ValidationArguments) {
          return /^[a-zA-Z0-9!@#$%^&*]*$/.test(value);
        },
      },
    });
  };
}

export function IsEqualTo(property: string, validationOptions?: ValidationOptions) {
  return (object: any, propertyName: string): any => {
    registerDecorator({
      name: 'isEqualTo',
      target: object.constructor,
      propertyName,
      constraints: [property],
      options: validationOptions,
      validator: {
        validate(value: any, args: ValidationArguments): boolean {
          const [relatedPropertyName] = args.constraints
          const relatedValue = (args.object as any)[relatedPropertyName]
          return value === relatedValue
        },

        defaultMessage(args: ValidationArguments): string {
          const [relatedPropertyName] = args.constraints
          return `$property must match ${relatedPropertyName} exactly`
        },
      },
    })
  }
}

export function IsPluginConfig(validationOptions?: ValidationOptions) {
    return (object: any, propertyName: string) => {
        registerDecorator({
            name: 'isPluginConfig',
            target: object.constructor,
            propertyName: propertyName,
            options: validationOptions,
            validator: {
                validate(value: any, _args: ValidationArguments) {
                    if (isObjectLike(value)) {
                        return Object.entries(value).every(([_, v]) => {
                            if (isArray(v)) {
                                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                                // @ts-ignore
                                return Array.from(v).every(isString);
                            }

                            return isString(v) || isBoolean(v);
                        });
                    }

                    return false;
                },
                defaultMessage(args?: ValidationArguments) {
                    const expectedMsg = 'Expected "{ [key: string]: string | string[] | boolean }"';

                    if (!args) {
                        return expectedMsg;
                    }

                    const strValue = JSON.stringify(args.value);
                    return `${expectedMsg} on "${args.property}" but found "${strValue}" instead`;
                },
            },
        });
    };
}

// any specific validators should be specified here
export function MetatypeRelationshipPairID(validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            name: 'MetatypeRelationshipPairID',
            target: object.constructor,
            propertyName,
            constraints: [],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    return value instanceof MetatypeRelationshipPair && typeof value.id! === 'string';
                },
            },
        });
    };
}

// any specific validators should be specified here
export function MetatypeRelationshipID(validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            name: 'MetatypeRelationshipID',
            target: object.constructor,
            propertyName,
            constraints: [],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    return value instanceof MetatypeRelationship && typeof value.id! === 'string';
                },
            },
        });
    };
}

export function MetatypeID(validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            name: 'MetatypeID',
            target: object.constructor,
            propertyName,
            constraints: [],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    return value instanceof Metatype && typeof value.id! === 'string';
                },
            },
        });
    };
}

// we have to copy the container validator as to avoid cyclical imports
export function ContainerID(validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            name: 'ContainerID',
            target: object.constructor,
            propertyName,
            constraints: [],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    return value instanceof Container && typeof value.id === 'string';
                },
            },
        });
    };
}

/*
 These final operations are class-validator specific property validations
*/
export function UserID(validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            name: 'UserID',
            target: object.constructor,
            propertyName,
            constraints: [],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    return value instanceof User && typeof value.id === 'string';
                },
            },
        });
    };
}

export function IsUrl(validationOptions: ValidationOptions = {}) {
  return (object: any, propertyName: string) => {
    registerDecorator({
      propertyName,
      options: {
        message: `${propertyName} must be url`,
        ...validationOptions,
      },
      name: 'isUrl',
      target: object.constructor,
      constraints: [],
      validator: {
        validate(value: string): boolean {
          return isUrl(value);
        },
      },
    });
  };
}

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

export function IsBigNumberish(
  options: {
    positive?: boolean;
  } = {},
  validationOptions: ValidationOptions = {},
) {
  return (object: any, propertyName: string) => {
    const { positive } = options;

    registerDecorator({
      propertyName,
      options: {
        message: `${propertyName} must be ${positive ? 'positive ' : ''}big numberish`,
        ...validationOptions,
      },
      name: 'IsBigNumberish',
      target: object.constructor,
      constraints: [],
      validator: {
        validate(value: any): boolean {
          let result = false;

          try {
            const bn = BigNumber.from(value);
            result = positive ? bn.gt(0) : bn.gte(0);
          } catch (err) {
            //
          }

          return result;
        },
      },
    });
  };
}

export function IsAddress(options: ValidationOptions = {}) {
  return (object: any, propertyName: string) => {
    registerDecorator({
      propertyName,
      options: {
        message: `${propertyName} must be an address`,
        ...options,
      },
      name: 'isAddress',
      target: object.constructor,
      constraints: [],
      validator: {
        validate(value: any): boolean {
          return isAddress(value);
        },
      },
    });
  };
}

export function MaxFileSize(maxSizeBytes: number, validationOptions?: ValidationOptions): PropertyDecorator {

  return ValidateBy({
    name: 'MaxFileSize',
    constraints: [maxSizeBytes],
    validator: {
      validate(value: StoredFile, args: ValidationArguments) {
        const size: number = args.constraints[0];

        if (isFile(value)) {
          return value.size <= size;
        }

        return false;
      },

      defaultMessage(validationArguments?: ValidationArguments): string {
        return `Maximum file size is ${validationArguments.constraints[0]}`;
      },
    },
  }, validationOptions);

}

export function IsFile(validationOptions?: ValidationOptions): PropertyDecorator {

  return ValidateBy({
    name: 'IsFile',
    constraints: [],
    validator: {

      validate(value: any, args: ValidationArguments) {
        return isFile(value);
      },

      defaultMessage(validationArguments?: ValidationArguments): string {
        return `Field "${validationArguments.property}" does not contain file`;
      },
    },
  }, validationOptions);


}

export function HasMimeType(allowedMimeTypes: string[], validationOptions?: ValidationOptions): PropertyDecorator {

  return ValidateBy({
    name: 'HasMimeType',
    constraints: [allowedMimeTypes],
    validator: {

      validate(value: StoredFile, args: ValidationArguments) {
        const allowedMimeTypes: string[] = args.constraints[0] || [];

        if (isFile(value)) {
          return allowedMimeTypes.includes(value.mimetype);
        }

        return false;
      },

      defaultMessage(validationArguments?: ValidationArguments): string {
        const allowedMimeTypes: string[] = validationArguments.constraints[0] || [];
        return `File must be of one of the types ${allowedMimeTypes.join(', ')}`;
      },
    },
  }, validationOptions);


}

validateBody = async <T>(
  obj: ClassType<T>,
  body: string | null,
  validateOptions?: ValidationOptions
): Promise<T> => {
  const raw: any = plainToClass(obj, JSON.parse(body ?? '{}'));
  await validateOrReject(raw, {
    ...validateOptions,
    whitelist: true,
    forbidUnknownValues: true
  });
  return raw;
}

IsFieldEqual = (target: string, validationOptions?: ValidationOptions) => {
  return (object: any, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      options: validationOptions,
      constraints: [target],
      propertyName,
      validator: IsFieldEqualConstraint,
    })
  }
}

IsEntityNotExists = (
  options: IsEntityOptions | Function,
  validationOptions?: ValidationOptions,
) => {
  return (object: any, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      options: validationOptions,
      constraints: [options, false],
      propertyName,
      validator: IsEntityConstraint,
    })
  }
}

IsEntityExists = (
  options: IsEntityOptions | Function,
  validationOptions?: ValidationOptions,
) => {
  return (object: any, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      options: validationOptions,
      constraints: [options, true],
      propertyName,
      validator: IsEntityConstraint,
    })
  }
}

export function IsUniqueTitle(validationOptions?: ValidationOptions) {
  return (object: object, propertyName: string) => {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [],
      validator: UniqueTitleConstrainsts,
      async: true,
    });
  };
}

export function IsHex32(options: ValidationOptions = {}) {
  return IsHex(
    {
      size: 32,
    },
    options,
  );
}

export function IsBytesLike(options: ValidationOptions & { acceptText?: boolean } = {}) {
  return (object: any, propertyName: string) => {
    registerDecorator({
      propertyName,
      options: {
        message: `${propertyName} must be bytes like`,
        ...options,
      },
      name: 'IsBytesLike',
      target: object.constructor,
      constraints: [],
      validator: {
        validate(value: any): boolean {
          let result = false;

          try {
            if (value) {
              switch (typeof value) {
                case 'string':
                  if (options.acceptText) {
                    result = true;
                  } else {
                    result = utils.isHexString(value) && value.length % 2 === 0;
                  }
                  break;

                case 'object':
                  result = Array.isArray(value) && value.every((value) => typeof value === 'number');
                  break;
              }
            }
          } catch (err) {
            //
          }

          return result;
        },
      },
    });
  };
}

export function IsFiles(validationOptions?: ValidationOptions): PropertyDecorator {
  return applyDecorators(
    IsArray(validationOptions),
    IsFile(Object.assign(validationOptions || {}, { each: true })),
  );
}