@mikro-orm/mongodb 7.0.5-dev.9 → 7.0.5

package/MongoConnection.js

@@ -1,428 +1,433 @@
-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,
+  #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]);
+          }
         });
-    }
-    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;
+      });
+      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);
             }
-            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 });
+            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') {
-            return res;
-        }
-        return this.transformResult(res);
-    }
-    rethrow(promise, query) {
-        return promise.catch(e => {
-            this.logQuery(query, { level: 'error' });
-            e.message += '\nQuery: ' + query;
-            throw e;
+          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];
         });
-    }
-    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 { $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];
         });
-        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 });
-    }
+      }
+    }
+    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 });
+  }
 }