@mikro-orm/mongodb 7.0.0-dev.114 → 7.0.0-dev.116

package/MongoConnection.d.ts

@@ -24,17 +24,17 @@ export declare class MongoConnection extends Connection {
     mapOptions(overrides: MongoClientOptions): MongoClientOptions;
     getDb(): Db;
     execute(query: string): Promise<any>;
-    find<T extends object>(collection: string, where: FilterQuery<T>, orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[], limit?: number, offset?: number, fields?: string[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<EntityData<T>[]>;
-    stream<T extends object>(collection: string, where: FilterQuery<T>, orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[], limit?: number, offset?: number, fields?: string[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
+    find<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[], limit?: number, offset?: number, fields?: string[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[], limit?: number, offset?: number, fields?: string[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
     private _find;
-    insertOne<T extends object>(collection: string, data: Partial<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
-    insertMany<T extends object>(collection: string, data: Partial<T>[], ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
-    updateMany<T extends object>(collection: string, where: FilterQuery<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertOptions<T>): Promise<QueryResult<T>>;
-    bulkUpdateMany<T extends object>(collection: string, where: FilterQuery<T>[], data: Partial<T>[], ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    deleteMany<T extends object>(collection: string, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
-    aggregate<T extends object = any>(collection: string, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<T[]>;
-    streamAggregate<T extends object>(collection: string, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, stream?: boolean): AsyncIterableIterator<T>;
-    countDocuments<T extends object>(collection: string, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<number>;
+    insertOne<T extends object>(entityName: EntityName<T>, data: Partial<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
+    insertMany<T extends object>(entityName: EntityName<T>, data: Partial<T>[], ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
+    updateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertOptions<T>): Promise<QueryResult<T>>;
+    bulkUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: Partial<T>[], ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    deleteMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
+    aggregate<T extends object = any>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<T[]>;
+    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, stream?: boolean): AsyncIterableIterator<T>;
+    countDocuments<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<number>;
     transactional<T>(cb: (trx: Transaction<ClientSession>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         ctx?: Transaction<ClientSession>;

package/MongoConnection.js

@@ -1,5 +1,5 @@
 import { MongoClient, ObjectId, } from 'mongodb';
-import { Connection, EventType, QueryOrder, Utils, ValidationError, inspect, } from '@mikro-orm/core';
+import { Connection, EventType, inspect, QueryOrder, Utils, ValidationError, } from '@mikro-orm/core';
 export class MongoConnection extends Connection {
     #client;
     #db;
@@ -111,26 +111,26 @@ export class MongoConnection extends Connection {
     async execute(query) {
         throw new Error(`${this.constructor.name} does not support generic execute method`);
     }
-    async find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
-        const { cursor, query } = await this._find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext);
+    async find(entityName, where, orderBy, limit, offset, fields, ctx, loggerContext) {
+        const { cursor, query } = await this._find(entityName, where, orderBy, limit, offset, fields, ctx, loggerContext);
         const now = Date.now();
         const res = await cursor.toArray();
         this.logQuery(`${query}.toArray();`, { took: Date.now() - now, results: res.length, ...loggerContext });
         return res;
     }
-    async *stream(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
-        const { cursor, query } = await this._find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext);
+    async *stream(entityName, where, orderBy, limit, offset, fields, ctx, loggerContext) {
+        const { cursor, query } = await this._find(entityName, where, orderBy, limit, offset, fields, ctx, loggerContext);
         this.logQuery(`${query}.toArray();`, loggerContext);
         yield* cursor;
     }
-    async _find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
+    async _find(entityName, where, orderBy, limit, offset, fields, ctx, loggerContext) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
+        const collection = this.getCollectionName(entityName);
         const options = ctx ? { session: ctx } : {};
         if (fields) {
             options.projection = fields.reduce((o, k) => Object.assign(o, { [k]: 1 }), {});
         }
-        const resultSet = this.getCollection(collection).find(where, options);
+        const resultSet = this.getCollection(entityName).find(where, options);
         let query = `db.getCollection('${collection}').find(${this.logObject(where)}, ${this.logObject(options)})`;
         orderBy = Utils.asArray(orderBy);
         if (Array.isArray(orderBy) && orderBy.length > 0) {
@@ -156,44 +156,44 @@ export class MongoConnection extends Connection {
         }
         return { cursor: resultSet, query };
     }
-    async insertOne(collection, data, ctx) {
-        return this.runQuery('insertOne', collection, data, undefined, ctx);
+    async insertOne(entityName, data, ctx) {
+        return this.runQuery('insertOne', entityName, data, undefined, ctx);
     }
-    async insertMany(collection, data, ctx) {
-        return this.runQuery('insertMany', collection, data, undefined, ctx);
+    async insertMany(entityName, data, ctx) {
+        return this.runQuery('insertMany', entityName, data, undefined, ctx);
     }
-    async updateMany(collection, where, data, ctx, upsert, upsertOptions) {
-        return this.runQuery('updateMany', collection, data, where, ctx, upsert, upsertOptions);
+    async updateMany(entityName, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery('updateMany', entityName, data, where, ctx, upsert, upsertOptions);
     }
-    async bulkUpdateMany(collection, where, data, ctx, upsert, upsertOptions) {
-        return this.runQuery('bulkUpdateMany', collection, data, where, ctx, upsert, upsertOptions);
+    async bulkUpdateMany(entityName, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery('bulkUpdateMany', entityName, data, where, ctx, upsert, upsertOptions);
     }
-    async deleteMany(collection, where, ctx) {
-        return this.runQuery('deleteMany', collection, undefined, where, ctx);
+    async deleteMany(entityName, where, ctx) {
+        return this.runQuery('deleteMany', entityName, undefined, where, ctx);
     }
-    async aggregate(collection, pipeline, ctx, loggerContext) {
+    async aggregate(entityName, pipeline, ctx, loggerContext) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
+        const collection = this.getCollectionName(entityName);
         /* v8 ignore next */
         const options = ctx ? { session: ctx } : {};
         const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)}).toArray();`;
         const now = Date.now();
-        const res = await this.getCollection(collection).aggregate(pipeline, options).toArray();
+        const res = await this.getCollection(entityName).aggregate(pipeline, options).toArray();
         this.logQuery(query, { took: Date.now() - now, results: res.length, ...loggerContext });
         return res;
     }
-    async *streamAggregate(collection, pipeline, ctx, loggerContext, stream = false) {
+    async *streamAggregate(entityName, pipeline, ctx, loggerContext, stream = false) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
+        const collection = this.getCollectionName(entityName);
         /* v8 ignore next */
         const options = ctx ? { session: ctx } : {};
         const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)})};`;
-        const cursor = this.getCollection(collection).aggregate(pipeline, options);
+        const cursor = this.getCollection(entityName).aggregate(pipeline, options);
         this.logQuery(query, { ...loggerContext });
         yield* cursor;
     }
-    async countDocuments(collection, where, ctx) {
-        return this.runQuery('countDocuments', collection, undefined, where, ctx);
+    async countDocuments(entityName, where, ctx) {
+        return this.runQuery('countDocuments', entityName, undefined, where, ctx);
     }
     async transactional(cb, options = {}) {
         await this.ensureConnection();
@@ -237,9 +237,9 @@ export class MongoConnection extends Connection {
         this.logQuery('db.rollback();');
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
-    async runQuery(method, collection, data, where, ctx, upsert, upsertOptions, loggerContext) {
+    async runQuery(method, entityName, data, where, ctx, upsert, upsertOptions, loggerContext) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
+        const collection = this.getCollectionName(entityName);
         const logger = this.config.getLogger();
         const options = ctx ? { session: ctx, upsert } : { upsert };
         if (options.upsert === undefined) {
@@ -253,22 +253,22 @@ export class MongoConnection extends Connection {
             case 'insertOne':
                 Object.keys(data).filter(k => typeof data[k] === 'undefined').forEach(k => delete data[k]);
                 query = log(() => `db.getCollection('${collection}').insertOne(${this.logObject(data)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection).insertOne(data, options), query);
+                res = await this.rethrow(this.getCollection(entityName).insertOne(data, options), query);
                 break;
             case 'insertMany':
                 data.forEach(data => Object.keys(data).filter(k => typeof data[k] === 'undefined').forEach(k => delete data[k]));
                 query = log(() => `db.getCollection('${collection}').insertMany(${this.logObject(data)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection).insertMany(data, options), query);
+                res = await this.rethrow(this.getCollection(entityName).insertMany(data, options), query);
                 break;
             case 'updateMany': {
-                const payload = Object.keys(data).some(k => k.startsWith('$')) ? data : this.createUpdatePayload(data, upsertOptions);
+                const payload = Object.keys(data).every(k => k.startsWith('$')) ? data : this.createUpdatePayload(data, upsertOptions);
                 query = log(() => `db.getCollection('${collection}').updateMany(${this.logObject(where)}, ${this.logObject(payload)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection).updateMany(where, payload, options), query);
+                res = await this.rethrow(this.getCollection(entityName).updateMany(where, payload, options), query);
                 break;
             }
             case 'bulkUpdateMany': {
                 query = log(() => `bulk = db.getCollection('${collection}').initializeUnorderedBulkOp(${this.logObject(options)});\n`);
-                const bulk = this.getCollection(collection).initializeUnorderedBulkOp(options);
+                const bulk = this.getCollection(entityName).initializeUnorderedBulkOp(options);
                 data.forEach((row, idx) => {
                     const id = where[idx];
                     const cond = Utils.isPlainObject(id) ? id : { _id: id };
@@ -294,7 +294,7 @@ export class MongoConnection extends Connection {
             case 'deleteMany':
             case 'countDocuments':
                 query = log(() => `db.getCollection('${collection}').${method}(${this.logObject(where)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection)[method](where, options), query);
+                res = await this.rethrow(this.getCollection(entityName)[method](where, options), query);
                 break;
         }
         this.logQuery(query, { took: Date.now() - now, ...loggerContext });
@@ -311,7 +311,14 @@ export class MongoConnection extends Connection {
         });
     }
     createUpdatePayload(row, upsertOptions) {
+        row = { ...row };
         const doc = { $set: row };
+        Utils.keys(row).forEach(k => {
+            if (k.toString().startsWith('$')) {
+                doc[k] = row[k];
+                delete row[k];
+            }
+        });
         const $unset = {};
         const $inc = {};
         for (const k of Utils.keys(row)) {
@@ -367,10 +374,9 @@ export class MongoConnection extends Connection {
             insertedIds: res.insertedIds ? Object.values(res.insertedIds) : undefined,
         };
     }
-    getCollectionName(name) {
-        name = Utils.className(name);
-        const meta = this.metadata.find(name);
-        return meta ? meta.collection : name;
+    getCollectionName(entityName) {
+        const meta = this.metadata.find(entityName);
+        return meta ? meta.collection : Utils.className(entityName);
     }
     logObject(o) {
         if (o.session) {

package/MongoDriver.d.ts

@@ -13,25 +13,25 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any, any, any> & {
         rawResults?: boolean;
     }): AsyncIterableIterator<T>;
-    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     streamVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): AsyncIterableIterator<EntityData<T>>;
-    count<T extends object>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T>, ctx?: Transaction<ClientSession>): Promise<number>;
-    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: {
+    count<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T>, ctx?: Transaction<ClientSession>): Promise<number>;
+    nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: {
         ctx?: Transaction<ClientSession>;
     }): Promise<QueryResult<T>>;
-    aggregate(entityName: string, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
-    streamAggregate<T extends object>(entityName: string, pipeline: any[], ctx?: Transaction<ClientSession>): AsyncIterableIterator<T>;
+    aggregate(entityName: EntityName, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
+    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>): AsyncIterableIterator<T>;
     getPlatform(): MongoPlatform;
     private renameFields;
     private convertObjectIds;
     private buildFilterById;
-    protected buildFields<T extends object, P extends string = never>(entityName: string, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;
+    protected buildFields<T extends object, P extends string = never>(entityName: EntityName<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;
     private handleVersionProperty;
     /** @inheritDoc */
     getORMClass(): Constructor<MongoMikroORM>;

package/MongoDriver.js

@@ -20,7 +20,6 @@ export class MongoDriver extends DatabaseDriver {
             yield* this.streamVirtual(entityName, where, options);
             return;
         }
-        entityName = Utils.className(entityName);
         const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
         where = this.renameFields(entityName, where, true);
         const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
@@ -259,14 +258,14 @@ export class MongoDriver extends DatabaseDriver {
                         return;
                     }
                     if (prop.array && Array.isArray(copiedData[prop.name])) {
-                        copiedData[prop.name] = copiedData[prop.name].map((item) => this.renameFields(prop.type, item, dotPaths, true));
+                        copiedData[prop.name] = copiedData[prop.name].map((item) => this.renameFields(prop.targetMeta.class, item, dotPaths, true));
                     }
                     else {
-                        copiedData[prop.name] = this.renameFields(prop.type, copiedData[prop.name], dotPaths, prop.object || object);
+                        copiedData[prop.name] = this.renameFields(prop.targetMeta.class, copiedData[prop.name], dotPaths, prop.object || object);
                     }
                 }
                 else {
-                    const meta2 = this.metadata.find(prop.type);
+                    const meta2 = this.metadata.find(prop.targetMeta.class);
                     const pk = meta2.properties[meta2.primaryKeys[0]];
                     isObjectId = pk.type === 'ObjectId';
                 }
@@ -308,10 +307,7 @@ export class MongoDriver extends DatabaseDriver {
         return { _id: id };
     }
     buildFields(entityName, populate, fields, exclude) {
-        const meta = this.metadata.find(entityName);
-        if (!meta) {
-            return fields;
-        }
+        const meta = this.metadata.get(entityName);
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => this.isPopulated(meta, prop, p)));
         const ret = [];
         if (fields) {

package/MongoEntityManager.d.ts

@@ -9,11 +9,11 @@ export declare class MongoEntityManager<Driver extends MongoDriver = MongoDriver
     /**
      * Shortcut to driver's aggregate method. Available in MongoDriver only.
      */
-    aggregate(entityName: EntityName<any>, pipeline: any[]): Promise<any[]>;
+    aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
     /**
      * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
      */
-    streamAggregate<T extends object>(entityName: EntityName<any>, pipeline: any[]): AsyncIterableIterator<T>;
+    streamAggregate<T extends object>(entityName: EntityName, pipeline: any[]): AsyncIterableIterator<T>;
     /**
      * @inheritDoc
      */

package/MongoEntityManager.js

@@ -7,14 +7,12 @@ export class MongoEntityManager extends EntityManager {
      * Shortcut to driver's aggregate method. Available in MongoDriver only.
      */
     async aggregate(entityName, pipeline) {
-        entityName = Utils.className(entityName);
         return this.getDriver().aggregate(entityName, pipeline, this.getTransactionContext());
     }
     /**
      * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
      */
     async *streamAggregate(entityName, pipeline) {
-        entityName = Utils.className(entityName);
         yield* this.getDriver().streamAggregate(entityName, pipeline, this.getTransactionContext());
     }
     /**

package/MongoSchemaGenerator.js

@@ -11,7 +11,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         /* v8 ignore next */
         const promises = metadata
             .filter(meta => !existing.includes(meta.collection))
-            .map(meta => this.connection.createCollection(meta.collection).catch(err => {
+            .map(meta => this.connection.createCollection(meta.class).catch(err => {
             const existsErrorMessage = `Collection ${this.config.get('dbName')}.${meta.collection} already exists.`;
             // ignore errors about the collection already existing
             if (!(err.name === 'MongoServerError' && err.message.includes(existsErrorMessage))) {
@@ -32,7 +32,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         }
         const promises = metadata
             .filter(meta => existing.includes(meta.collection))
-            .map(meta => this.connection.dropCollection(meta.collection));
+            .map(meta => this.connection.dropCollection(meta.class));
         await Promise.all(promises);
     }
     async update(options = {}) {
@@ -127,7 +127,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         meta.indexes.forEach(index => {
             let fieldOrSpec;
             const properties = this.mapIndexProperties(index, meta);
-            const collection = this.connection.getCollection(meta.className);
+            const collection = this.connection.getCollection(meta.class);
             if (Array.isArray(index.options) && index.options.length === 2 && properties.length === 0) {
                 res.push([collection.collectionName, collection.createIndex(index.options[0], index.options[1])]);
                 return;
@@ -173,7 +173,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         meta.uniques.forEach(index => {
             const properties = this.mapIndexProperties(index, meta);
             const fieldOrSpec = properties.reduce((o, i) => { o[i] = 1; return o; }, {});
-            const collection = this.connection.getCollection(meta.className);
+            const collection = this.connection.getCollection(meta.class);
             res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: index.name,
                     unique: true,
@@ -186,7 +186,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         if (!prop[type] || !meta.collection) {
             return [];
         }
-        const collection = this.connection.getCollection(meta.className);
+        const collection = this.connection.getCollection(meta.class);
         const fieldOrSpec = prop.embeddedPath
             ? prop.embeddedPath.join('.')
             : prop.fieldNames.reduce((o, i) => { o[i] = 1; return o; }, {});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/mongodb",
   "type": "module",
-  "version": "7.0.0-dev.114",
+  "version": "7.0.0-dev.116",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -53,9 +53,9 @@
     "mongodb": "7.0.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.2"
+    "@mikro-orm/core": "^6.6.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.114"
+    "@mikro-orm/core": "7.0.0-dev.116"
   }
 }