How to use the typeorm-typedi-extensions.InjectRepository function in typeorm-typedi-extensions

constructor(
    @InjectRepository(Message)
    private messageRepository: MongoRepository,
    @InjectRepository(Room) private roomRepository: MongoRepository,
    @InjectRepository(User) private userRepository: MongoRepository,
  ) {}

import { processWebhooks } from '../../../utils/processWebhooks';
import { UserMetaRepository } from '../repositories/UserMetaRepository';
import { UserRepository } from '../repositories/UserRepository';
import { ConnectionArgs, createConnectionType } from '../types/createConnectionType';
import { UpdateUserInput } from '../types/UpdateUserInput';
import { Authorized } from '../utils/Authorized';
import { ExtendedConnection } from '../utils/ExtendedConnection';

const UserConnection = createConnectionType(User);

@Resolver(of => User)
export class UserResolver {
  @InjectRepository(UserRepository)
  private readonly userRepository: UserRepository;

  @InjectRepository(UserMetaRepository)
  private readonly userMetaRepository: UserMetaRepository;

  @InjectRepository(UserEmail)
  private readonly userEmailRepository: Repository;

  @Authorized()
  @Query(returns => User)
  public User(
    @Arg('id', type => ID) id: string //
  ) {
    return this.userRepository.findOneOrFail(id);
  }

  @Authorized()
  @Query(returns => User)
  public async getUser(@Ctx() context: Context) {

  constructor(@InjectRepository(Post) public readonly postRepository: Repository) {
    super(Post, postRepository);
  }

  constructor(@InjectRepository(User) public readonly userRepository: Repository) {
    super(User, userRepository);
  }

Resolver,
  UseMiddleware,
} from "type-graphql";
import { FindOneOptions, LessThan, Repository } from "typeorm";
import { InjectRepository } from "typeorm-typedi-extensions";
import { Comment } from "../../entity/Comment";
import { QuestionCommentNotification } from "../../entity/QuestionCommentNotification";
import { MyContext } from "../../types/Context";
import { isAuthenticated } from "../shared/middleware/isAuthenticated";
import { OkResponse } from "../shared/OkResponse";
import { NotificationsResponse } from "./response";

const NOTIF_LIMIT = 50;
@Resolver(Comment)
export class CommentResolver {
  @InjectRepository(QuestionCommentNotification)
  private readonly questionCommentNotificationRepo: Repository<
    QuestionCommentNotification
  >;

  @Query(() => NotificationsResponse)
  @UseMiddleware(isAuthenticated)
  async notifications(
    @Ctx() { req }: MyContext,
    @Arg("cursor", { nullable: true }) cursor?: string
  ): Promise {
    const where: FindOneOptions["where"] = {
      userToNotifyId: req.session && req.session.userId,
    };

    if (cursor) {
      where.createdAt = LessThan(cursor);

constructor(
    @InjectRepository(FeatureFlagSegment)
    protected readonly repository: Repository,
    @Inject('EnvironmentService') readonly environmentService: EnvironmentService,
    @Inject('FeatureFlagService') readonly featureFlagService: FeatureFlagService,
    @Inject('ProjectService') readonly projectService: ProjectService,
    @Inject('SegmentService') readonly segmentService: SegmentService
  ) {
    super(FeatureFlagSegment, repository);
  }

  constructor(@InjectRepository(Author) public readonly authorRepository: Repository) {
    super(Author, authorRepository);
  }

constructor(
    @InjectRepository(Message)
    private messageRepository: MongoRepository,
    @InjectRepository(Room) private roomRepository: MongoRepository,
    @InjectRepository(User) private userRepository: MongoRepository,
  ) {}

  constructor(@InjectRepository(Project) protected readonly repository: Repository) {
    super(Project, repository);
  }
}