@mikro-orm/mongodb 7.0.0-dev.29 → 7.0.0-dev.291

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 CollationOptions, type Configuration, Connection, type ConnectionOptions, type ConnectionType, type Dictionary, 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<{
@@ -15,22 +17,24 @@ export declare class MongoConnection extends Connection {
         error?: Error;
     }>;
     getClient(): MongoClient;
-    getCollection<T extends object>(name: EntityName<T>): Collection<T>;
+    getCollection<T extends object>(name: EntityName<T> | string): Collection<T>;
     createCollection<T extends object>(name: EntityName<T>): Promise<Collection<T>>;
     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>[]>;
-    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[]>;
-    countDocuments<T extends object>(collection: string, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<number>;
+    find<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, opts?: MongoFindOptions<T>): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, opts?: MongoFindOptions<T>): AsyncIterableIterator<T>;
+    private _find;
+    insertOne<T extends object>(entityName: EntityName<T>, data: Partial<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
+    insertMany<T extends object>(entityName: EntityName<T>, data: Partial<T>[], ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
+    updateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertOptions<T>): Promise<QueryResult<T>>;
+    bulkUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: Partial<T>[], ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    deleteMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
+    aggregate<T extends object = any>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<T[]>;
+    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, stream?: boolean): AsyncIterableIterator<T>;
+    countDocuments<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, opts?: MongoCountOptions): Promise<number>;
     transactional<T>(cb: (trx: Transaction<ClientSession>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         ctx?: Transaction<ClientSession>;
@@ -50,3 +54,21 @@ export declare class MongoConnection extends Connection {
     private getCollectionName;
     private logObject;
 }
+export interface MongoQueryOptions {
+    collation?: CollationOptions;
+    indexHint?: string | Dictionary;
+    maxTimeMS?: number;
+    allowDiskUse?: boolean;
+}
+export interface MongoFindOptions<T extends object> extends MongoQueryOptions {
+    orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[];
+    limit?: number;
+    offset?: number;
+    fields?: string[];
+    ctx?: Transaction<ClientSession>;
+    loggerContext?: LoggingOptions;
+}
+export interface MongoCountOptions extends Omit<MongoQueryOptions, 'allowDiskUse'> {
+    ctx?: Transaction<ClientSession>;
+    loggerContext?: LoggingOptions;
+}

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, inspect, QueryOrder, Utils, ValidationError, } 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,83 +104,118 @@ 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) {
+    async find(entityName, where, opts = {}) {
+        const { cursor, query } = await this._find(entityName, where, opts);
+        const now = Date.now();
+        const res = await cursor.toArray();
+        this.logQuery(`${query}.toArray();`, { took: Date.now() - now, results: res.length, ...opts.loggerContext });
+        return res;
+    }
+    async *stream(entityName, where, opts = {}) {
+        const { cursor, query } = await this._find(entityName, where, opts);
+        this.logQuery(`${query}.toArray();`, opts.loggerContext);
+        yield* cursor;
+    }
+    async _find(entityName, where, opts = {}) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
-        const options = ctx ? { session: ctx } : {};
-        if (fields) {
-            options.projection = fields.reduce((o, k) => Object.assign(o, { [k]: 1 }), {});
+        const collection = this.getCollectionName(entityName);
+        const options = opts.ctx ? { session: opts.ctx } : {};
+        if (opts.fields) {
+            options.projection = opts.fields.reduce((o, k) => Object.assign(o, { [k]: 1 }), {});
+        }
+        if (opts.collation) {
+            options.collation = opts.collation;
+        }
+        if (opts.indexHint != null) {
+            options.hint = opts.indexHint;
+        }
+        if (opts.maxTimeMS != null) {
+            options.maxTimeMS = opts.maxTimeMS;
+        }
+        if (opts.allowDiskUse != null) {
+            options.allowDiskUse = opts.allowDiskUse;
         }
-        const resultSet = this.getCollection(collection).find(where, options);
+        const resultSet = this.getCollection(entityName).find(where, options);
         let query = `db.getCollection('${collection}').find(${this.logObject(where)}, ${this.logObject(options)})`;
-        orderBy = Utils.asArray(orderBy);
-        if (Array.isArray(orderBy) && orderBy.length > 0) {
+        const orderBy = Utils.asArray(opts.orderBy);
+        if (orderBy.length > 0) {
             const orderByTuples = [];
             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]);
+                    if (typeof direction === 'string') {
+                        orderByTuples.push([k.toString(), direction.toUpperCase() === QueryOrder.ASC ? 1 : -1]);
+                    }
+                    else {
+                        orderByTuples.push([k.toString(), direction]);
+                    }
                 });
             });
             if (orderByTuples.length > 0) {
                 query += `.sort(${this.logObject(orderByTuples)})`;
-                // @ts-expect-error ??
                 resultSet.sort(orderByTuples);
             }
         }
-        if (limit !== undefined) {
-            query += `.limit(${limit})`;
-            resultSet.limit(limit);
+        if (opts.limit !== undefined) {
+            query += `.limit(${opts.limit})`;
+            resultSet.limit(opts.limit);
         }
-        if (offset !== undefined) {
-            query += `.skip(${offset})`;
-            resultSet.skip(offset);
+        if (opts.offset !== undefined) {
+            query += `.skip(${opts.offset})`;
+            resultSet.skip(opts.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);
+    async insertOne(entityName, data, ctx) {
+        return this.runQuery('insertOne', entityName, data, undefined, ctx);
     }
-    async insertMany(collection, data, ctx) {
-        return this.runQuery('insertMany', collection, data, undefined, ctx);
+    async insertMany(entityName, data, ctx) {
+        return this.runQuery('insertMany', entityName, data, undefined, ctx);
     }
-    async updateMany(collection, where, data, ctx, upsert, upsertOptions) {
-        return this.runQuery('updateMany', collection, data, where, ctx, upsert, upsertOptions);
+    async updateMany(entityName, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery('updateMany', entityName, data, where, ctx, { upsert, upsertOptions });
     }
-    async bulkUpdateMany(collection, where, data, ctx, upsert, upsertOptions) {
-        return this.runQuery('bulkUpdateMany', collection, data, where, ctx, upsert, upsertOptions);
+    async bulkUpdateMany(entityName, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery('bulkUpdateMany', entityName, data, where, ctx, { upsert, upsertOptions });
     }
-    async deleteMany(collection, where, ctx) {
-        return this.runQuery('deleteMany', collection, undefined, where, ctx);
+    async deleteMany(entityName, where, ctx) {
+        return this.runQuery('deleteMany', entityName, undefined, where, ctx);
     }
-    async aggregate(collection, pipeline, ctx, loggerContext) {
+    async aggregate(entityName, pipeline, ctx, loggerContext) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
+        const collection = this.getCollectionName(entityName);
         /* v8 ignore next */
         const options = ctx ? { session: ctx } : {};
         const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)}).toArray();`;
         const now = Date.now();
-        const res = await this.getCollection(collection).aggregate(pipeline, options).toArray();
+        const res = await this.getCollection(entityName).aggregate(pipeline, options).toArray();
         this.logQuery(query, { took: Date.now() - now, results: res.length, ...loggerContext });
         return res;
     }
-    async countDocuments(collection, where, ctx) {
-        return this.runQuery('countDocuments', collection, undefined, where, ctx);
+    async *streamAggregate(entityName, pipeline, ctx, loggerContext, stream = false) {
+        await this.ensureConnection();
+        const collection = this.getCollectionName(entityName);
+        /* v8 ignore next */
+        const options = ctx ? { session: ctx } : {};
+        const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)})};`;
+        const cursor = this.getCollection(entityName).aggregate(pipeline, options);
+        this.logQuery(query, { ...loggerContext });
+        yield* cursor;
+    }
+    async countDocuments(entityName, where, opts = {}) {
+        return this.runQuery('countDocuments', entityName, undefined, where, opts.ctx, {
+            loggerContext: opts.loggerContext,
+            collation: opts.collation,
+            indexHint: opts.indexHint,
+            maxTimeMS: opts.maxTimeMS,
+        });
     }
     async transactional(cb, options = {}) {
         await this.ensureConnection();
@@ -196,7 +239,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);
@@ -216,9 +259,10 @@ export class MongoConnection extends Connection {
         this.logQuery('db.rollback();');
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
-    async runQuery(method, collection, data, where, ctx, upsert, upsertOptions, loggerContext) {
+    async runQuery(method, entityName, data, where, ctx, opts) {
         await this.ensureConnection();
-        collection = this.getCollectionName(collection);
+        const { upsert, upsertOptions, loggerContext, collation, indexHint, maxTimeMS } = opts ?? {};
+        const collection = this.getCollectionName(entityName);
         const logger = this.config.getLogger();
         const options = ctx ? { session: ctx, upsert } : { upsert };
         if (options.upsert === undefined) {
@@ -232,22 +276,22 @@ export class MongoConnection extends Connection {
             case 'insertOne':
                 Object.keys(data).filter(k => typeof data[k] === 'undefined').forEach(k => delete data[k]);
                 query = log(() => `db.getCollection('${collection}').insertOne(${this.logObject(data)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection).insertOne(data, options), query);
+                res = await this.rethrow(this.getCollection(entityName).insertOne(data, options), query);
                 break;
             case 'insertMany':
                 data.forEach(data => Object.keys(data).filter(k => typeof data[k] === 'undefined').forEach(k => delete data[k]));
                 query = log(() => `db.getCollection('${collection}').insertMany(${this.logObject(data)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection).insertMany(data, options), query);
+                res = await this.rethrow(this.getCollection(entityName).insertMany(data, options), query);
                 break;
             case 'updateMany': {
-                const payload = Object.keys(data).some(k => k.startsWith('$')) ? data : this.createUpdatePayload(data, upsertOptions);
+                const payload = Object.keys(data).every(k => k.startsWith('$')) ? data : this.createUpdatePayload(data, upsertOptions);
                 query = log(() => `db.getCollection('${collection}').updateMany(${this.logObject(where)}, ${this.logObject(payload)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection).updateMany(where, payload, options), query);
+                res = await this.rethrow(this.getCollection(entityName).updateMany(where, payload, options), query);
                 break;
             }
             case 'bulkUpdateMany': {
                 query = log(() => `bulk = db.getCollection('${collection}').initializeUnorderedBulkOp(${this.logObject(options)});\n`);
-                const bulk = this.getCollection(collection).initializeUnorderedBulkOp(options);
+                const bulk = this.getCollection(entityName).initializeUnorderedBulkOp(options);
                 data.forEach((row, idx) => {
                     const id = where[idx];
                     const cond = Utils.isPlainObject(id) ? id : { _id: id };
@@ -272,8 +316,19 @@ export class MongoConnection extends Connection {
             }
             case 'deleteMany':
             case 'countDocuments':
+                if (method === 'countDocuments') {
+                    if (collation) {
+                        options.collation = collation;
+                    }
+                    if (indexHint != null) {
+                        options.hint = indexHint;
+                    }
+                    if (maxTimeMS != null) {
+                        options.maxTimeMS = maxTimeMS;
+                    }
+                }
                 query = log(() => `db.getCollection('${collection}').${method}(${this.logObject(where)}, ${this.logObject(options)});`);
-                res = await this.rethrow(this.getCollection(collection)[method](where, options), query);
+                res = await this.rethrow(this.getCollection(entityName)[method](where, options), query);
                 break;
         }
         this.logQuery(query, { took: Date.now() - now, ...loggerContext });
@@ -290,7 +345,14 @@ export class MongoConnection extends Connection {
         });
     }
     createUpdatePayload(row, upsertOptions) {
+        row = { ...row };
         const doc = { $set: row };
+        Utils.keys(row).forEach(k => {
+            if (k.toString().startsWith('$')) {
+                doc[k] = row[k];
+                delete row[k];
+            }
+        });
         const $unset = {};
         const $inc = {};
         for (const k of Utils.keys(row)) {
@@ -346,13 +408,12 @@ export class MongoConnection extends Connection {
             insertedIds: res.insertedIds ? Object.values(res.insertedIds) : undefined,
         };
     }
-    getCollectionName(name) {
-        name = Utils.className(name);
-        const meta = this.metadata.find(name);
-        return meta ? meta.collection : name;
+    getCollectionName(entityName) {
+        const meta = this.metadata.find(entityName);
+        return meta ? meta.collection : Utils.className(entityName);
     }
     logObject(o) {
-        if (o.session) {
+        if (o?.session) {
             o = { ...o, session: `[ClientSession]` };
         }
         return inspect(o, { depth: 5, compact: true, breakLength: 300 });

package/MongoDriver.d.ts

@@ -1,30 +1,39 @@
 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];
-    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>[]>;
-    count<T extends object>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T>, ctx?: Transaction<ClientSession>): Promise<number>;
-    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: {
+    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: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    streamVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): AsyncIterableIterator<EntityData<T>>;
+    count<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T>): Promise<number>;
+    nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: {
         ctx?: Transaction<ClientSession>;
     }): Promise<QueryResult<T>>;
-    aggregate(entityName: string, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
+    aggregate(entityName: EntityName, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
+    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>): AsyncIterableIterator<T>;
     getPlatform(): MongoPlatform;
+    private buildQueryOptions;
     private renameFields;
     private convertObjectIds;
     private buildFilterById;
-    protected buildFields<T extends object, P extends string = never>(entityName: string, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;
+    protected buildFields<T extends object, P extends string = never>(entityName: EntityName<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;
     private handleVersionProperty;
+    /** @inheritDoc */
+    getORMClass(): Constructor<MongoMikroORM>;
 }