feature: How to Assign Validation Result to a Field Using class-validator in NestJS?

[cppleon]

I am working on a NestJS project where I use class-validator to validate incoming DTOs. I have a custom validator @IsAccessPointExists() that checks if an access point exists in the database. The validation works fine, but I also want to assign the validated access point object (retrieved from the database) to the accessPoint field in the DTO after validation. I want to avoid making an extra database query to fetch the access point after validation.

Here is my current DTO:

export class CompleteInstallationDto {
  @IsMongoId()
  @IsAccessPointExists()
  accessPoint: string; // I want this to hold the validated access point object
}

And here is my custom validator:

@ValidatorConstraint({ async: true })
@Injectable()
export class IsAccessPointExistsConstraint
  implements ValidatorConstraintInterface
{
  constructor(private readonly accessPointService: AccessPointService) {}

  async validate(value: string): Promise<boolean> {
    const accessPoint = await this.accessPointService.findById(value);
    return !!accessPoint; // Validation works fine
  }

  defaultMessage(): string {
    return 'Access point does not exist';
  }
}

export function IsAccessPointExists(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsAccessPointExistsConstraint,
    });
  };
}

I want the accessPoint field in the DTO to hold the validated access point object (retrieved from the database) instead of just the ID. Is there a way to achieve this using class-validator or class-transformer? If not, what would be the best approach to handle this?

Any help or suggestions would be greatly appreciated!

[cppleon]

Problem Statement
Currently, class-validator focuses solely on validation and does not allow assigning the result of a validation (e.g., a database query result) to the validated field. This limitation forces developers to make redundant database queries after validation, which is inefficient and adds unnecessary complexity.

Proposed Solution
Introduce a new method, validateAndAssign, in class-validator that allows both validation and assignment of the validation result to the field being validated.

How It Could Work

• The custom validator would implement a validateAndAssign method that returns the validated value (e.g., a database document).
• If the validation passes, the returned value would be assigned to the field in the DTO.
• If the validation fails, the usual validation error would be thrown.

Example Usage

@ValidatorConstraint({ name: 'IsAccessPointExists', async: true })
@Injectable()
export class IsAccessPointExistsValidator
  implements ValidatorConstraintInterface
{
  constructor(
    @InjectModel(AccessPoint.name)
    private readonly accessPointModel: Model<AccessPoint>,
  ) {}

  async validate(accessPointId: string): Promise<boolean> {
    const accessPoint = await this.accessPointModel.exists({ _id: accessPointId }).exec();
    return !!accessPoint;
  }

  async validateAndAssign(accessPointId: string): Promise<any> {
    return await this.accessPointModel.findById(accessPointId).exec();
  }

  defaultMessage(args: ValidationArguments): string {
    return `Access Point with ID "${args.value}" does not exist.`;
  }
}

DTO

export class CompleteInstallationDto {
  @IsMACAddress()
  @ApiProperty()
  macAddress: string;

  @IsMongoId()
  @IsAccessPointExists({ assign: true }) // Assign the validated document to the field
  @ApiProperty()
  accessPoint: AccessPoint; // This will hold the validated AccessPoint document
}

Expected Behavior

• The @IsAccessPointExists decorator validates whether the accessPoint exists in the database.
• If the validation passes, the accessPoint field in the DTO is assigned the validated document (retrieved during validation).
• If the validation fails, the usual validation error is thrown.

Benefits

• Efficiency: Avoids redundant database queries by reusing the result of the validation.
• Convenience: Simplifies the code by combining validation and assignment into a single step.
• Flexibility: Developers can enable assignment when needed using an option like { assign: true }.