@mikro-orm/mongodb 7.0.0-dev.32 → 7.0.0-dev.321

package/MongoDriver.js

@@ -1,8 +1,9 @@
 import { ObjectId } from 'mongodb';
-import { DatabaseDriver, EntityManagerType, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { DatabaseDriver, EntityManagerType, PolymorphicRef, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { MongoConnection } from './MongoConnection.js';
 import { MongoPlatform } from './MongoPlatform.js';
 import { MongoEntityManager } from './MongoEntityManager.js';
+import { MongoMikroORM } from './MongoMikroORM.js';
 export class MongoDriver extends DatabaseDriver {
     [EntityManagerType];
     connection = new MongoConnection(this.config);
@@ -14,6 +15,31 @@ export class MongoDriver extends DatabaseDriver {
         const EntityManagerClass = this.config.get('entityManager', MongoEntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
+    async *stream(entityName, where, options) {
+        if (this.metadata.find(entityName)?.virtual) {
+            yield* this.streamVirtual(entityName, where, options);
+            return;
+        }
+        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));
+        const res = this.getConnection('read').stream(entityName, where, {
+            orderBy,
+            limit: options.limit,
+            offset: options.offset,
+            fields,
+            ctx: options.ctx,
+            ...this.buildQueryOptions(options),
+        });
+        for await (const item of res) {
+            if (options.rawResults) {
+                yield item;
+            }
+            else {
+                yield this.mapResult(item, this.metadata.find(entityName));
+            }
+        }
+    }
     async find(entityName, where, options = {}) {
         if (this.metadata.find(entityName)?.virtual) {
             return this.findVirtual(entityName, where, options);
@@ -36,14 +62,29 @@ export class MongoDriver extends DatabaseDriver {
             const { orderBy: newOrderBy, where: newWhere } = this.processCursorOptions(meta, options, options.orderBy);
             const newWhereConverted = this.renameFields(entityName, newWhere, true);
             const orderBy = Utils.asArray(newOrderBy).map(order => this.renameFields(entityName, order, true));
-            const res = await this.rethrow(this.getConnection('read').find(entityName, andWhere(where, newWhereConverted), orderBy, options.limit, options.offset, fields, options.ctx, options.logging));
+            const res = await this.rethrow(this.getConnection('read').find(entityName, andWhere(where, newWhereConverted), {
+                orderBy,
+                limit: options.limit,
+                offset: options.offset,
+                fields,
+                ctx: options.ctx,
+                loggerContext: options.logging,
+                ...this.buildQueryOptions(options),
+            }));
             if (isCursorPagination && !first && !!last) {
                 res.reverse();
             }
             return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
         }
         const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
-        const res = await this.rethrow(this.getConnection('read').find(entityName, where, orderBy, options.limit, options.offset, fields, options.ctx));
+        const res = await this.rethrow(this.getConnection('read').find(entityName, where, {
+            orderBy,
+            limit: options.limit,
+            offset: options.offset,
+            fields,
+            ctx: options.ctx,
+            ...this.buildQueryOptions(options),
+        }));
         return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
     }
     async findOne(entityName, where, options = { populate: [], orderBy: {} }) {
@@ -58,7 +99,14 @@ export class MongoDriver extends DatabaseDriver {
         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));
-        const res = await this.rethrow(this.getConnection('read').find(entityName, where, orderBy, 1, undefined, fields, options.ctx, options.logging));
+        const res = await this.rethrow(this.getConnection('read').find(entityName, where, {
+            orderBy,
+            limit: 1,
+            fields,
+            ctx: options.ctx,
+            loggerContext: options.logging,
+            ...this.buildQueryOptions(options),
+        }));
         return this.mapResult(res[0], this.metadata.find(entityName));
     }
     async findVirtual(entityName, where, options) {
@@ -70,13 +118,29 @@ export class MongoDriver extends DatabaseDriver {
         /* v8 ignore next */
         return super.findVirtual(entityName, where, options);
     }
-    async count(entityName, where, options = {}, ctx) {
-        /* v8 ignore next 3 */
+    async *streamVirtual(entityName, where, options) {
+        const meta = this.metadata.find(entityName);
+        if (meta.expression instanceof Function) {
+            const em = this.createEntityManager();
+            const stream = await meta.expression(em, where, options, true);
+            yield* stream;
+            return;
+        }
+        /* v8 ignore next */
+        return super.findVirtual(entityName, where, options);
+    }
+    async count(entityName, where, options = {}) {
+        /* v8 ignore next */
         if (this.metadata.find(entityName)?.virtual) {
             return this.countVirtual(entityName, where, options);
         }
         where = this.renameFields(entityName, where, true);
-        return this.rethrow(this.getConnection('read').countDocuments(entityName, where, ctx));
+        const queryOpts = this.buildQueryOptions(options);
+        return this.rethrow(this.getConnection('read').countDocuments(entityName, where, {
+            ctx: options.ctx,
+            loggerContext: options.logging,
+            ...queryOpts,
+        }));
     }
     async nativeInsert(entityName, data, options = {}) {
         this.handleVersionProperty(entityName, data);
@@ -165,10 +229,38 @@ export class MongoDriver extends DatabaseDriver {
     async aggregate(entityName, pipeline, ctx) {
         return this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, ctx));
     }
+    async *streamAggregate(entityName, pipeline, ctx) {
+        yield* this.getConnection('read').streamAggregate(entityName, pipeline, ctx);
+    }
     getPlatform() {
         return this.platform;
     }
-    renameFields(entityName, data, dotPaths = false, object) {
+    buildQueryOptions(options) {
+        if (options.collation != null && typeof options.collation === 'string') {
+            throw new Error("Collation option for MongoDB must be a CollationOptions object (e.g. { locale: 'en' }). Use a string only with SQL drivers.");
+        }
+        const ret = {};
+        if (options.collation) {
+            ret.collation = options.collation;
+        }
+        if (options.indexHint != null) {
+            ret.indexHint = options.indexHint;
+        }
+        if (options.maxTimeMS != null) {
+            ret.maxTimeMS = options.maxTimeMS;
+        }
+        if (options.allowDiskUse != null) {
+            ret.allowDiskUse = options.allowDiskUse;
+        }
+        return ret;
+    }
+    renameFields(entityName, data, dotPaths = false, object, root = true) {
+        if (data == null && root) {
+            return {};
+        }
+        if (typeof data !== 'object' || data === null) {
+            return data;
+        }
         // copy to new variable to prevent changing the T type or doing as unknown casts
         const copiedData = Object.assign({}, data); // copy first
         const meta = this.metadata.find(entityName);
@@ -184,7 +276,7 @@ export class MongoDriver extends DatabaseDriver {
             for (let i = 0; i < copiedData.$and.length; i++) {
                 const and = copiedData.$and[i];
                 if ('$fulltext' in and) {
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if ('$fulltext' in copiedData) {
                         throw new Error('Cannot merge multiple $fulltext conditions to top level of the query object.');
                     }
@@ -204,13 +296,12 @@ export class MongoDriver extends DatabaseDriver {
             throw new Error('Full text search is only supported on the top level of the query object.');
         }
         Utils.keys(copiedData).forEach(k => {
-            if (Utils.isGroupOperator(k)) {
-                /* v8 ignore next 5 */
+            if (Utils.isOperator(k)) {
                 if (Array.isArray(copiedData[k])) {
-                    copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v));
+                    copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v, dotPaths, object, false));
                 }
                 else {
-                    copiedData[k] = this.renameFields(entityName, copiedData[k]);
+                    copiedData[k] = this.renameFields(entityName, copiedData[k], dotPaths, object, false);
                 }
                 return;
             }
@@ -218,23 +309,44 @@ export class MongoDriver extends DatabaseDriver {
                 const prop = meta.properties[k];
                 let isObjectId = false;
                 if (prop.kind === ReferenceKind.SCALAR) {
-                    isObjectId = prop.type.toLowerCase() === 'objectid';
+                    isObjectId = prop.type === 'ObjectId';
                 }
                 else if (prop.kind === ReferenceKind.EMBEDDED) {
                     if (copiedData[prop.name] == null) {
                         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, false));
                     }
                     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, false);
                     }
                 }
+                else if (prop.polymorphic && prop.fieldNames?.length >= 2) {
+                    // Polymorphic M:1: split into discriminator + FK fields
+                    const value = copiedData[k];
+                    delete copiedData[k];
+                    if (value instanceof PolymorphicRef) {
+                        copiedData[prop.fieldNames[0]] = value.discriminator;
+                        const idField = prop.fieldNames[1];
+                        const targetMeta = this.metadata.find(prop.discriminatorMap[value.discriminator]);
+                        const hasObjectId = targetMeta && targetMeta.properties[targetMeta.primaryKeys[0]]?.type === 'ObjectId';
+                        copiedData[idField] = hasObjectId ? this.convertObjectIds(value.id) : value.id;
+                    }
+                    else if (Array.isArray(value)) {
+                        // Tuple format: [discriminator, id]
+                        copiedData[prop.fieldNames[0]] = value[0];
+                        copiedData[prop.fieldNames[1]] = value[1] != null ? this.convertObjectIds(value[1]) : value[1];
+                    }
+                    else if (value == null) {
+                        prop.fieldNames.forEach(f => (copiedData[f] = null));
+                    }
+                    return;
+                }
                 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.toLowerCase() === 'objectid';
+                    isObjectId = pk.type === 'ObjectId';
                 }
                 if (isObjectId) {
                     copiedData[k] = this.convertObjectIds(copiedData[k]);
@@ -253,7 +365,7 @@ export class MongoDriver extends DatabaseDriver {
         if (data instanceof ObjectId) {
             return data;
         }
-        if (Utils.isString(data) && data.match(/^[0-9a-f]{24}$/i)) {
+        if (typeof data === 'string' && /^[0-9a-f]{24}$/i.exec(data)) {
             return new ObjectId(data);
         }
         if (Array.isArray(data)) {
@@ -268,21 +380,18 @@ export class MongoDriver extends DatabaseDriver {
     }
     buildFilterById(entityName, id) {
         const meta = this.metadata.find(entityName);
-        if (meta.properties[meta.primaryKeys[0]].type.toLowerCase() === 'objectid') {
+        if (meta.properties[meta.primaryKeys[0]].type === 'ObjectId') {
             return { _id: new ObjectId(id) };
         }
         return { _id: id };
     }
     buildFields(entityName, populate, fields, exclude) {
-        const meta = this.metadata.find(entityName);
-        if (!meta) {
-            return fields;
-        }
-        const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
+        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) {
             for (let field of fields) {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (Utils.isPlainObject(field)) {
                     continue;
                 }
@@ -290,7 +399,7 @@ export class MongoDriver extends DatabaseDriver {
                     field = field.toString().substring(0, field.toString().indexOf('.'));
                 }
                 let prop = meta.properties[field];
-                /* v8 ignore start */
+                /* v8 ignore next */
                 if (prop) {
                     if (!prop.fieldNames) {
                         continue;
@@ -305,7 +414,6 @@ export class MongoDriver extends DatabaseDriver {
                 else {
                     ret.push(field);
                 }
-                /* v8 ignore stop */
             }
             ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
         }
@@ -328,4 +436,8 @@ export class MongoDriver extends DatabaseDriver {
             data[versionProperty.name] ??= update ? { $inc: 1 } : 1;
         }
     }
+    /** @inheritDoc */
+    getORMClass() {
+        return MongoMikroORM;
+    }
 }

package/MongoEntityManager.d.ts

@@ -1,4 +1,4 @@
-import { EntityManager, type EntityName, type EntityRepository, type GetRepository, type TransactionOptions } from '@mikro-orm/core';
+import { EntityManager, type EntityName, type EntityRepository, type GetRepository, type TransactionOptions, type StreamOptions, type Loaded } from '@mikro-orm/core';
 import type { Collection, Document, TransactionOptions as MongoTransactionOptions } from 'mongodb';
 import type { MongoDriver } from './MongoDriver.js';
 import type { MongoEntityRepository } from './MongoEntityRepository.js';
@@ -9,8 +9,16 @@ 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[]>;
-    getCollection<T extends Document>(entityName: EntityName<T>): Collection<T>;
+    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, pipeline: any[]): AsyncIterableIterator<T>;
+    /**
+     * @inheritDoc
+     */
+    stream<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+    getCollection<T extends Document>(entityOrCollectionName: EntityName<T> | string): Collection<T>;
     /**
      * @inheritDoc
      */

package/MongoEntityManager.js

@@ -1,4 +1,4 @@
-import { EntityManager, Utils } from '@mikro-orm/core';
+import { EntityManager, Utils, } from '@mikro-orm/core';
 /**
  * @inheritDoc
  */
@@ -7,11 +7,25 @@ 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);
+        return this.getDriver().aggregate(entityName, pipeline, this.getTransactionContext());
     }
-    getCollection(entityName) {
-        return this.getConnection().getCollection(entityName);
+    /**
+     * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
+     */
+    async *streamAggregate(entityName, pipeline) {
+        yield* this.getDriver().streamAggregate(entityName, pipeline, this.getTransactionContext());
+    }
+    /**
+     * @inheritDoc
+     */
+    async *stream(entityName, options = {}) {
+        if (!Utils.isEmpty(options.populate)) {
+            throw new Error('Populate option is not supported when streaming results in MongoDB');
+        }
+        yield* super.stream(entityName, options);
+    }
+    getCollection(entityOrCollectionName) {
+        return this.getConnection().getCollection(entityOrCollectionName);
     }
     /**
      * @inheritDoc

package/MongoExceptionConverter.d.ts

@@ -1,7 +1,7 @@
 import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
 export declare class MongoExceptionConverter extends ExceptionConverter {
     /**
-     * @link https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
+     * @see https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
      */
     convertException(exception: Error & Dictionary): DriverException;
 }

package/MongoExceptionConverter.js

@@ -1,9 +1,9 @@
-import { UniqueConstraintViolationException, ExceptionConverter, TableExistsException } from '@mikro-orm/core';
-/* v8 ignore start */
+import { UniqueConstraintViolationException, ExceptionConverter, TableExistsException, } from '@mikro-orm/core';
 export class MongoExceptionConverter extends ExceptionConverter {
     /**
-     * @link https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
+     * @see https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
      */
+    /* v8 ignore next */
     convertException(exception) {
         switch (exception.code) {
             case 48:
@@ -14,4 +14,3 @@ export class MongoExceptionConverter extends ExceptionConverter {
         return super.convertException(exception);
     }
 }
-/* v8 ignore stop */

package/MongoMikroORM.d.ts

@@ -1,19 +1,22 @@
-import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType, type IMigrator } from '@mikro-orm/core';
 import { MongoDriver } from './MongoDriver.js';
 import type { MongoEntityManager } from './MongoEntityManager.js';
+export type MongoOptions<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Options<MongoDriver, EM, Entities>;
+export declare function defineMongoConfig<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: MongoOptions<EM, Entities>): Options<MongoDriver, EM, Entities>;
 /**
  * @inheritDoc
  */
-export declare class MongoMikroORM<EM extends EntityManager = MongoEntityManager> extends MikroORM<MongoDriver, EM> {
-    private static DRIVER;
+export declare class MongoMikroORM<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MongoDriver, EM, Entities> {
     /**
      * @inheritDoc
      */
-    static init<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    static init<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * @inheritDoc
      */
-    static initSync<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    constructor(options: Options<MongoDriver, EM, Entities>);
+    /**
+     * Gets the Migrator.
+     */
+    get migrator(): IMigrator;
 }
-export type MongoOptions = Options<MongoDriver>;
-export declare function defineMongoConfig(options: MongoOptions): Options<MongoDriver, MongoEntityManager<MongoDriver> & EntityManager<IDatabaseDriver<import("@mikro-orm/core").Connection>>>;

package/MongoMikroORM.js

@@ -1,24 +1,30 @@
 import { defineConfig, MikroORM, } from '@mikro-orm/core';
 import { MongoDriver } from './MongoDriver.js';
+export function defineMongoConfig(options) {
+    return defineConfig({ driver: MongoDriver, ...options });
+}
 /**
  * @inheritDoc
  */
 export class MongoMikroORM extends MikroORM {
-    static DRIVER = MongoDriver;
     /**
      * @inheritDoc
      */
     static async init(options) {
-        return super.init(options);
+        return super.init(defineMongoConfig(options));
     }
     /**
      * @inheritDoc
      */
-    static initSync(options) {
-        return super.initSync(options);
+    constructor(options) {
+        super(defineMongoConfig(options));
+    }
+    /**
+     * Gets the Migrator.
+     */
+    get migrator() {
+        return this.driver
+            .getPlatform()
+            .getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations-mongodb', this.em);
     }
-}
-/* v8 ignore next 3 */
-export function defineMongoConfig(options) {
-    return defineConfig({ driver: MongoDriver, ...options });
 }

package/MongoPlatform.d.ts

@@ -1,5 +1,5 @@
 import { ObjectId } from 'mongodb';
-import { Platform, type IPrimaryKey, type Primary, type NamingStrategy, type Constructor, type EntityRepository, type EntityProperty, type PopulateOptions, type EntityMetadata, type IDatabaseDriver, type EntityManager, type Configuration, type MikroORM } from '@mikro-orm/core';
+import { Platform, type IPrimaryKey, type Primary, type NamingStrategy, type Constructor, type EntityRepository, type EntityProperty, type PopulateOptions, type EntityMetadata, type IDatabaseDriver, type EntityManager, type Configuration, type MikroORM, type TransformContext } from '@mikro-orm/core';
 import { MongoExceptionConverter } from './MongoExceptionConverter.js';
 import { MongoSchemaGenerator } from './MongoSchemaGenerator.js';
 export declare class MongoPlatform extends Platform {
@@ -16,12 +16,10 @@ export declare class MongoPlatform extends Platform {
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): MongoSchemaGenerator;
     normalizePrimaryKey<T extends number | string = number | string>(data: Primary<T> | IPrimaryKey | ObjectId): T;
     denormalizePrimaryKey(data: number | string): IPrimaryKey;
-    getSerializedPrimaryKeyField(field: string): string;
-    usesDifferentSerializedPrimaryKey(): boolean;
     usesImplicitTransactions(): boolean;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown): unknown;
-    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
+    convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     marshallArray(values: string[]): string;
     cloneEmbeddable<T>(data: T): T;
     shouldHaveColumn<T>(prop: EntityProperty<T>, populate: PopulateOptions<T>[], exclude?: string[]): boolean;

package/MongoPlatform.js

@@ -32,24 +32,18 @@ export class MongoPlatform extends Platform {
         /* v8 ignore next */
         return super.getExtension(extensionName, extensionKey, moduleName, em);
     }
-    /* v8 ignore next 3: kept for type inference only */
+    /* v8 ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
         return new MongoSchemaGenerator(em ?? driver);
     }
     normalizePrimaryKey(data) {
-        if (Utils.isObjectID(data)) {
+        if (Utils.isObject(data) && data.constructor?.name === 'ObjectId') {
             return data.toHexString();
         }
         return data;
     }
     denormalizePrimaryKey(data) {
-        return new ObjectId(data);
-    }
-    getSerializedPrimaryKeyField(field) {
-        return 'id';
-    }
-    usesDifferentSerializedPrimaryKey() {
-        return true;
+        return new ObjectId('' + data);
     }
     usesImplicitTransactions() {
         return false;
@@ -60,7 +54,7 @@ export class MongoPlatform extends Platform {
     convertJsonToDatabaseValue(value) {
         return Utils.copy(value);
     }
-    convertJsonToJSValue(value, prop) {
+    convertJsonToJSValue(value, context) {
         return value;
     }
     marshallArray(values) {
@@ -78,6 +72,9 @@ export class MongoPlatform extends Platform {
         return prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner;
     }
     validateMetadata(meta) {
+        if (meta.inheritanceType === 'tpt') {
+            throw MetadataError.tptNotSupportedByDriver(meta);
+        }
         const pk = meta.getPrimaryProps()[0];
         if (pk && pk.fieldNames?.[0] !== '_id') {
             throw MetadataError.invalidPrimaryKey(meta, pk, '_id');

package/MongoSchemaGenerator.d.ts

@@ -1,14 +1,15 @@
-import { AbstractSchemaGenerator, type CreateSchemaOptions, type MikroORM } from '@mikro-orm/core';
+import { type CreateSchemaOptions, type MikroORM } from '@mikro-orm/core';
+import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import type { MongoDriver } from './MongoDriver.js';
 export declare class MongoSchemaGenerator extends AbstractSchemaGenerator<MongoDriver> {
     static register(orm: MikroORM): void;
-    createSchema(options?: MongoCreateSchemaOptions): Promise<void>;
-    dropSchema(options?: {
+    create(options?: MongoCreateSchemaOptions): Promise<void>;
+    drop(options?: {
         dropMigrationsTable?: boolean;
     }): Promise<void>;
-    updateSchema(options?: MongoCreateSchemaOptions): Promise<void>;
+    update(options?: MongoCreateSchemaOptions): Promise<void>;
     ensureDatabase(): Promise<boolean>;
-    refreshDatabase(options?: MongoCreateSchemaOptions): Promise<void>;
+    refresh(options?: MongoCreateSchemaOptions): Promise<void>;
     dropIndexes(options?: {
         skipIndexes?: {
             collection: string;
@@ -17,7 +18,9 @@ export declare class MongoSchemaGenerator extends AbstractSchemaGenerator<MongoD
         collectionsWithFailedIndexes?: string[];
     }): Promise<void>;
     ensureIndexes(options?: EnsureIndexesOptions): Promise<void>;
+    private mapIndexProperties;
     private createIndexes;
+    private executeQuery;
     private createUniqueIndexes;
     private createPropertyIndexes;
 }