@mikro-orm/mongodb 7.0.5 → 7.0.6-dev.1

package/MongoConnection.js

@@ -1,433 +1,428 @@
-import { MongoClient, ObjectId } from 'mongodb';
-import { Connection, EventType, inspect, QueryOrder, Utils, ValidationError } from '@mikro-orm/core';
+import { MongoClient, ObjectId, } from 'mongodb';
+import { Connection, EventType, inspect, QueryOrder, Utils, ValidationError, } from '@mikro-orm/core';
 /** MongoDB database connection using the official `mongodb` driver. */
 export class MongoConnection extends Connection {
-  #client;
-  #db;
-  constructor(config, options, type = 'write') {
-    super(config, options, type);
-    // @ts-ignore
-    ObjectId.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
-      return `ObjectId('${this.toHexString()}')`;
-    };
-    // @ts-ignore
-    Date.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
-      return `ISODate('${this.toISOString()}')`;
-    };
-  }
-  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 = driverOptions();
-    }
-    if (driverOptions instanceof MongoClient) {
-      this.logger.log('info', 'Reusing MongoClient provided via `driverOptions`');
-      this.#client = driverOptions;
-    } else {
-      this.#client = new MongoClient(this.config.get('clientUrl'), this.mapOptions(driverOptions));
-      this.#client.appendMetadata({
-        name: 'MikroORM',
-        version: Utils.getORMVersion(),
-      });
-      const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
-      /* v8 ignore next */
-      this.#client.on('connectionCreated', () => {
-        void onCreateConnection?.(this.#client);
-      });
-    }
-    this.#db = this.#client.db(this.config.get('dbName'));
-  }
-  async 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);
-    } catch (error) {
-      return (this.connected = false);
-    }
-  }
-  async checkConnection() {
-    try {
-      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"' };
-    } catch (error) {
-      return { ok: false, reason: error.message, error };
-    }
-  }
-  getClient() {
-    if (!this.#client) {
-      this.createClient();
-    }
-    return this.#client;
-  }
-  getCollection(name) {
-    return this.getDb().collection(this.getCollectionName(name));
-  }
-  async createCollection(name) {
-    return this.getDb().createCollection(this.getCollectionName(name));
-  }
-  async listCollections() {
-    const collections = await this.getDb().listCollections({}, { nameOnly: true }).toArray();
-    return collections.map(c => c.name);
-  }
-  async dropCollection(name) {
-    return this.getDb().dropCollection(this.getCollectionName(name));
-  }
-  mapOptions(overrides) {
-    const ret = {};
-    const pool = this.config.get('pool');
-    const username = this.config.get('user');
-    const password = this.config.get('password');
-    if (this.config.get('host')) {
-      throw new ValidationError('Mongo driver does not support `host` options, use `clientUrl` instead!');
-    }
-    if (username && password) {
-      ret.auth = { username, password };
-    }
-    ret.minPoolSize = pool.min;
-    ret.maxPoolSize = pool.max;
-    ret.waitQueueTimeoutMS = pool.idleTimeoutMillis;
-    return Utils.mergeConfig(ret, overrides);
-  }
-  getDb() {
-    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(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();
-    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(entityName).find(where, options);
-    let query = `db.getCollection('${collection}').find(${this.logObject(where)}, ${this.logObject(options)})`;
-    const orderBy = Utils.asArray(opts.orderBy);
-    if (orderBy.length > 0) {
-      const orderByTuples = [];
-      orderBy.forEach(o => {
-        Utils.keys(o).forEach(k => {
-          const direction = o[k];
-          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)})`;
-        resultSet.sort(orderByTuples);
-      }
-    }
-    if (opts.limit !== undefined) {
-      query += `.limit(${opts.limit})`;
-      resultSet.limit(opts.limit);
-    }
-    if (opts.offset !== undefined) {
-      query += `.skip(${opts.offset})`;
-      resultSet.skip(opts.offset);
-    }
-    return { cursor: resultSet, query };
-  }
-  async insertOne(entityName, data, ctx) {
-    return this.runQuery('insertOne', entityName, data, undefined, ctx);
-  }
-  async insertMany(entityName, data, ctx) {
-    return this.runQuery('insertMany', entityName, data, undefined, ctx);
-  }
-  async updateMany(entityName, where, data, ctx, upsert, upsertOptions) {
-    return this.runQuery('updateMany', entityName, 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(entityName, where, ctx) {
-    return this.runQuery('deleteMany', entityName, undefined, where, ctx);
-  }
-  async aggregate(entityName, pipeline, ctx, loggerContext) {
-    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)}).toArray();`;
-    const now = Date.now();
-    const res = await this.getCollection(entityName).aggregate(pipeline, options).toArray();
-    this.logQuery(query, { took: Date.now() - now, results: res.length, ...loggerContext });
-    return res;
-  }
-  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();
-    const session = await this.begin(options);
-    try {
-      const ret = await cb(session);
-      await this.commit(session, options.eventBroadcaster);
-      return ret;
-    } catch (error) {
-      await this.rollback(session, options.eventBroadcaster);
-      throw error;
-    } finally {
-      await session.endSession();
-    }
-  }
-  async begin(options = {}) {
-    await this.ensureConnection();
-    const { ctx, isolationLevel, eventBroadcaster, ...txOptions } = options;
-    if (!ctx) {
-      await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
-    }
-    const session = ctx || this.getClient().startSession();
-    session.startTransaction(txOptions);
-    this.logQuery('db.begin();');
-    await eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, session);
-    return session;
-  }
-  async commit(ctx, eventBroadcaster) {
-    await this.ensureConnection();
-    await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
-    await ctx.commitTransaction();
-    this.logQuery('db.commit();');
-    await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
-  }
-  async rollback(ctx, eventBroadcaster) {
-    await this.ensureConnection();
-    await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
-    await ctx.abortTransaction();
-    this.logQuery('db.rollback();');
-    await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
-  }
-  async runQuery(method, entityName, data, where, ctx, opts) {
-    await this.ensureConnection();
-    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) {
-      delete options.upsert;
-    }
-    const now = Date.now();
-    let res;
-    let query;
-    const log = msg => (logger.isEnabled('query') ? msg() : '');
-    switch (method) {
-      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(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(entityName).insertMany(data, options), query);
-        break;
-      case 'updateMany': {
-        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(entityName).updateMany(where, payload, options), query);
-        break;
-      }
-      case 'bulkUpdateMany': {
-        query = log(
-          () => `bulk = db.getCollection('${collection}').initializeUnorderedBulkOp(${this.logObject(options)});\n`,
-        );
-        const bulk = this.getCollection(entityName).initializeUnorderedBulkOp(options);
-        data.forEach((row, idx) => {
-          const id = where[idx];
-          const cond = Utils.isPlainObject(id) ? id : { _id: id };
-          const doc = this.createUpdatePayload(row, upsertOptions);
-          if (upsert) {
-            if (Utils.isEmpty(cond)) {
-              query += log(() => `bulk.insert(${this.logObject(row)});\n`);
-              bulk.insert(row);
-            } else {
-              query += log(() => `bulk.find(${this.logObject(cond)}).upsert().update(${this.logObject(doc)});\n`);
-              bulk.find(cond).upsert().update(doc);
+    #client;
+    #db;
+    constructor(config, options, type = 'write') {
+        super(config, options, type);
+        // @ts-ignore
+        ObjectId.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
+            return `ObjectId('${this.toHexString()}')`;
+        };
+        // @ts-ignore
+        Date.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
+            return `ISODate('${this.toISOString()}')`;
+        };
+    }
+    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 = driverOptions();
+        }
+        if (driverOptions instanceof MongoClient) {
+            this.logger.log('info', 'Reusing MongoClient provided via `driverOptions`');
+            this.#client = driverOptions;
+        }
+        else {
+            this.#client = new MongoClient(this.config.get('clientUrl'), this.mapOptions(driverOptions));
+            this.#client.appendMetadata({
+                name: 'MikroORM',
+                version: Utils.getORMVersion(),
+            });
+            const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
+            /* v8 ignore next */
+            this.#client.on('connectionCreated', () => {
+                void onCreateConnection?.(this.#client);
+            });
+        }
+        this.#db = this.#client.db(this.config.get('dbName'));
+    }
+    async 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);
+        }
+        catch (error) {
+            return (this.connected = false);
+        }
+    }
+    async checkConnection() {
+        try {
+            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"' };
+        }
+        catch (error) {
+            return { ok: false, reason: error.message, error };
+        }
+    }
+    getClient() {
+        if (!this.#client) {
+            this.createClient();
+        }
+        return this.#client;
+    }
+    getCollection(name) {
+        return this.getDb().collection(this.getCollectionName(name));
+    }
+    async createCollection(name) {
+        return this.getDb().createCollection(this.getCollectionName(name));
+    }
+    async listCollections() {
+        const collections = await this.getDb().listCollections({}, { nameOnly: true }).toArray();
+        return collections.map(c => c.name);
+    }
+    async dropCollection(name) {
+        return this.getDb().dropCollection(this.getCollectionName(name));
+    }
+    mapOptions(overrides) {
+        const ret = {};
+        const pool = this.config.get('pool');
+        const username = this.config.get('user');
+        const password = this.config.get('password');
+        if (this.config.get('host')) {
+            throw new ValidationError('Mongo driver does not support `host` options, use `clientUrl` instead!');
+        }
+        if (username && password) {
+            ret.auth = { username, password };
+        }
+        ret.minPoolSize = pool.min;
+        ret.maxPoolSize = pool.max;
+        ret.waitQueueTimeoutMS = pool.idleTimeoutMillis;
+        return Utils.mergeConfig(ret, overrides);
+    }
+    getDb() {
+        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(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();
+        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(entityName).find(where, options);
+        let query = `db.getCollection('${collection}').find(${this.logObject(where)}, ${this.logObject(options)})`;
+        const orderBy = Utils.asArray(opts.orderBy);
+        if (orderBy.length > 0) {
+            const orderByTuples = [];
+            orderBy.forEach(o => {
+                Utils.keys(o).forEach(k => {
+                    const direction = o[k];
+                    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)})`;
+                resultSet.sort(orderByTuples);
             }
-            return;
-          }
-          query += log(() => `bulk.find(${this.logObject(cond)}).update(${this.logObject(doc)});\n`);
-          bulk.find(cond).update(doc);
+        }
+        if (opts.limit !== undefined) {
+            query += `.limit(${opts.limit})`;
+            resultSet.limit(opts.limit);
+        }
+        if (opts.offset !== undefined) {
+            query += `.skip(${opts.offset})`;
+            resultSet.skip(opts.offset);
+        }
+        return { cursor: resultSet, query };
+    }
+    async insertOne(entityName, data, ctx) {
+        return this.runQuery('insertOne', entityName, data, undefined, ctx);
+    }
+    async insertMany(entityName, data, ctx) {
+        return this.runQuery('insertMany', entityName, data, undefined, ctx);
+    }
+    async updateMany(entityName, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery('updateMany', entityName, 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(entityName, where, ctx) {
+        return this.runQuery('deleteMany', entityName, undefined, where, ctx);
+    }
+    async aggregate(entityName, pipeline, ctx, loggerContext) {
+        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)}).toArray();`;
+        const now = Date.now();
+        const res = await this.getCollection(entityName).aggregate(pipeline, options).toArray();
+        this.logQuery(query, { took: Date.now() - now, results: res.length, ...loggerContext });
+        return res;
+    }
+    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,
         });
-        query += log(() => `bulk.execute()`);
-        res = await this.rethrow(bulk.execute(), query);
-        break;
-      }
-      case 'deleteMany':
-      case 'countDocuments':
+    }
+    async transactional(cb, options = {}) {
+        await this.ensureConnection();
+        const session = await this.begin(options);
+        try {
+            const ret = await cb(session);
+            await this.commit(session, options.eventBroadcaster);
+            return ret;
+        }
+        catch (error) {
+            await this.rollback(session, options.eventBroadcaster);
+            throw error;
+        }
+        finally {
+            await session.endSession();
+        }
+    }
+    async begin(options = {}) {
+        await this.ensureConnection();
+        const { ctx, isolationLevel, eventBroadcaster, ...txOptions } = options;
+        if (!ctx) {
+            await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
+        }
+        const session = ctx || this.getClient().startSession();
+        session.startTransaction(txOptions);
+        this.logQuery('db.begin();');
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, session);
+        return session;
+    }
+    async commit(ctx, eventBroadcaster) {
+        await this.ensureConnection();
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
+        await ctx.commitTransaction();
+        this.logQuery('db.commit();');
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
+    }
+    async rollback(ctx, eventBroadcaster) {
+        await this.ensureConnection();
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
+        await ctx.abortTransaction();
+        this.logQuery('db.rollback();');
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
+    }
+    async runQuery(method, entityName, data, where, ctx, opts) {
+        await this.ensureConnection();
+        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) {
+            delete options.upsert;
+        }
+        const now = Date.now();
+        let res;
+        let query;
+        const log = (msg) => (logger.isEnabled('query') ? msg() : '');
+        switch (method) {
+            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(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(entityName).insertMany(data, options), query);
+                break;
+            case 'updateMany': {
+                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(entityName).updateMany(where, payload, options), query));
+                break;
+            }
+            case 'bulkUpdateMany': {
+                query = log(() => `bulk = db.getCollection('${collection}').initializeUnorderedBulkOp(${this.logObject(options)});\n`);
+                const bulk = this.getCollection(entityName).initializeUnorderedBulkOp(options);
+                data.forEach((row, idx) => {
+                    const id = where[idx];
+                    const cond = Utils.isPlainObject(id) ? id : { _id: id };
+                    const doc = this.createUpdatePayload(row, upsertOptions);
+                    if (upsert) {
+                        if (Utils.isEmpty(cond)) {
+                            query += log(() => `bulk.insert(${this.logObject(row)});\n`);
+                            bulk.insert(row);
+                        }
+                        else {
+                            query += log(() => `bulk.find(${this.logObject(cond)}).upsert().update(${this.logObject(doc)});\n`);
+                            bulk.find(cond).upsert().update(doc);
+                        }
+                        return;
+                    }
+                    query += log(() => `bulk.find(${this.logObject(cond)}).update(${this.logObject(doc)});\n`);
+                    bulk.find(cond).update(doc);
+                });
+                query += log(() => `bulk.execute()`);
+                res = await this.rethrow(bulk.execute(), query);
+                break;
+            }
+            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(entityName)[method](where, options), query);
+                break;
+        }
+        this.logQuery(query, { took: Date.now() - now, ...loggerContext });
         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(entityName)[method](where, options), query);
-        break;
-    }
-    this.logQuery(query, { took: Date.now() - now, ...loggerContext });
-    if (method === 'countDocuments') {
-      return res;
-    }
-    return this.transformResult(res);
-  }
-  rethrow(promise, query) {
-    return promise.catch(e => {
-      this.logQuery(query, { level: 'error' });
-      e.message += '\nQuery: ' + query;
-      throw e;
-    });
-  }
-  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)) {
-      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;
-        delete doc.$set;
-      }
-      if (upsertOptions.onConflictMergeFields) {
-        doc.$setOnInsert = {};
-        upsertOptions.onConflictMergeFields.forEach(f => {
-          doc.$setOnInsert[f] = doc.$set[f];
-          delete doc.$set[f];
+            return res;
+        }
+        return this.transformResult(res);
+    }
+    rethrow(promise, query) {
+        return promise.catch(e => {
+            this.logQuery(query, { level: 'error' });
+            e.message += '\nQuery: ' + query;
+            throw e;
         });
-        const { $set, $setOnInsert } = doc;
-        doc.$set = $setOnInsert;
-        doc.$setOnInsert = $set;
-      } else if (upsertOptions.onConflictExcludeFields) {
-        doc.$setOnInsert = {};
-        upsertOptions.onConflictExcludeFields.forEach(f => {
-          doc.$setOnInsert[f] = doc.$set[f];
-          delete doc.$set[f];
+    }
+    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];
+            }
         });
-      }
-    }
-    if (Utils.hasObjectKeys($unset)) {
-      doc.$unset = $unset;
-    }
-    if (Utils.hasObjectKeys($inc)) {
-      doc.$inc = $inc;
-    }
-    if (!Utils.hasObjectKeys(doc.$set)) {
-      delete doc.$set;
-    }
-    return doc;
-  }
-  transformResult(res) {
-    return {
-      affectedRows: res.modifiedCount || res.deletedCount || res.insertedCount || 0,
-      insertId: res.insertedId ?? res.insertedIds?.[0],
-      insertedIds: res.insertedIds ? Object.values(res.insertedIds) : undefined,
-    };
-  }
-  getCollectionName(entityName) {
-    const meta = this.metadata.find(entityName);
-    return meta ? meta.collection : Utils.className(entityName);
-  }
-  logObject(o) {
-    if (o?.session) {
-      o = { ...o, session: `[ClientSession]` };
-    }
-    return inspect(o, { depth: 5, compact: true, breakLength: 300 });
-  }
+        const $unset = {};
+        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;
+                delete doc.$set;
+            }
+            if (upsertOptions.onConflictMergeFields) {
+                doc.$setOnInsert = {};
+                upsertOptions.onConflictMergeFields.forEach(f => {
+                    doc.$setOnInsert[f] = doc.$set[f];
+                    delete doc.$set[f];
+                });
+                const { $set, $setOnInsert } = doc;
+                doc.$set = $setOnInsert;
+                doc.$setOnInsert = $set;
+            }
+            else if (upsertOptions.onConflictExcludeFields) {
+                doc.$setOnInsert = {};
+                upsertOptions.onConflictExcludeFields.forEach(f => {
+                    doc.$setOnInsert[f] = doc.$set[f];
+                    delete doc.$set[f];
+                });
+            }
+        }
+        if (Utils.hasObjectKeys($unset)) {
+            doc.$unset = $unset;
+        }
+        if (Utils.hasObjectKeys($inc)) {
+            doc.$inc = $inc;
+        }
+        if (!Utils.hasObjectKeys(doc.$set)) {
+            delete doc.$set;
+        }
+        return doc;
+    }
+    transformResult(res) {
+        return {
+            affectedRows: res.modifiedCount || res.deletedCount || res.insertedCount || 0,
+            insertId: res.insertedId ?? res.insertedIds?.[0],
+            insertedIds: res.insertedIds ? Object.values(res.insertedIds) : undefined,
+        };
+    }
+    getCollectionName(entityName) {
+        const meta = this.metadata.find(entityName);
+        return meta ? meta.collection : Utils.className(entityName);
+    }
+    logObject(o) {
+        if (o?.session) {
+            o = { ...o, session: `[ClientSession]` };
+        }
+        return inspect(o, { depth: 5, compact: true, breakLength: 300 });
+    }
 }