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

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>>>;