Can't resolve dependency of component (validator constraint)

Hi, I’ve got a problem. I’m using class-validator and creating my custom constraint like this:

@Component()
@ValidatorConstraint({ async: true })
export class IsTakenConstraint implements ValidatorConstraintInterface {

  constructor(
    @Inject(UserRepositoryToken)
    private readonly userRepository: Repository<UserEntity>,
  ) {}

  validate(userInfo: any, args: ValidationArguments) {
    return this.userRepository.findOne(userInfo).then(user => !!user);
  }
}

export const IsTaken = (validationOptions?: ValidationOptions) => (
  (object: object, propertyName: string) => {
    registerDecorator({
      propertyName,
      target: object.constructor,
      options: validationOptions,
      constraints: [],
      validator: IsTakenConstraint,
    });
  }
);

Then IsTaken is used as decorator in user.dto.ts file and validation takes place in Pipe. But… I’m getting an error ‘Cannot read property ‘findOne’ of undefined’ so it seems like userRepository is not being injected into constructor. But it is exported from DatabaseModule and works properly in UsersService.

There is UsersModule:

@Module({
    modules: [DatabaseModule],
    controllers: [UsersController],
    components: [
        ...userProviders,
        IsTakenConstraint,
        UsersService,
    ],
})
export class UsersModule {}

And usersProviders:

export const userProviders = [
  {
    provide: UserRepositoryToken,
    useFactory: (connection: Connection) => connection.getRepository(UserEntity),
    inject: [DbConnectionToken],
  },
];

I’m sure I’m missing something important here…

[kamilmysliwiec]

@Pesiok no issues, you can inject dependencies to both interceptors & guards, just remember to use controller or method scope (@UseGuards()). The global ones can’t inject anything. and thanks!! 🎉

[grzegorz-bielski]

Ok, thanks once again. For future reference and people, like me for whom it was not immediately obvious:

Controller setup:

@Controller('route')
export class SassyController {
  constructor(
    private readonly thingsRepository: Repository<Things>,
  ) {}

  @Get()
  @UseGuards(SomeGuard)
  getThings() {
    return 'things';
  }
}

Guard setup:

@Guard()
export class SomeGuard implements CanActivate {
  constructor(
    @Inject(ThingsRepositoryToken)
    private readonly thingsRepository: Repository<Things>,
  ) {}

  public canActivate(request, context: ExecutionContext): boolean {
    if (this.thingsRepository.someMethod()) {
      return true;
    } else {
     return false;
   }
  }
}

Yes, it’s that easy.