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

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,53 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoConnection = void 0;
-const mongodb_1 = require("mongodb");
-const bson_1 = require("bson");
-const node_util_1 = require("node:util");
-const core_1 = require("@mikro-orm/core");
-class MongoConnection extends core_1.Connection {
-    client;
-    db;
+import { MongoClient, ObjectId, } from 'mongodb';
+import { Connection, EventType, QueryOrder, Utils, ValidationError, inspect, } from '@mikro-orm/core';
+export class MongoConnection extends Connection {
+    #client;
+    #db;
     constructor(config, options, type = 'write') {
         super(config, options, type);
         // @ts-ignore
-        bson_1.ObjectId.prototype[node_util_1.inspect.custom] = function () {
+        ObjectId.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
             return `ObjectId('${this.toHexString()}')`;
         };
         // @ts-ignore
-        Date.prototype[node_util_1.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 mongodb_1.MongoClient) {
+        if (driverOptions instanceof MongoClient) {
             this.logger.log('info', 'Reusing MongoClient provided via `driverOptions`');
-            this.client = driverOptions;
+            this.#client = driverOptions;
         }
         else {
-            this.client = new mongodb_1.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');
-            /* istanbul ignore next */
-            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;
@@ -55,8 +56,8 @@ class MongoConnection extends core_1.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"' };
         }
@@ -65,20 +66,23 @@ class MongoConnection extends core_1.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 = {};
@@ -86,36 +90,40 @@ class MongoConnection extends core_1.Connection {
         const username = this.config.get('user');
         const password = this.config.get('password');
         if (this.config.get('host')) {
-            throw new core_1.ValidationError('Mongo driver does not support `host` options, use `clientUrl` instead!');
+            throw new ValidationError('Mongo driver does not support `host` options, use `clientUrl` instead!');
         }
         if (username && password) {
             ret.auth = { username, password };
         }
-        if (pool.min) {
-            ret.minPoolSize = pool.min;
-        }
-        if (pool.max) {
-            ret.maxPoolSize = pool.max;
-        }
+        ret.minPoolSize = pool.min;
+        ret.maxPoolSize = pool.max;
+        ret.waitQueueTimeoutMS = pool.idleTimeoutMillis;
         ret.driverInfo = {
             name: 'MikroORM',
-            version: core_1.Utils.getORMVersion(),
+            version: Utils.getORMVersion(),
         };
-        return core_1.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;
+        return Utils.mergeConfig(ret, overrides);
     }
     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 } : {};
@@ -124,18 +132,17 @@ class MongoConnection extends core_1.Connection {
         }
         const resultSet = this.getCollection(collection).find(where, options);
         let query = `db.getCollection('${collection}').find(${this.logObject(where)}, ${this.logObject(options)})`;
-        orderBy = core_1.Utils.asArray(orderBy);
+        orderBy = Utils.asArray(orderBy);
         if (Array.isArray(orderBy) && orderBy.length > 0) {
             const orderByTuples = [];
             orderBy.forEach(o => {
-                core_1.Utils.keys(o).forEach(k => {
+                Utils.keys(o).forEach(k => {
                     const direction = o[k];
-                    orderByTuples.push([k.toString(), core_1.Utils.isString(direction) ? direction.toUpperCase() === core_1.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);
             }
         }
@@ -147,10 +154,7 @@ class MongoConnection extends core_1.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);
@@ -170,7 +174,7 @@ class MongoConnection extends core_1.Connection {
     async aggregate(collection, pipeline, ctx, loggerContext) {
         await this.ensureConnection();
         collection = this.getCollectionName(collection);
-        /* istanbul ignore next */
+        /* 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();
@@ -178,6 +182,16 @@ class MongoConnection extends core_1.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);
     }
@@ -201,27 +215,27 @@ class MongoConnection extends core_1.Connection {
         await this.ensureConnection();
         const { ctx, isolationLevel, eventBroadcaster, ...txOptions } = options;
         if (!ctx) {
-            await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
+            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(core_1.EventType.afterTransactionStart, session);
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, session);
         return session;
     }
     async commit(ctx, eventBroadcaster) {
         await this.ensureConnection();
-        await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionCommit, ctx);
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
         await ctx.commitTransaction();
         this.logQuery('db.commit();');
-        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionCommit, ctx);
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
     }
     async rollback(ctx, eventBroadcaster) {
         await this.ensureConnection();
-        await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionRollback, ctx);
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
         await ctx.abortTransaction();
         this.logQuery('db.rollback();');
-        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
     async runQuery(method, collection, data, where, ctx, upsert, upsertOptions, loggerContext) {
         await this.ensureConnection();
@@ -257,10 +271,10 @@ class MongoConnection extends core_1.Connection {
                 const bulk = this.getCollection(collection).initializeUnorderedBulkOp(options);
                 data.forEach((row, idx) => {
                     const id = where[idx];
-                    const cond = core_1.Utils.isPlainObject(id) ? id : { _id: id };
+                    const cond = Utils.isPlainObject(id) ? id : { _id: id };
                     const doc = this.createUpdatePayload(row, upsertOptions);
                     if (upsert) {
-                        if (core_1.Utils.isEmpty(cond)) {
+                        if (Utils.isEmpty(cond)) {
                             query += log(() => `bulk.insert(${this.logObject(row)});\n`);
                             bulk.insert(row);
                         }
@@ -299,12 +313,19 @@ class MongoConnection extends core_1.Connection {
     createUpdatePayload(row, upsertOptions) {
         const doc = { $set: row };
         const $unset = {};
-        core_1.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;
@@ -328,11 +349,14 @@ class MongoConnection extends core_1.Connection {
                 });
             }
         }
-        if (core_1.Utils.hasObjectKeys($unset)) {
+        if (Utils.hasObjectKeys($unset)) {
             doc.$unset = $unset;
-            if (!core_1.Utils.hasObjectKeys(doc.$set)) {
-                delete doc.$set;
-            }
+        }
+        if (Utils.hasObjectKeys($inc)) {
+            doc.$inc = $inc;
+        }
+        if (!Utils.hasObjectKeys(doc.$set)) {
+            delete doc.$set;
         }
         return doc;
     }
@@ -344,7 +368,7 @@ class MongoConnection extends core_1.Connection {
         };
     }
     getCollectionName(name) {
-        name = core_1.Utils.className(name);
+        name = Utils.className(name);
         const meta = this.metadata.find(name);
         return meta ? meta.collection : name;
     }
@@ -352,7 +376,6 @@ class MongoConnection extends core_1.Connection {
         if (o.session) {
             o = { ...o, session: `[ClientSession]` };
         }
-        return (0, node_util_1.inspect)(o, { depth: 5, compact: true, breakLength: 300 });
+        return inspect(o, { depth: 5, compact: true, breakLength: 300 });
     }
 }
-exports.MongoConnection = MongoConnection;

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 IDatabaseDriver, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type PopulatePath, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
-import { MongoConnection } from './MongoConnection';
-import { MongoPlatform } from './MongoPlatform';
-import { MongoEntityManager } from './MongoEntityManager';
+import { type ClientSession } from 'mongodb';
+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<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    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>;
 }