class-validator#ValidationArguments 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);

}

@IsFile()
  @HasMimeType(['text/plain'])
  @MaxFileSize(5, {
    message: (opt: ValidationArguments) => {
      return `${opt.value.path}`;
    },
  })
  @MinFileSize(3)
  file: FileSystemStoredFile;

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

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 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);


}

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

async validate(value: string, args: ValidationArguments) {
    const [target] = args.constraints

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

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

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

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 "Color value ($value) is too dark";
  }

validate(text: string, args: ValidationArguments) {
    return !isColorTooDark(text);
  }

public defaultMessage(validationArguments?: ValidationArguments) {
        return 'Either signatureId, or privateKey/fromPrivateKey must be present.';
    }

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

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