[Question] How to "remove" inherit decorator ?

There is an elegant way to “remove” inherit decorator like @IsOptional in child class ?

I’m using class-validator with Nest to validate my input data with some DTO class.

I need to have a parent class with all fields optional and a child class with some mandatory fields.

So i have a CreateAccountDto wich inherit from AccountDto

The idea behind is to have different inputs DTO like CreateAccountDto and avoid repetition.

Actually i have :

export class AccountDto {
  @IsUUID('4')
  @IsOptional()
  @ApiModelProperty()
  readonly account_id: string;

  @IsString()
  @IsNotEmpty()
  @MaxLength(200)
  @IsEmail()
  @IsOptional()
  @ApiModelProperty()
  readonly email: string;

  @IsString()
  @IsNotEmpty()
  @MaxLength(100)
  @IsOptional()
  @ApiModelProperty()
  readonly password: string;
}

and

export class CreateAccountDto extends AccountDto {
  @Equals(undefined)
  @RemoveApiModelProperty()
  readonly account_id: string;

  @RemoveIsOptional()
  readonly email: string;

  @RemoveIsOptional()
  readonly password: string;
}

const removeValidationPropertyDecorator = (metakey: string): PropertyDecorator => {
  return (target: object, propertyKey: string | symbol) => {
    const validationMetadatasKey = 'validationMetadatas';
    const validationMetadatas: ValidationMetadata[] = getFromContainer(MetadataStorage)[validationMetadatasKey];

    _.remove(validationMetadatas, (validationMetadata: ValidationMetadata) => {
      return validationMetadata.propertyName === propertyKey && validationMetadata.type === metakey;
    });
  };
};
export const RemoveIsOptional = (): PropertyDecorator => {
  return removeValidationPropertyDecorator(ValidationTypes.CONDITIONAL_VALIDATION);
};

My actual solution is to have a custom @RemoveIsOptional decorator, but i’m not sure is the best way to accomplish my goal !?

[miramo]

For NestJS users, have you seen this: https://trilon.io/blog/introducing-mapped-types-for-nestjs ?

I don’t know if this can satisfy all your needs, but this doesn’t exist when I created this issue 🤷 And I think that would have helped us a lot.

In the meantime we have implemented/used another solution on our side ;

import { getFromContainer, MetadataStorage } from 'class-validator';
import cloneDeep from 'lodash/cloneDeep';

/**
 * Allow copying validation metadatas set by `class-validator` from
 * a given Class property to an other. Copied `ValidationMetadata`s
 * will have their `target` and `propertyName` changed according to
 * the decorated class and property.
 *
 * @param fromClass    Class to inherit validation metadatas from.
 * @param fromProperty Name of the target property (default to decorated property).
 *
 * @return {PropertyDecorator} Responsible for copying and registering `ValidationMetada`s.
 *
 * @example
 * class SubDto {
 *   @InheritValidation(Dto)
 *   readonly id: number;
 *
 *   @InheritValidation(Dto, 'name')
 *   readonly firstName: string;
 *
 *   @InheritValidation(Dto, 'name')
 *   readonly lastName: string;
 * }
 */
export function InheritValidation<T>(fromClass: new (...args: any[]) => T, fromProperty?: keyof T): PropertyDecorator {
  const metadataStorage = getFromContainer(MetadataStorage);
  const validationMetadatas = metadataStorage.getTargetValidationMetadatas(fromClass, typeof fromClass);

  /**
   * Change the `target` and `propertyName` of each `ValidationMetaData`
   * and add it to `MetadataStorage`. Thus, `class-validator` uses it
   * during validation.
   *
   * @param toClass    Class owning the decorated property.
   * @param toProperty Name of the decorated property.
   */
  return (toClass: object, toProperty: any) => {
    const toPropertyName = toProperty as string;

    const sourceProperty = fromProperty || toProperty;

    const metadatasCopy = cloneDeep(validationMetadatas.filter(vm => vm.target === fromClass && vm.propertyName === sourceProperty));

    metadatasCopy.forEach(vm => {
      vm.target = toClass.constructor;
      vm.propertyName = toPropertyName;
      metadataStorage.addValidationMetadata(vm);
    });
  };
}

Related PR : https://github.com/typestack/class-validator/pull/161

[mopcweb]

Digging deeper i found next solution for my use case, maybe it still would be useful for others. Insipred by https://github.com/typestack/class-validator/issues/164#issuecomment-369874196

setupOptionalValidators.ts

import { getMetadataStorage } from 'class-validator';
import { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';

export function setupOptionalValidators(): void {
  const validationMetadatasKey = 'validationMetadatas';
  const validationMetadatas: ValidationMetadata[] = getMetadataStorage()[validationMetadatasKey];

  const forUpdate = validationMetadatas.filter((item) => !item.groups?.length);
  forUpdate.forEach((_item, i) => { forUpdate[i].always = true; });
}
// setupOptionalValidators just iterates over all ValidationMetadata(s) and addes `{ always: true }` for thos without `groups` option
// So basically it is not necessary to use it, you could add manually `{ always: true }` to all `class-validator` decorators without groups
// Because without `{ always: true }` those decorators will not work properly (

This one should be called after importing all DTOs. In my case i’m using TsED v5, so i call it if $afterRoutesInit.

Now i can write my models in convenient way: (@Property and @Required are TsED v5 decorators used here for swagger schema)

import { SomeEnum } from 'path/to/SomeEnum';
import { SomeEntity } from 'path/to/SomeEntity';

export class UpdateDto implements Partial<SomeEntity> {
  @Property()
  @IsOptional({ groups: ['update'] })
  @IsString()
  public propertyOne?: string;

  @Property()
  @IsOptional({ groups: ['update'] })
  @IsEnum(SomeEnum)
  public propertyTwo?: SomeEnum;

  @Property()
  @IsOptional({ groups: ['update'] })
  @IsString()
  public propertyThree?: string;

  @Property()
  @IsOptional()
  @IsString()
  public propertyFour?: string;

  @Property()
  @IsOptional()
  @IsBoolean()
  public propertyFive?: boolean;
}

export class CreateDto extends UpdateDto implements SomeEntity {
  @Required() public propertyOne: string;
  @Required() public propertyTwo: SomeEnum;
  @Required() public propertyThree: string;
}

End when i validating my requests - i just provide [‘create’] or [‘update’] groups for validate();

P.S. For validation inside TsED v5 i am overriding default ValidationPipe:

@OverrideProvider(ValidationPipe)
export class ClassValidationPipe extends ValidationPipe implements IPipe {
  private _validateOptions: ValidatorOptions = { whitelist: true, forbidNonWhitelisted: true };

  public async transform(value: any, metadata: ParamMetadata): Promise<any> {
    if (!this.shouldValidate(metadata)) return value;
    const options: ValidatorOptions = { ...this._validateOptions, groups: metadata.required ? ['create'] : ['update'] };

    const dataToValidate = plainToClass(metadata.type, value);
    const result = Array.isArray(dataToValidate)
      ? await this.validateList(dataToValidate, options)
      : await validate(dataToValidate, options);

    if (result.length > 0) throwHttpError.badRequest(this.removeRestrictedProperties(result));
    return value;
  }

  protected async validateList<T>(list: T[], options: ValidatorOptions = { }): Promise<ValidationError[]> {
    let result: ValidationError[] = [];
    const promises = list.map((item) => validate(item, options).then((errors) => { result = result.concat(errors); }));
    await Promise.all(promises);
    return result;
  }

  protected shouldValidate(metadata: ParamMetadata): boolean {
    const types: Function[] = [String, Boolean, Number, Array, Object];

    return !super.shouldValidate(metadata) || !types.includes(metadata.type);
  }

  // This one is just for convenient errors in my architechure
  protected removeRestrictedProperties(errors: ValidationError[]): GenericObject[] {
    if (!errors || !errors.length) return;
    const result = errors.map((item) => ({
      property: item.property,
      value: item.value,
      errors: item.constraints,
    }));
    return result;
  }
}

So now when calling @BodyParams() inside Controller ValidationPipe will add [‘update’] group, while calling @Required() @BodyParams() or @BodyParams({ required: true }) will add [‘create’] group.