如何在类型中传递泛型类型？

Question

I am trying to create a new constraint for Typestack Class Validators. "IsUnique" constraint will take an Entity as the type and it's column as an argument to check if that column does not exist in the database and is unique.

I have tried the code below but somehow I'm not being able to pass a type to the "IsUniqueConstraint" through validator key in the registerDecorator. Since, I'm new to Typescript so I don't understand its concepts well.

Can someone please help me to know how can we do it?

is-unique.constraint.ts

import { registerDecorator, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments, ValidationOptions } from 'class-validator';
import { Injectable } from '@nestjs/common';
import { Repository } from 'typeorm';

@ValidatorConstraint({ name: 'isUnique', async: true })
@Injectable()
export class IsUniqueConstraint<T> implements ValidatorConstraintInterface {

    constructor(private readonly repository: Repository<T>) { }

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

        const result = await this.repository.findOne({ where: { [column]: value } });

        if (result) {
            return false;
        }

        return true;
    }

    defaultMessage(args: ValidationArguments) {
        return `"${args.value}" already exists for ${args.constraints[0]}`;
    }

}

export function IsUnique<T>(column: string, validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            target: object.constructor,
            propertyName,
            options: validationOptions,
            constraints: [column],
            validator: IsUniqueConstraint,
        });
    };
}

user.dto.ts

import { IsNotEmpty } from 'class-validator';
import { IsUnique } from './../shared/constraints/is-unique.constraint';
import { User } from './user.entity';

export class CreateUserDto {
  @IsNotEmpty()
  @IsUnique<User>('username')
  readonly username: string;
}

Answer 1

Generics are generally a compile-time-only feature. Unless you have some way of emitting the metadata, including the generics (not sure if that is easily possible).

If you need to use a type at run-time, you generally should pass it as a regular argument, so in this case the signature has to change to accommodate this:

@IsUnique(User, 'username')

This is probably why when injecting repositories you do it via @InjectRepository(User) , which also takes the entity class as argument. I doubt that IsUniqueConstraint can have the repository injected as is. You would probably need to resolve it from the DI container/connection manager based on the entity type passed by the decorator.

According to the docs you can directly assign an object to validator , not just a class/constructor, so you can create a concrete instance of your validator, manually passing the resolved repository to the constructor.

So, maybe something along those lines:

import { getRepository } from "typeorm";
// ...

export function IsUnique(
    entity: Function,
    column: string,
    validationOptions?: ValidationOptions) {

    // Not sure if this works here. Maybe it needs to be
    // moved into the returned function or a different resolution
    // mechanism is required.
    const repository = getRepository(entity); 

    return (object: object, propertyName: string) => {
        registerDecorator({
            target: object.constructor,
            propertyName,
            options: validationOptions,
            constraints: [column],
            validator: new IsUniqueConstraint(repository),
        });
    };
}

Answer 2

Okay, after trying a lot I have solved it the other way. Thanks to @HB for showing me the path.

To do the same I passed the entity to the validator and generated repository in the class itself. Because Nest JS Injection was working for the classes only.

import { registerDecorator, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments, ValidationOptions } from 'class-validator';
import { Injectable } from '@nestjs/common';
import { Connection } from 'typeorm';
import { InjectConnection } from '@nestjs/typeorm';

@ValidatorConstraint({ name: 'isUnique', async: true })
@Injectable()
export class IsUniqueConstraint implements ValidatorConstraintInterface {

    constructor(@InjectConnection() private readonly connection: Connection) { }

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

        const repository = this.connection.getRepository(entity);
        const result     = await repository.findOne({ where: { [column]: value } });

        if (result) {
            return false;
        }

        return true;
    }

    defaultMessage(args: ValidationArguments) {
        return `"${args.value}" already exists for ${args.constraints[1]}`;
    }

}

export function IsUnique(entity: Function, column: string, validationOptions?: ValidationOptions) {
    return (object: object, propertyName: string) => {
        registerDecorator({
            target: object.constructor,
            propertyName,
            options: validationOptions,
            constraints: [entity, column],
            validator: IsUniqueConstraint,
        });
    };
}