@mikro-orm/mongodb 7.0.0-dev.1 → 7.0.0-dev.100

package/MongoDriver.js

@@ -1,22 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoDriver = void 0;
-const bson_1 = require("bson");
-const core_1 = require("@mikro-orm/core");
-const MongoConnection_1 = require("./MongoConnection");
-const MongoPlatform_1 = require("./MongoPlatform");
-const MongoEntityManager_1 = require("./MongoEntityManager");
-class MongoDriver extends core_1.DatabaseDriver {
-    [core_1.EntityManagerType];
-    connection = new MongoConnection_1.MongoConnection(this.config);
-    platform = new MongoPlatform_1.MongoPlatform();
+import { ObjectId } from 'mongodb';
+import { DatabaseDriver, EntityManagerType, GroupOperator, 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);
+    platform = new MongoPlatform();
     constructor(config) {
         super(config, ['mongodb']);
     }
     createEntityManager(useContext) {
-        const EntityManagerClass = this.config.get('entityManager', MongoEntityManager_1.MongoEntityManager);
+        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;
+        }
+        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));
+        const res = this.getConnection('read').stream(entityName, where, orderBy, options.limit, options.offset, fields, options.ctx);
+        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);
@@ -27,10 +44,10 @@ class MongoDriver extends core_1.DatabaseDriver {
         const isCursorPagination = [first, last, before, after].some(v => v != null);
         if (isCursorPagination) {
             const andWhere = (cond1, cond2) => {
-                if (core_1.Utils.isEmpty(cond1)) {
+                if (Utils.isEmpty(cond1)) {
                     return cond2;
                 }
-                if (core_1.Utils.isEmpty(cond2)) {
+                if (Utils.isEmpty(cond2)) {
                     return cond1;
                 }
                 return { $and: [cond1, cond2] };
@@ -38,29 +55,29 @@ class MongoDriver extends core_1.DatabaseDriver {
             const meta = this.metadata.find(entityName);
             const { orderBy: newOrderBy, where: newWhere } = this.processCursorOptions(meta, options, options.orderBy);
             const newWhereConverted = this.renameFields(entityName, newWhere, true);
-            const orderBy = core_1.Utils.asArray(newOrderBy).map(order => this.renameFields(entityName, order, 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));
             if (isCursorPagination && !first && !!last) {
                 res.reverse();
             }
             return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
         }
-        const orderBy = core_1.Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, 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, options.limit, options.offset, fields, options.ctx));
         return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
     }
     async findOne(entityName, where, options = { populate: [], orderBy: {} }) {
         if (this.metadata.find(entityName)?.virtual) {
             const [item] = await this.findVirtual(entityName, where, options);
-            /* istanbul ignore next */
+            /* v8 ignore next */
             return item ?? null;
         }
-        if (core_1.Utils.isPrimaryKey(where)) {
+        if (Utils.isPrimaryKey(where)) {
             where = this.buildFilterById(entityName, where);
         }
         const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
         where = this.renameFields(entityName, where, true);
-        const orderBy = core_1.Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, 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));
         return this.mapResult(res[0], this.metadata.find(entityName));
     }
@@ -70,11 +87,22 @@ class MongoDriver extends core_1.DatabaseDriver {
             const em = this.createEntityManager();
             return meta.expression(em, where, options);
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
+        return super.findVirtual(entityName, where, options);
+    }
+    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 = {}, ctx) {
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (this.metadata.find(entityName)?.virtual) {
             return this.countVirtual(entityName, where, options);
         }
@@ -82,27 +110,32 @@ class MongoDriver extends core_1.DatabaseDriver {
         return this.rethrow(this.getConnection('read').countDocuments(entityName, where, ctx));
     }
     async nativeInsert(entityName, data, options = {}) {
+        this.handleVersionProperty(entityName, data);
         data = this.renameFields(entityName, data);
         return this.rethrow(this.getConnection('write').insertOne(entityName, data, options.ctx));
     }
     async nativeInsertMany(entityName, data, options = {}) {
-        data = data.map(d => this.renameFields(entityName, d));
+        data = data.map(item => {
+            this.handleVersionProperty(entityName, item);
+            return this.renameFields(entityName, item);
+        });
         const meta = this.metadata.find(entityName);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
         const res = await this.rethrow(this.getConnection('write').insertMany(entityName, data, options.ctx));
         res.rows = res.insertedIds.map(id => ({ [pk]: id }));
         return res;
     }
     async nativeUpdate(entityName, where, data, options = {}) {
-        if (core_1.Utils.isPrimaryKey(where)) {
+        if (Utils.isPrimaryKey(where)) {
             where = this.buildFilterById(entityName, where);
         }
-        where = this.renameFields(entityName, where, true);
+        this.handleVersionProperty(entityName, data, true);
         data = this.renameFields(entityName, data);
+        where = this.renameFields(entityName, where, true);
         options = { ...options };
         const meta = this.metadata.find(entityName);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const rename = (field) => meta ? (meta.properties[field]?.fieldNames[0] ?? field) : field;
         if (options.onConflictFields && Array.isArray(options.onConflictFields)) {
             options.onConflictFields = options.onConflictFields.map(rename);
@@ -117,15 +150,18 @@ class MongoDriver extends core_1.DatabaseDriver {
     }
     async nativeUpdateMany(entityName, where, data, options = {}) {
         where = where.map(row => {
-            if (core_1.Utils.isPlainObject(row)) {
+            if (Utils.isPlainObject(row)) {
                 return this.renameFields(entityName, row, true);
             }
             return row;
         });
-        data = data.map(row => this.renameFields(entityName, row));
+        data = data.map(row => {
+            this.handleVersionProperty(entityName, row, true);
+            return this.renameFields(entityName, row);
+        });
         options = { ...options };
         const meta = this.metadata.find(entityName);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const rename = (field) => meta ? (meta.properties[field]?.fieldNames[0] ?? field) : field;
         if (options.onConflictFields && Array.isArray(options.onConflictFields)) {
             options.onConflictFields = options.onConflictFields.map(rename);
@@ -136,13 +172,13 @@ class MongoDriver extends core_1.DatabaseDriver {
         if (options.onConflictExcludeFields) {
             options.onConflictExcludeFields = options.onConflictExcludeFields.map(rename);
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
         const res = await this.rethrow(this.getConnection('write').bulkUpdateMany(entityName, where, data, options.ctx, options.upsert, options));
         if (res.insertedIds) {
             let i = 0;
             res.rows = where.map(cond => {
-                if (core_1.Utils.isEmpty(cond)) {
+                if (Utils.isEmpty(cond)) {
                     return { [pk]: res.insertedIds[i++] };
                 }
                 return { [pk]: cond[pk] };
@@ -151,7 +187,7 @@ class MongoDriver extends core_1.DatabaseDriver {
         return res;
     }
     async nativeDelete(entityName, where, options = {}) {
-        if (core_1.Utils.isPrimaryKey(where)) {
+        if (Utils.isPrimaryKey(where)) {
             where = this.buildFilterById(entityName, where);
         }
         where = this.renameFields(entityName, where, true);
@@ -160,6 +196,9 @@ class MongoDriver extends core_1.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;
     }
@@ -168,7 +207,7 @@ class MongoDriver extends core_1.DatabaseDriver {
         const copiedData = Object.assign({}, data); // copy first
         const meta = this.metadata.find(entityName);
         if (meta?.serializedPrimaryKey && !meta.embeddable && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
-            core_1.Utils.renameKey(copiedData, meta.serializedPrimaryKey, meta.primaryKeys[0]);
+            Utils.renameKey(copiedData, meta.serializedPrimaryKey, meta.primaryKeys[0]);
         }
         if (meta && !meta.embeddable) {
             this.inlineEmbeddables(meta, copiedData, dotPaths);
@@ -179,7 +218,7 @@ class MongoDriver extends core_1.DatabaseDriver {
             for (let i = 0; i < copiedData.$and.length; i++) {
                 const and = copiedData.$and[i];
                 if ('$fulltext' in and) {
-                    /* istanbul ignore next */
+                    /* v8 ignore next */
                     if ('$fulltext' in copiedData) {
                         throw new Error('Cannot merge multiple $fulltext conditions to top level of the query object.');
                     }
@@ -195,12 +234,12 @@ class MongoDriver extends core_1.DatabaseDriver {
         }
         // mongo only allows the $text operator in the root of the object and will
         // search all documents where the field has a text index.
-        if (core_1.Utils.hasNestedKey(copiedData, '$fulltext')) {
+        if (Utils.hasNestedKey(copiedData, '$fulltext')) {
             throw new Error('Full text search is only supported on the top level of the query object.');
         }
-        core_1.Utils.keys(copiedData).forEach(k => {
-            if (core_1.Utils.isGroupOperator(k)) {
-                /* istanbul ignore else */
+        Utils.keys(copiedData).forEach(k => {
+            if (k in GroupOperator) {
+                /* v8 ignore next */
                 if (Array.isArray(copiedData[k])) {
                     copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v));
                 }
@@ -212,10 +251,10 @@ class MongoDriver extends core_1.DatabaseDriver {
             if (meta?.properties[k]) {
                 const prop = meta.properties[k];
                 let isObjectId = false;
-                if (prop.kind === core_1.ReferenceKind.SCALAR) {
-                    isObjectId = prop.type.toLowerCase() === 'objectid';
+                if (prop.kind === ReferenceKind.SCALAR) {
+                    isObjectId = prop.type === 'ObjectId';
                 }
-                else if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
+                else if (prop.kind === ReferenceKind.EMBEDDED) {
                     if (copiedData[prop.name] == null) {
                         return;
                     }
@@ -229,32 +268,32 @@ class MongoDriver extends core_1.DatabaseDriver {
                 else {
                     const meta2 = this.metadata.find(prop.type);
                     const pk = meta2.properties[meta2.primaryKeys[0]];
-                    isObjectId = pk.type.toLowerCase() === 'objectid';
+                    isObjectId = pk.type === 'ObjectId';
                 }
                 if (isObjectId) {
                     copiedData[k] = this.convertObjectIds(copiedData[k]);
                 }
                 if (prop.fieldNames) {
-                    core_1.Utils.renameKey(copiedData, k, prop.fieldNames[0]);
+                    Utils.renameKey(copiedData, k, prop.fieldNames[0]);
                 }
             }
-            if (core_1.Utils.isPlainObject(copiedData[k]) && '$re' in copiedData[k]) {
+            if (Utils.isPlainObject(copiedData[k]) && '$re' in copiedData[k]) {
                 copiedData[k] = new RegExp(copiedData[k].$re);
             }
         });
         return copiedData;
     }
     convertObjectIds(data) {
-        if (data instanceof bson_1.ObjectId) {
+        if (data instanceof ObjectId) {
             return data;
         }
-        if (core_1.Utils.isString(data) && data.match(/^[0-9a-f]{24}$/i)) {
-            return new bson_1.ObjectId(data);
+        if (typeof data === 'string' && data.match(/^[0-9a-f]{24}$/i)) {
+            return new ObjectId(data);
         }
         if (Array.isArray(data)) {
             return data.map((item) => this.convertObjectIds(item));
         }
-        if (core_1.Utils.isObject(data)) {
+        if (Utils.isObject(data)) {
             Object.keys(data).forEach(k => {
                 data[k] = this.convertObjectIds(data[k]);
             });
@@ -263,8 +302,8 @@ class MongoDriver extends core_1.DatabaseDriver {
     }
     buildFilterById(entityName, id) {
         const meta = this.metadata.find(entityName);
-        if (meta.properties[meta.primaryKeys[0]].type.toLowerCase() === 'objectid') {
-            return { _id: new bson_1.ObjectId(id) };
+        if (meta.properties[meta.primaryKeys[0]].type === 'ObjectId') {
+            return { _id: new ObjectId(id) };
         }
         return { _id: id };
     }
@@ -273,19 +312,19 @@ class MongoDriver extends core_1.DatabaseDriver {
         if (!meta) {
             return fields;
         }
-        const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
+        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) {
-                /* istanbul ignore next */
-                if (core_1.Utils.isPlainObject(field)) {
+                /* v8 ignore next */
+                if (Utils.isPlainObject(field)) {
                     continue;
                 }
                 if (field.toString().includes('.')) {
                     field = field.toString().substring(0, field.toString().indexOf('.'));
                 }
                 let prop = meta.properties[field];
-                /* istanbul ignore else */
+                /* v8 ignore next */
                 if (prop) {
                     if (!prop.fieldNames) {
                         continue;
@@ -295,7 +334,7 @@ class MongoDriver extends core_1.DatabaseDriver {
                 }
                 else if (field === '*') {
                     const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate));
-                    ret.push(...core_1.Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
+                    ret.push(...Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
                 }
                 else {
                     ret.push(field);
@@ -303,11 +342,27 @@ class MongoDriver extends core_1.DatabaseDriver {
             }
             ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
         }
-        else if (!core_1.Utils.isEmpty(exclude) || lazyProps.some(p => !p.formula)) {
+        else if (!Utils.isEmpty(exclude) || lazyProps.some(p => !p.formula)) {
             const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, exclude));
-            ret.push(...core_1.Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
+            ret.push(...Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
         }
         return ret.length > 0 ? ret : undefined;
     }
+    handleVersionProperty(entityName, data, update = false) {
+        const meta = this.metadata.find(entityName);
+        if (!meta?.versionProperty) {
+            return;
+        }
+        const versionProperty = meta.properties[meta.versionProperty];
+        if (versionProperty.runtimeType === 'Date') {
+            data[versionProperty.name] ??= new Date();
+        }
+        else {
+            data[versionProperty.name] ??= update ? { $inc: 1 } : 1;
+        }
+    }
+    /** @inheritDoc */
+    getORMClass() {
+        return MongoMikroORM;
+    }
 }
-exports.MongoDriver = MongoDriver;

package/MongoEntityManager.d.ts

@@ -1,7 +1,7 @@
-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 NoInfer, type Loaded } from '@mikro-orm/core';
 import type { Collection, Document, TransactionOptions as MongoTransactionOptions } from 'mongodb';
-import type { MongoDriver } from './MongoDriver';
-import type { MongoEntityRepository } from './MongoEntityRepository';
+import type { MongoDriver } from './MongoDriver.js';
+import type { MongoEntityRepository } from './MongoEntityRepository.js';
 /**
  * @inheritDoc
  */
@@ -10,6 +10,14 @@ 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[]>;
+    /**
+     * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
+     */
+    streamAggregate<T extends object>(entityName: EntityName<any>, 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>(entityName: EntityName<T>): Collection<T>;
     /**
      * @inheritDoc

package/MongoEntityManager.js

@@ -1,17 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoEntityManager = void 0;
-const core_1 = require("@mikro-orm/core");
+import { EntityManager, Utils, } from '@mikro-orm/core';
 /**
  * @inheritDoc
  */
-class MongoEntityManager extends core_1.EntityManager {
+export class MongoEntityManager extends EntityManager {
     /**
      * Shortcut to driver's aggregate method. Available in MongoDriver only.
      */
     async aggregate(entityName, pipeline) {
-        entityName = core_1.Utils.className(entityName);
-        return this.getDriver().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());
+    }
+    /**
+     * @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(entityName) {
         return this.getConnection().getCollection(entityName);
@@ -35,4 +48,3 @@ class MongoEntityManager extends core_1.EntityManager {
         return super.transactional(cb, options);
     }
 }
-exports.MongoEntityManager = MongoEntityManager;

package/MongoEntityRepository.d.ts

@@ -1,6 +1,6 @@
 import { EntityRepository, type EntityName } from '@mikro-orm/core';
 import type { Collection } from 'mongodb';
-import type { MongoEntityManager } from './MongoEntityManager';
+import type { MongoEntityManager } from './MongoEntityManager.js';
 export declare class MongoEntityRepository<T extends object> extends EntityRepository<T> {
     protected readonly em: MongoEntityManager;
     constructor(em: MongoEntityManager, entityName: EntityName<T>);

package/MongoEntityRepository.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoEntityRepository = void 0;
-const core_1 = require("@mikro-orm/core");
-class MongoEntityRepository extends core_1.EntityRepository {
+import { EntityRepository } from '@mikro-orm/core';
+export class MongoEntityRepository extends EntityRepository {
     em;
     constructor(em, entityName) {
         super(em, entityName);
@@ -24,4 +21,3 @@ class MongoEntityRepository extends core_1.EntityRepository {
         return this.em;
     }
 }
-exports.MongoEntityRepository = MongoEntityRepository;

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,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoExceptionConverter = void 0;
-const core_1 = require("@mikro-orm/core");
-class MongoExceptionConverter extends core_1.ExceptionConverter {
-    /* istanbul ignore next */
+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:
-                return new core_1.TableExistsException(exception);
+                return new TableExistsException(exception);
             case 11000:
-                return new core_1.UniqueConstraintViolationException(exception);
+                return new UniqueConstraintViolationException(exception);
         }
         return super.convertException(exception);
     }
 }
-exports.MongoExceptionConverter = MongoExceptionConverter;

package/MongoMikroORM.d.ts

@@ -1,19 +1,22 @@
-import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
-import { MongoDriver } from './MongoDriver';
-import type { MongoEntityManager } from './MongoEntityManager';
+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,29 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoMikroORM = void 0;
-exports.defineMongoConfig = defineMongoConfig;
-const core_1 = require("@mikro-orm/core");
-const MongoDriver_1 = require("./MongoDriver");
+import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { MongoDriver } from './MongoDriver.js';
+export function defineMongoConfig(options) {
+    return defineConfig({ driver: MongoDriver, ...options });
+}
 /**
  * @inheritDoc
  */
-class MongoMikroORM extends core_1.MikroORM {
-    static DRIVER = MongoDriver_1.MongoDriver;
+export class MongoMikroORM extends MikroORM {
     /**
      * @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);
     }
-}
-exports.MongoMikroORM = MongoMikroORM;
-/* istanbul ignore next */
-function defineMongoConfig(options) {
-    return (0, core_1.defineConfig)({ driver: MongoDriver_1.MongoDriver, ...options });
 }

package/MongoPlatform.d.ts

@@ -1,7 +1,7 @@
-import { ObjectId } from 'bson';
-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 { MongoExceptionConverter } from './MongoExceptionConverter';
-import { MongoSchemaGenerator } from './MongoSchemaGenerator';
+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, type TransformContext } from '@mikro-orm/core';
+import { MongoExceptionConverter } from './MongoExceptionConverter.js';
+import { MongoSchemaGenerator } from './MongoSchemaGenerator.js';
 export declare class MongoPlatform extends Platform {
     protected readonly exceptionConverter: MongoExceptionConverter;
     setConfig(config: Configuration): void;
@@ -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;