@nestjs/mongoose#InjectModel TypeScript Examples

constructor(
    @InjectModel(Track.modelName)
    protected readonly EntityModel: ReturnModelType<typeof Track>,
    @InjectModel(Stage.modelName)
    protected readonly StageModel: ReturnModelType<typeof Stage>,
    @InjectModel(TrackMentor.modelName)
    protected readonly trackMentorModel: ReturnModelType<typeof TrackMentor>,
    protected readonly userService: UsersService
  ) {
    super(EntityModel);
  }

constructor(
    @InjectModel('User') private readonly userModel: Model<user>,
    @InjectModel('Topic') private readonly topicModel: Model<topic>,
    @InjectModel('Pin') private readonly pinModel: Model<pin>,
    @InjectModel('Board') private readonly boardModel: Model<board>,
    @InjectModel('Chat') private readonly chatModel: Model<chat>,
    @InjectModel('Message') private readonly messageModel: Model<message>,

    private notification: NotificationService,
    private email: Email,
    private ValidationService: ValidationService,
    private boardService: BoardService,
  ) { }

constructor(
    @InjectModel('Course') private readonly CourseModel: Model<Course>,
    @InjectModel('Schedule') private readonly ScheduleModel: Model<Schedule>,
    @InjectModel('Review') private readonly ReviewModel: Model<Review>,
    @InjectModel('Doubt') private readonly DoubtModel: Model<Doubt>,
    @InjectModel('DoubtAnswer')
    private readonly DoubtAnswerModel: Model<DoubtAnswer>,
    @InjectModel('Assignment')
    private readonly AssignmentModel: Model<Assignment>,
    @InjectModel('Lecture') private readonly LectureModel: Model<Lecture>,
    @InjectModel('Mentor') private readonly mentorModel: Model<Mentor>,
  ) {}

constructor(@InjectModel('User') private readonly userModel: Model<user>) {
    this.params = {
      type: String(process.env.FIREBASE_CREADENTIAL_TYPE),
      projectId: String(process.env.FIREBASE_CREADENTIAL_PROJECT_ID),
      privateKeyId: String(process.env.FIREBASE_CREADENTIAL_PRIVATE_KEY_ID),
      privateKey: String(
        process.env.FIREBASE_CREADENTIAL_PRIVATE_KEY.replace(/\\n/g, '\n'),
      ),
      clientEmail: String(process.env.FIREBASE_CREADENTIAL_CLIENT_ID),
      clientId: String(process.env.FIREBASE_CREADENTIAL_CLIENT_EMAIL),
      authUri: String(process.env.FIREBASE_CREADENTIAL_AUTH_URI),
      tokenUri: String(process.env.FIREBASE_CREADENTIAL_TOKEN_URI),
      authProviderX509CertUrl: String(
        process.env.FIREBASE_CREADENTIAL_AUTH_PROVIDER_X509_CERT_URL,
      ),
      clientX509CertUrl: String(
        process.env.FIREBASE_CREADENTIAL_CLIENT_X509_CERT_URL,
      ),
    };
    this.app = firebase.initializeApp({
      credential: firebase.credential.cert(this.params),
    });
    this.HelpersUtils = new HelpersUtils();
  }

constructor(
    @InjectModel(MentorMentee.modelName)
    private mentorMenteeModel: ReturnModelType<typeof MentorMentee>,
    @InjectModel(TrackMentor.modelName)
    private trackMentorModel: ReturnModelType<typeof TrackMentor>,
    @InjectModel(Submission.modelName)
    private SubmissionModel: ReturnModelType<typeof Submission>,
    private mailService: MailService
  ) {}

constructor(
    @InjectModel('Board') private readonly boardModel: Model<board>,
    @InjectModel('Pin') private readonly pinModel: Model<pin>,
    @InjectModel('Topic') private readonly topicModel: Model<topic>,
    @InjectModel('User') private readonly userModel: Model<user>,
    private ValidationService: ValidationService,
  ) {}

constructor(
    @InjectModel('Announcement')
    private readonly AnnouncementModel: Model<Announcement>,
  ) {}

constructor(
    @InjectModel('fs.files') private readonly fileModel: Model<File>,
    @InjectConnection() private readonly connection: Connection,
  ) {
    this.bucket = new mongo.GridFSBucket(this.connection.db)
  }

constructor(@InjectModel(User.name) private readonly user: Model<User>) {}

constructor(
    @InjectModel('Product') private readonly productModel: Model<ProductEntity>,
  ) {}

constructor(
    @InjectModel(User.modelName)
    protected readonly userEntity: ReturnModelType<typeof User>
  ) {
    super(userEntity);
  }

constructor(
    @InjectModel('User') private readonly userModel: Model<user>,
    @InjectModel('Chat') private readonly chatModel: Model<chat>,
    @InjectModel('Message') private readonly messageModel: Model<message>,

    private ValidationService: ValidationService,
  ) {}

constructor(
        @InjectModel(Cat.name) private readonly catModel: Model<Cat>
    ) { }

constructor(
    @InjectModel('User') private readonly userModel: Model<User>,
    @InjectModel('Session') private readonly sessionModel: Model<Session>,
  ) {}

constructor(@InjectModel(User.name) private userModel: Model<UserDocument>) {}

constructor(@InjectModel(User.name) private usersModel: Model<UserDocument>) {}

constructor(@InjectModel('Sequence') private sequenceModel: Model<ISequence>) {}

constructor(
    @InjectModel(Application.name) private applicationModel: Model<ApplicationDocument>,
    @InjectModel('User') private userModel: Model<UserDocument>,
    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger = new Logger('application'),
  ) {}

constructor(@InjectModel('User') private readonly userModel: Model<User>) {}

constructor(
    @InjectModel('User') private userModel: Model<UserDocument>,
    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger = new Logger('user'),
  ) {}

constructor(
    @InjectModel(TemporaryToken.modelName)
    protected readonly tokenEntity: ReturnModelType<typeof TemporaryToken>
  ) {
    super(tokenEntity);
  }

constructor(@InjectModel(User.name) private usersModel: Model<UserDocument>) {}

constructor(
    @InjectModel(UserStage.modelName)
    protected readonly UserStageModel: ReturnModelType<typeof UserStage>,
    protected readonly userService: UsersService
  ) {
    super(UserStageModel);
  }