@mikro-orm/mongodb 7.0.0-dev.11 → 7.0.0-dev.110

package/MongoConnection.d.ts

@@ -1,10 +1,12 @@
-import { MongoClient, type ClientSession, type Collection, type Db, type MongoClientOptions, type TransactionOptions } from 'mongodb';
-import { Connection, type AnyEntity, type Configuration, type ConnectionOptions, type ConnectionType, type EntityData, type EntityName, type FilterQuery, type IsolationLevel, type QueryOrderMap, type QueryResult, type Transaction, type TransactionEventBroadcaster, type UpsertOptions, type UpsertManyOptions, type LoggingOptions } from '@mikro-orm/core';
+import { type ClientSession, type Collection, type Db, MongoClient, type MongoClientOptions, type TransactionOptions } from 'mongodb';
+import { type AnyEntity, type Configuration, Connection, type ConnectionOptions, type ConnectionType, type EntityData, type EntityName, type FilterQuery, type IsolationLevel, type LoggingOptions, type QueryOrderMap, type QueryResult, type Transaction, type TransactionEventBroadcaster, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 export declare class MongoConnection extends Connection {
-    protected client: MongoClient;
-    protected db: Db;
+    #private;
     constructor(config: Configuration, options?: ConnectionOptions, type?: ConnectionType);
-    connect(): Promise<void>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
+    createClient(): void;
     close(force?: boolean): Promise<void>;
     isConnected(): Promise<boolean>;
     checkConnection(): Promise<{
@@ -20,16 +22,18 @@ export declare class MongoConnection extends Connection {
     listCollections(): Promise<string[]>;
     dropCollection(name: EntityName<AnyEntity>): Promise<boolean>;
     mapOptions(overrides: MongoClientOptions): MongoClientOptions;
-    getClientUrl(): string;
     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>;
+    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>;
     transactional<T>(cb: (trx: Transaction<ClientSession>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;

package/MongoConnection.js

@@ -1,49 +1,54 @@
-import { ObjectId, MongoClient, } from 'mongodb';
-import { inspect } from 'node:util';
-import { Connection, EventType, QueryOrder, Utils, ValidationError, } from '@mikro-orm/core';
+import { MongoClient, ObjectId, } from 'mongodb';
+import { Connection, EventType, QueryOrder, Utils, ValidationError, inspect, } from '@mikro-orm/core';
 export class MongoConnection extends Connection {
-    client;
-    db;
+    #client;
+    #db;
     constructor(config, options, type = 'write') {
         super(config, options, type);
         // @ts-ignore
-        ObjectId.prototype[inspect.custom] = function () {
+        ObjectId.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
             return `ObjectId('${this.toHexString()}')`;
         };
         // @ts-ignore
-        Date.prototype[inspect.custom] = function () {
+        Date.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
             return `ISODate('${this.toISOString()}')`;
         };
     }
-    async connect() {
+    async connect(options) {
+        this.getClient();
+        this.connected = true;
+        if (options?.skipOnConnect !== true) {
+            await this.onConnect();
+        }
+    }
+    createClient() {
         let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
         if (typeof driverOptions === 'function') {
-            driverOptions = await driverOptions();
+            driverOptions = driverOptions();
         }
         if (driverOptions instanceof MongoClient) {
             this.logger.log('info', 'Reusing MongoClient provided via `driverOptions`');
-            this.client = driverOptions;
+            this.#client = driverOptions;
         }
         else {
-            this.client = new MongoClient(this.config.getClientUrl(), this.mapOptions(driverOptions));
-            await this.client.connect();
+            this.#client = new MongoClient(this.config.get('clientUrl'), this.mapOptions(driverOptions));
             const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
-            /* v8 ignore next 3 */
-            this.client.on('connectionCreated', () => {
-                void onCreateConnection?.(this.client);
+            /* v8 ignore next */
+            this.#client.on('connectionCreated', () => {
+                void onCreateConnection?.(this.#client);
             });
         }
-        this.db = this.client.db(this.config.get('dbName'));
-        this.connected = true;
+        this.#db = this.#client.db(this.config.get('dbName'));
     }
     async close(force) {
-        await this.client?.close(!!force);
+        await this.#client?.close(force);
         this.connected = false;
+        this.#client = undefined;
     }
     async isConnected() {
         try {
-            const res = await this.db?.command({ ping: 1 });
-            return this.connected = !!res.ok;
+            const res = await this.#db?.command({ ping: 1 });
+            return this.connected = !!res?.ok;
         }
         catch (error) {
             return this.connected = false;
@@ -51,8 +56,8 @@ export class MongoConnection extends Connection {
     }
     async checkConnection() {
         try {
-            const res = await this.db?.command({ ping: 1 });
-            return res.ok
+            const res = await this.#db?.command({ ping: 1 });
+            return res?.ok
                 ? { ok: true }
                 : { ok: false, reason: 'Ping reply does not feature "ok" property, or it evaluates to "false"' };
         }
@@ -61,20 +66,23 @@ export class MongoConnection extends Connection {
         }
     }
     getClient() {
-        return this.client;
+        if (!this.#client) {
+            this.createClient();
+        }
+        return this.#client;
     }
     getCollection(name) {
-        return this.db.collection(this.getCollectionName(name));
+        return this.getDb().collection(this.getCollectionName(name));
     }
     async createCollection(name) {
-        return this.db.createCollection(this.getCollectionName(name));
+        return this.getDb().createCollection(this.getCollectionName(name));
     }
     async listCollections() {
-        const collections = await this.db.listCollections({}, { nameOnly: true }).toArray();
+        const collections = await this.getDb().listCollections({}, { nameOnly: true }).toArray();
         return collections.map(c => c.name);
     }
     async dropCollection(name) {
-        return this.db.dropCollection(this.getCollectionName(name));
+        return this.getDb().dropCollection(this.getCollectionName(name));
     }
     mapOptions(overrides) {
         const ret = {};
@@ -96,19 +104,26 @@ export class MongoConnection extends Connection {
         };
         return Utils.mergeConfig(ret, overrides);
     }
-    getClientUrl() {
-        const options = this.mapOptions(this.options.driverOptions ?? {});
-        const clientUrl = this.config.getClientUrl(true);
-        const match = clientUrl.match(/^(\w+):\/\/((.*@.+)|.+)$/);
-        return match ? `${match[1]}://${options.auth ? options.auth.username + ':*****@' : ''}${match[2]}` : clientUrl;
-    }
     getDb() {
-        return this.db;
+        this.#db ??= this.getClient().db(this.config.get('dbName'));
+        return this.#db;
     }
     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);
+        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);
+        this.logQuery(`${query}.toArray();`, loggerContext);
+        yield* cursor;
+    }
+    async _find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
         await this.ensureConnection();
         collection = this.getCollectionName(collection);
         const options = ctx ? { session: ctx } : {};
@@ -123,12 +138,11 @@ export class MongoConnection extends Connection {
             orderBy.forEach(o => {
                 Utils.keys(o).forEach(k => {
                     const direction = o[k];
-                    orderByTuples.push([k.toString(), Utils.isString(direction) ? direction.toUpperCase() === QueryOrder.ASC ? 1 : -1 : direction]);
+                    orderByTuples.push([k.toString(), typeof direction === 'string' ? direction.toUpperCase() === QueryOrder.ASC ? 1 : -1 : direction]);
                 });
             });
             if (orderByTuples.length > 0) {
                 query += `.sort(${this.logObject(orderByTuples)})`;
-                // @ts-expect-error ??
                 resultSet.sort(orderByTuples);
             }
         }
@@ -140,10 +154,7 @@ export class MongoConnection extends Connection {
             query += `.skip(${offset})`;
             resultSet.skip(offset);
         }
-        const now = Date.now();
-        const res = await resultSet.toArray();
-        this.logQuery(`${query}.toArray();`, { took: Date.now() - now, results: res.length, ...loggerContext });
-        return res;
+        return { cursor: resultSet, query };
     }
     async insertOne(collection, data, ctx) {
         return this.runQuery('insertOne', collection, data, undefined, ctx);
@@ -171,6 +182,16 @@ export class MongoConnection extends Connection {
         this.logQuery(query, { took: Date.now() - now, results: res.length, ...loggerContext });
         return res;
     }
+    async *streamAggregate(collection, pipeline, ctx, loggerContext, stream = false) {
+        await this.ensureConnection();
+        collection = this.getCollectionName(collection);
+        /* 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);
+        this.logQuery(query, { ...loggerContext });
+        yield* cursor;
+    }
     async countDocuments(collection, where, ctx) {
         return this.runQuery('countDocuments', collection, undefined, where, ctx);
     }
@@ -196,7 +217,7 @@ export class MongoConnection extends Connection {
         if (!ctx) {
             await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
         }
-        const session = ctx || this.client.startSession();
+        const session = ctx || this.getClient().startSession();
         session.startTransaction(txOptions);
         this.logQuery('db.begin();');
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, session);
@@ -292,12 +313,19 @@ export class MongoConnection extends Connection {
     createUpdatePayload(row, upsertOptions) {
         const doc = { $set: row };
         const $unset = {};
-        Utils.keys(row)
-            .filter(k => typeof row[k] === 'undefined')
-            .forEach(k => {
-            $unset[k] = '';
-            delete row[k];
-        });
+        const $inc = {};
+        for (const k of Utils.keys(row)) {
+            const item = row[k];
+            if (typeof item === 'undefined') {
+                $unset[k] = '';
+                delete row[k];
+                continue;
+            }
+            if (Utils.isPlainObject(item) && '$inc' in item) {
+                $inc[k] = item.$inc;
+                delete row[k];
+            }
+        }
         if (upsertOptions) {
             if (upsertOptions.onConflictAction === 'ignore') {
                 doc.$setOnInsert = doc.$set;
@@ -323,9 +351,12 @@ export class MongoConnection extends Connection {
         }
         if (Utils.hasObjectKeys($unset)) {
             doc.$unset = $unset;
-            if (!Utils.hasObjectKeys(doc.$set)) {
-                delete doc.$set;
-            }
+        }
+        if (Utils.hasObjectKeys($inc)) {
+            doc.$inc = $inc;
+        }
+        if (!Utils.hasObjectKeys(doc.$set)) {
+            delete doc.$set;
         }
         return doc;
     }

package/MongoDriver.d.ts

@@ -1,17 +1,22 @@
 import { type ClientSession } from 'mongodb';
-import { type Configuration, type CountOptions, DatabaseDriver, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type FilterQuery, type FindOneOptions, type FindOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type PopulatePath, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type Configuration, type Constructor, type CountOptions, DatabaseDriver, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityName, type FilterQuery, type FindOneOptions, type FindOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type PopulatePath, type QueryResult, type StreamOptions, type Transaction, type UpsertManyOptions, type UpsertOptions } 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 declare class MongoDriver extends DatabaseDriver<MongoConnection> {
     [EntityManagerType]: MongoEntityManager<this>;
     protected readonly connection: MongoConnection;
     protected readonly platform: MongoPlatform;
     constructor(config: Configuration);
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
+    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>[]>;
+    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>>;
@@ -21,9 +26,13 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
         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>;
     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;
+    private handleVersionProperty;
+    /** @inheritDoc */
+    getORMClass(): Constructor<MongoMikroORM>;
 }

package/MongoDriver.js

@@ -1,8 +1,9 @@
 import { ObjectId } from 'mongodb';
-import { DatabaseDriver, EntityManagerType, ReferenceKind, Utils, } from '@mikro-orm/core';
+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);
@@ -14,6 +15,25 @@ 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;
+        }
+        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);
@@ -70,8 +90,19 @@ export class MongoDriver extends DatabaseDriver {
         /* 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) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (this.metadata.find(entityName)?.virtual) {
             return this.countVirtual(entityName, where, options);
         }
@@ -79,11 +110,15 @@ export class MongoDriver extends 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);
         /* v8 ignore next */
         const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
@@ -95,8 +130,9 @@ export class MongoDriver extends DatabaseDriver {
         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);
         /* v8 ignore next */
@@ -119,7 +155,10 @@ export class MongoDriver extends DatabaseDriver {
             }
             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);
         /* v8 ignore next */
@@ -157,6 +196,9 @@ 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;
     }
@@ -176,7 +218,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.');
                     }
@@ -196,8 +238,8 @@ 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 (k in GroupOperator) {
+                /* v8 ignore next */
                 if (Array.isArray(copiedData[k])) {
                     copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v));
                 }
@@ -210,7 +252,7 @@ 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) {
@@ -226,7 +268,7 @@ export class MongoDriver extends 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]);
@@ -245,7 +287,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' && data.match(/^[0-9a-f]{24}$/i)) {
             return new ObjectId(data);
         }
         if (Array.isArray(data)) {
@@ -260,7 +302,7 @@ 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 };
@@ -270,11 +312,11 @@ export class MongoDriver extends 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) {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (Utils.isPlainObject(field)) {
                     continue;
                 }
@@ -282,7 +324,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;
@@ -297,7 +339,6 @@ export class MongoDriver extends DatabaseDriver {
                 else {
                     ret.push(field);
                 }
-                /* v8 ignore stop */
             }
             ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
         }
@@ -307,4 +348,21 @@ export class MongoDriver extends DatabaseDriver {
         }
         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;
+    }
 }

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 NoInfer, 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';
@@ -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,4 +1,4 @@
-import { EntityManager, Utils } from '@mikro-orm/core';
+import { EntityManager, Utils, } from '@mikro-orm/core';
 /**
  * @inheritDoc
  */
@@ -8,7 +8,23 @@ export class MongoEntityManager extends EntityManager {
      */
     async aggregate(entityName, pipeline) {
         entityName = Utils.className(entityName);
-        return this.getDriver().aggregate(entityName, pipeline);
+        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);

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 */
 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,28 @@
 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) {

package/MongoSchemaGenerator.d.ts

@@ -2,13 +2,13 @@ import { AbstractSchemaGenerator, type CreateSchemaOptions, type MikroORM } from
 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 +17,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;
 }

package/MongoSchemaGenerator.js

@@ -1,14 +1,14 @@
-import { AbstractSchemaGenerator, Utils, } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, Utils, inspect, } from '@mikro-orm/core';
 export class MongoSchemaGenerator extends AbstractSchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new MongoSchemaGenerator(orm.em));
     }
-    async createSchema(options = {}) {
+    async create(options = {}) {
         await this.connection.ensureConnection();
         options.ensureIndexes ??= true;
         const existing = await this.connection.listCollections();
         const metadata = this.getOrderedMetadata();
-        /* v8 ignore start */
+        /* v8 ignore next */
         const promises = metadata
             .filter(meta => !existing.includes(meta.collection))
             .map(meta => this.connection.createCollection(meta.collection).catch(err => {
@@ -18,13 +18,12 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
                 throw err;
             }
         }));
-        /* v8 ignore stop */
         if (options.ensureIndexes) {
             await this.ensureIndexes({ ensureCollections: false });
         }
         await Promise.all(promises);
     }
-    async dropSchema(options = {}) {
+    async drop(options = {}) {
         await this.connection.ensureConnection();
         const existing = await this.connection.listCollections();
         const metadata = this.getOrderedMetadata();
@@ -36,16 +35,16 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             .map(meta => this.connection.dropCollection(meta.collection));
         await Promise.all(promises);
     }
-    async updateSchema(options = {}) {
-        await this.createSchema(options);
+    async update(options = {}) {
+        await this.create(options);
     }
     async ensureDatabase() {
         return false;
     }
-    async refreshDatabase(options = {}) {
+    async refresh(options = {}) {
         await this.ensureDatabase();
-        await this.dropSchema();
-        await this.createSchema(options);
+        await this.drop();
+        await this.create(options);
     }
     async dropIndexes(options) {
         await this.connection.ensureConnection();
@@ -59,9 +58,9 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             const indexes = await db.collection(collection.name).listIndexes().toArray();
             for (const index of indexes) {
                 const isIdIndex = index.key._id === 1 && Utils.getObjectKeysSize(index.key) === 1;
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (!isIdIndex && !options?.skipIndexes?.find(idx => idx.collection === collection.name && idx.indexName === index.name)) {
-                    promises.push(db.collection(collection.name).dropIndex(index.name));
+                    promises.push(this.executeQuery(db.collection(collection.name), 'dropIndex', index.name));
                 }
             }
         }
@@ -72,7 +71,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         options.ensureCollections ??= true;
         options.retryLimit ??= 3;
         if (options.ensureCollections) {
-            await this.createSchema({ ensureIndexes: false });
+            await this.create({ ensureIndexes: false });
         }
         const promises = [];
         for (const meta of this.getOrderedMetadata()) {
@@ -113,11 +112,21 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             });
         }
     }
+    mapIndexProperties(index, meta) {
+        return Utils.flatten(Utils.asArray(index.properties).map(propName => {
+            const rootPropName = propName.split('.')[0];
+            const prop = meta.properties[rootPropName];
+            if (propName.includes('.')) {
+                return [prop.fieldNames[0] + propName.substring(propName.indexOf('.'))];
+            }
+            return prop?.fieldNames ?? propName;
+        }));
+    }
     createIndexes(meta) {
         const res = [];
         meta.indexes.forEach(index => {
             let fieldOrSpec;
-            const properties = Utils.flatten(Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+            const properties = this.mapIndexProperties(index, meta);
             const collection = this.connection.getCollection(meta.className);
             if (Array.isArray(index.options) && index.options.length === 2 && properties.length === 0) {
                 res.push([collection.collectionName, collection.createIndex(index.options[0], index.options[1])]);
@@ -138,7 +147,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             else {
                 fieldOrSpec = properties.reduce((o, i) => { o[i] = 1; return o; }, {});
             }
-            res.push([collection.collectionName, collection.createIndex(fieldOrSpec, {
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: index.name,
                     unique: false,
                     ...index.options,
@@ -146,13 +155,26 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         });
         return res;
     }
+    async executeQuery(collection, method, ...args) {
+        const now = Date.now();
+        return collection[method](...args).then((res) => {
+            Utils.dropUndefinedProperties(args);
+            const query = `db.getCollection('${collection.collectionName}').${method}(${args.map(arg => inspect(arg)).join(', ')});`;
+            this.config.getLogger().logQuery({
+                level: 'info',
+                query,
+                took: Date.now() - now,
+            });
+            return res;
+        });
+    }
     createUniqueIndexes(meta) {
         const res = [];
         meta.uniques.forEach(index => {
-            const properties = Utils.flatten(Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+            const properties = this.mapIndexProperties(index, meta);
             const fieldOrSpec = properties.reduce((o, i) => { o[i] = 1; return o; }, {});
             const collection = this.connection.getCollection(meta.className);
-            res.push([collection.collectionName, collection.createIndex(fieldOrSpec, {
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: index.name,
                     unique: true,
                     ...index.options,
@@ -168,8 +190,8 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         const fieldOrSpec = prop.embeddedPath
             ? prop.embeddedPath.join('.')
             : prop.fieldNames.reduce((o, i) => { o[i] = 1; return o; }, {});
-        return [[collection.collectionName, collection.createIndex(fieldOrSpec, {
-                    name: (Utils.isString(prop[type]) ? prop[type] : undefined),
+        return [[collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
+                    name: typeof prop[type] === 'string' ? prop[type] : undefined,
                     unique: type === 'unique',
                     sparse: prop.nullable === true,
                 })]];

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/index.d.ts

@@ -8,4 +8,4 @@ export * from './MongoEntityRepository.js';
 export * from './MongoSchemaGenerator.js';
 export { MongoEntityManager as EntityManager } from './MongoEntityManager.js';
 export { MongoEntityRepository as EntityRepository } from './MongoEntityRepository.js';
-export { MongoMikroORM as MikroORM, MongoOptions as Options, defineMongoConfig as defineConfig, } from './MongoMikroORM.js';
+export { MongoMikroORM as MikroORM, type MongoOptions as Options, defineMongoConfig as defineConfig, } from './MongoMikroORM.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/mongodb",
   "type": "module",
-  "version": "7.0.0-dev.11",
+  "version": "7.0.0-dev.110",
   "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",
@@ -38,7 +38,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "node": ">= 22.17.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy",
@@ -50,12 +50,12 @@
     "access": "public"
   },
   "dependencies": {
-    "mongodb": "6.15.0"
+    "mongodb": "7.0.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.13"
+    "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.11"
+    "@mikro-orm/core": "7.0.0-dev.110"
   }
 }