mongoose#model TypeScript Examples

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost:27017/nest'),
    AdminModule.createAdminAsync({
      imports: [
        MongooseSchemasModule,
      ],
      inject: [
        getModelToken('Admin'),
      ],
      useFactory: (adminModel: Model<Admin>) => ({
        adminJsOptions: {
          rootPath: '/admin',
          resources: [
            { resource: adminModel },
          ],
        },
        auth: {
          authenticate: async (email, password) => Promise.resolve({ email: 'test' }),
          cookieName: 'test',
          cookiePassword: 'testPass',
        },
      }),
      customLoader: ExpressCustomLoader,
    }),
    MongooseSchemasModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule { }

TypegooseMiddleware: MiddlewareFn = async (_, next) => {
  const result = await next();

  if (Array.isArray(result)) {
    return result.map(item =>
      item instanceof Model ? convertDocument(item) : item
    );
  }

  if (result instanceof Model) {
    return convertDocument(result);
  }

  return result;
}

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('Pin') private readonly pinModel: Model<pin>,
    @InjectModel('Board') private readonly boardModel: Model<board>,
    @InjectModel('User') private readonly userModel: Model<user>,
    @InjectModel('Topic') private readonly topicModel: Model<topic>,
    private ValidationService: ValidationService,
    private BoardService: BoardService,
    private NotificationService: NotificationService,
    private EmailService: Email,
  ) {
    this.HelpersUtils = new HelpersUtils();
  }

export class GtModelContainer extends Model {
  static readonly [GT_DOCUMENT] = true;
  private static [GT_LOCAL_INFO]: GtLocalInfo;
  private static [GT_DISCRIMINATOR_ROOT]?: typeof GtModelContainer;
  private readonly [CTOR_INVOKED] = true;

  static ctor<T extends GtModelContainer>(this: Ctor<T>, doc: Partial<T>): T {
    if (this[GT_DISCRIMINATOR_ROOT] === this) {
      const localInfo = findSchemaContainerOfChildDiscriminator(doc, this[GT_LOCAL_INFO]);
      return new localInfo.cls(doc) as any;
    } else {
      return new this(doc);
    }
  }

  static [Symbol.hasInstance](instance: any): boolean {
    if (hasInstance.call(this, instance)) {
      return true;
    } else if (instance.schema) {
      if (instance.schema === this.schema || hasExtendingSchema(instance.schema, this[GT_LOCAL_INFO].container.hierarchy.extending)) {
        return true;
      }
    }
    return false;
  }

  constructor(doc?: any) {
    super();
    if (this.constructor[GT_DISCRIMINATOR_ROOT] === this.constructor) {
      throw new Error(`Directly instantiating the base discriminator type is not allowed`);
    }

    if (doc) {
      const localInfo = findSchemaContainerOfChildDiscriminator(doc, this.constructor[GT_LOCAL_INFO]);
      syncModelInstance(doc, this, localInfo, true);
    }
  }
}

/**
 * Add Data into Database of the Particular Model after Verification
 *
 * @async
 * @param {Model} model - Model in the Database
 * @param {Object} data - Data to be Added to Database
 * @param {IUserDoc} admin - Admin user Document from Database
 * @param {Readonly<IPolicy>[]} policies - Array of Policies Applicable for the Function
 * @returns {Promise<Document>} - Saved Document
 */
export async function addDatatoDatabase<
  T,
  U extends Document,
  V extends Model<U>,
>(
  model: V,
  data: T,
  admin: IUserDoc,
  policies: Readonly<IPolicy>[],
): Promise<U> {
  await checkPolicy(policies, admin);
  const newData = new model(data);
  const savedData = await newData.save();
  return savedData;
}

/**
 * Create an instance of a Mongoose model
 * @param classSchema
 * @param modelName
 * @param collectionName
 * @param options
 */
export function generateModel<T>(
	classSchema: ClassType,
	modelName = classSchema.name,
	collectionName?,
	options?: SchemaOptions
) {
	const schema = generateSchema(classSchema, options);
	return model(modelName, schema, collectionName) as T & ModelType<T>;
}

Analytics: Model<AnalyticsModel> = model<AnalyticsModel, AnalyticsModelStatic>(
  'Analytics',
  AnalyticsSchema,
)

Channels: Model<ChannelProps> = model('Channels', ChannelSchema)

protected repository: Model<D>;

User: Model<IUser> = model("User", UserSchema)

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'),
  ) {}

dashboardUsers: Model<IDashboardUser> =
    models["dashboard-users"] || model("dashboard-users", dashboardUserSchema)

IMusic: Model<IMusicInterface> = model("IMusic", IMusicSchema)

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

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>,
  ) {}

describe('DatabaseModelsProviders', () => {
  let conn: any;
  let userModel: any;
  let postModel: any;
  let commentModel: any;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        ...databaseModelsProviders,

        {
          provide: DATABASE_CONNECTION,
          useValue: {
            model: jest
              .fn()
              .mockReturnValue({} as Model<User | Post | Comment>),
          },
        },
      ],
    }).compile();

    conn = module.get<Connection>(DATABASE_CONNECTION);
    userModel = module.get<UserModel>(USER_MODEL);
    postModel = module.get<PostModel>(POST_MODEL);
    commentModel = module.get<CommentModel>(COMMENT_MODEL);
  });

  it('DATABASE_CONNECTION should be defined', () => {
    expect(conn).toBeDefined();
  });

  it('USER_MODEL should be defined', () => {
    expect(userModel).toBeDefined();
  });

  it('POST_MODEL should be defined', () => {
    expect(postModel).toBeDefined();
  });

  it('COMMENT_MODEL should be defined', () => {
    expect(commentModel).toBeDefined();
  });
});

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(Cat.name) private readonly catModel: Model<Cat>
    ) { }

getModel = async (name: string): Promise<Model<any>> => {
  connection = await getConnection();

  return connection.model(name);
}

discriminator<U extends Document>(name: string, schema: Schema, value?: string): Model<U> {
    const created = extendEmbeddedDocument(super.discriminator(name, schema, value));
    this.casterConstructor.discriminators[name] = created;
    return created as any;
  }

UserProfileDbModel: Model<IUserProfileDbModel> = model<
  IUserProfileDbModel
>('user', UserProfileSchema)

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

Analytics: Model<AnalyticsModel> = model<AnalyticsModel, AnalyticsModelStatic>(
  'Analytics',
  AnalyticsSchema,
)