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

package/MongoDriver.js

@@ -1,444 +1,454 @@
 import { ObjectId } from 'mongodb';
-import { DatabaseDriver, EntityManagerType, PolymorphicRef, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { DatabaseDriver, EntityManagerType, PolymorphicRef, ReferenceKind, Utils } from '@mikro-orm/core';
 import { MongoConnection } from './MongoConnection.js';
 import { MongoPlatform } from './MongoPlatform.js';
 import { MongoEntityManager } from './MongoEntityManager.js';
 import { MongoMikroORM } from './MongoMikroORM.js';
 /** Database driver for MongoDB. */
 export class MongoDriver extends DatabaseDriver {
-    [EntityManagerType];
-    connection = new MongoConnection(this.config);
-    platform = new MongoPlatform();
-    constructor(config) {
-        super(config, ['mongodb']);
-    }
-    createEntityManager(useContext) {
-        const EntityManagerClass = this.config.get('entityManager', MongoEntityManager);
-        return new EntityManagerClass(this.config, this, this.metadata, useContext);
-    }
-    async *stream(entityName, where, options) {
-        if (this.metadata.find(entityName)?.virtual) {
-            yield* this.streamVirtual(entityName, where, options);
-            return;
-        }
-        const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
-        where = this.renameFields(entityName, where, true);
-        const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
-        const res = this.getConnection('read').stream(entityName, where, {
-            orderBy,
-            limit: options.limit,
-            offset: options.offset,
-            fields,
-            ctx: options.ctx,
-            ...this.buildQueryOptions(options),
-        });
-        for await (const item of res) {
-            if (options.rawResults) {
-                yield item;
-            }
-            else {
-                yield this.mapResult(item, this.metadata.find(entityName));
-            }
-        }
+  [EntityManagerType];
+  connection = new MongoConnection(this.config);
+  platform = new MongoPlatform();
+  constructor(config) {
+    super(config, ['mongodb']);
+  }
+  createEntityManager(useContext) {
+    const EntityManagerClass = this.config.get('entityManager', MongoEntityManager);
+    return new EntityManagerClass(this.config, this, this.metadata, useContext);
+  }
+  async *stream(entityName, where, options) {
+    if (this.metadata.find(entityName)?.virtual) {
+      yield* this.streamVirtual(entityName, where, options);
+      return;
     }
-    async find(entityName, where, options = {}) {
-        if (this.metadata.find(entityName)?.virtual) {
-            return this.findVirtual(entityName, where, options);
-        }
-        const { first, last, before, after } = options;
-        const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
-        where = this.renameFields(entityName, where, true);
-        const isCursorPagination = [first, last, before, after].some(v => v != null);
-        if (isCursorPagination) {
-            const andWhere = (cond1, cond2) => {
-                if (Utils.isEmpty(cond1)) {
-                    return cond2;
-                }
-                if (Utils.isEmpty(cond2)) {
-                    return cond1;
-                }
-                return { $and: [cond1, cond2] };
-            };
-            const meta = this.metadata.find(entityName);
-            const { orderBy: newOrderBy, where: newWhere } = this.processCursorOptions(meta, options, options.orderBy);
-            const newWhereConverted = this.renameFields(entityName, newWhere, true);
-            const orderBy = Utils.asArray(newOrderBy).map(order => this.renameFields(entityName, order, true));
-            const res = await this.rethrow(this.getConnection('read').find(entityName, andWhere(where, newWhereConverted), {
-                orderBy,
-                limit: options.limit,
-                offset: options.offset,
-                fields,
-                ctx: options.ctx,
-                loggerContext: options.logging,
-                ...this.buildQueryOptions(options),
-            }));
-            if (isCursorPagination && !first && !!last) {
-                res.reverse();
-            }
-            return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
-        }
-        const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
-        const res = await this.rethrow(this.getConnection('read').find(entityName, where, {
-            orderBy,
-            limit: options.limit,
-            offset: options.offset,
-            fields,
-            ctx: options.ctx,
-            ...this.buildQueryOptions(options),
-        }));
-        return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
-    }
-    async findOne(entityName, where, options = { populate: [], orderBy: {} }) {
-        if (this.metadata.find(entityName)?.virtual) {
-            const [item] = await this.findVirtual(entityName, where, options);
-            /* v8 ignore next */
-            return item ?? null;
-        }
-        if (Utils.isPrimaryKey(where)) {
-            where = this.buildFilterById(entityName, where);
-        }
-        const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
-        where = this.renameFields(entityName, where, true);
-        const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
-        const res = await this.rethrow(this.getConnection('read').find(entityName, where, {
-            orderBy,
-            limit: 1,
-            fields,
-            ctx: options.ctx,
-            loggerContext: options.logging,
-            ...this.buildQueryOptions(options),
-        }));
-        return this.mapResult(res[0], this.metadata.find(entityName));
-    }
-    async findVirtual(entityName, where, options) {
-        const meta = this.metadata.find(entityName);
-        if (meta.expression instanceof Function) {
-            const em = this.createEntityManager();
-            return meta.expression(em, where, options);
-        }
-        /* v8 ignore next */
-        return super.findVirtual(entityName, where, options);
-    }
-    async *streamVirtual(entityName, where, options) {
-        const meta = this.metadata.find(entityName);
-        if (meta.expression instanceof Function) {
-            const em = this.createEntityManager();
-            const stream = await meta.expression(em, where, options, true);
-            yield* stream;
-            return;
-        }
-        /* v8 ignore next */
-        return super.findVirtual(entityName, where, options);
+    const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
+    where = this.renameFields(entityName, where, true);
+    const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
+    const res = this.getConnection('read').stream(entityName, where, {
+      orderBy,
+      limit: options.limit,
+      offset: options.offset,
+      fields,
+      ctx: options.ctx,
+      ...this.buildQueryOptions(options),
+    });
+    for await (const item of res) {
+      if (options.rawResults) {
+        yield item;
+      } else {
+        yield this.mapResult(item, this.metadata.find(entityName));
+      }
     }
-    async count(entityName, where, options = {}) {
-        /* v8 ignore next */
-        if (this.metadata.find(entityName)?.virtual) {
-            return this.countVirtual(entityName, where, options);
-        }
-        where = this.renameFields(entityName, where, true);
-        const queryOpts = this.buildQueryOptions(options);
-        return this.rethrow(this.getConnection('read').countDocuments(entityName, where, {
-            ctx: options.ctx,
-            loggerContext: options.logging,
-            ...queryOpts,
-        }));
-    }
-    async nativeInsert(entityName, data, options = {}) {
-        this.handleVersionProperty(entityName, data);
-        data = this.renameFields(entityName, data);
-        return this.rethrow(this.getConnection('write').insertOne(entityName, data, options.ctx));
-    }
-    async nativeInsertMany(entityName, data, options = {}) {
-        data = data.map(item => {
-            this.handleVersionProperty(entityName, item);
-            return this.renameFields(entityName, item);
-        });
-        const meta = this.metadata.find(entityName);
-        /* v8 ignore next */
-        const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
-        const res = await this.rethrow(this.getConnection('write').insertMany(entityName, data, options.ctx));
-        res.rows = res.insertedIds.map(id => ({ [pk]: id }));
-        return res;
-    }
-    async nativeUpdate(entityName, where, data, options = {}) {
-        if (Utils.isPrimaryKey(where)) {
-            where = this.buildFilterById(entityName, where);
-        }
-        this.handleVersionProperty(entityName, data, true);
-        data = this.renameFields(entityName, data);
-        where = this.renameFields(entityName, where, true);
-        options = { ...options };
-        const meta = this.metadata.find(entityName);
-        /* v8 ignore next */
-        const rename = (field) => meta ? (meta.properties[field]?.fieldNames[0] ?? field) : field;
-        if (options.onConflictFields && Array.isArray(options.onConflictFields)) {
-            options.onConflictFields = options.onConflictFields.map(rename);
-        }
-        if (options.onConflictMergeFields) {
-            options.onConflictMergeFields = options.onConflictMergeFields.map(rename);
-        }
-        if (options.onConflictExcludeFields) {
-            options.onConflictExcludeFields = options.onConflictExcludeFields.map(rename);
-        }
-        return this.rethrow(this.getConnection('write').updateMany(entityName, where, data, options.ctx, options.upsert, options));
-    }
-    async nativeUpdateMany(entityName, where, data, options = {}) {
-        where = where.map(row => {
-            if (Utils.isPlainObject(row)) {
-                return this.renameFields(entityName, row, true);
-            }
-            return row;
-        });
-        data = data.map(row => {
-            this.handleVersionProperty(entityName, row, true);
-            return this.renameFields(entityName, row);
-        });
-        options = { ...options };
-        const meta = this.metadata.find(entityName);
-        /* v8 ignore next */
-        const rename = (field) => meta ? (meta.properties[field]?.fieldNames[0] ?? field) : field;
-        if (options.onConflictFields && Array.isArray(options.onConflictFields)) {
-            options.onConflictFields = options.onConflictFields.map(rename);
-        }
-        if (options.onConflictMergeFields) {
-            options.onConflictMergeFields = options.onConflictMergeFields.map(rename);
-        }
-        if (options.onConflictExcludeFields) {
-            options.onConflictExcludeFields = options.onConflictExcludeFields.map(rename);
-        }
-        /* v8 ignore next */
-        const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
-        const res = await this.rethrow(this.getConnection('write').bulkUpdateMany(entityName, where, data, options.ctx, options.upsert, options));
-        if (res.insertedIds) {
-            let i = 0;
-            res.rows = where.map(cond => {
-                if (Utils.isEmpty(cond)) {
-                    return { [pk]: res.insertedIds[i++] };
-                }
-                return { [pk]: cond[pk] };
-            });
-        }
-        return res;
+  }
+  async find(entityName, where, options = {}) {
+    if (this.metadata.find(entityName)?.virtual) {
+      return this.findVirtual(entityName, where, options);
     }
-    async nativeDelete(entityName, where, options = {}) {
-        if (Utils.isPrimaryKey(where)) {
-            where = this.buildFilterById(entityName, where);
-        }
-        where = this.renameFields(entityName, where, true);
-        return this.rethrow(this.getConnection('write').deleteMany(entityName, where, options.ctx));
+    const { first, last, before, after } = options;
+    const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
+    where = this.renameFields(entityName, where, true);
+    const isCursorPagination = [first, last, before, after].some(v => v != null);
+    if (isCursorPagination) {
+      const andWhere = (cond1, cond2) => {
+        if (Utils.isEmpty(cond1)) {
+          return cond2;
+        }
+        if (Utils.isEmpty(cond2)) {
+          return cond1;
+        }
+        return { $and: [cond1, cond2] };
+      };
+      const meta = this.metadata.find(entityName);
+      const { orderBy: newOrderBy, where: newWhere } = this.processCursorOptions(meta, options, options.orderBy);
+      const newWhereConverted = this.renameFields(entityName, newWhere, true);
+      const orderBy = Utils.asArray(newOrderBy).map(order => this.renameFields(entityName, order, true));
+      const res = await this.rethrow(
+        this.getConnection('read').find(entityName, andWhere(where, newWhereConverted), {
+          orderBy,
+          limit: options.limit,
+          offset: options.offset,
+          fields,
+          ctx: options.ctx,
+          loggerContext: options.logging,
+          ...this.buildQueryOptions(options),
+        }),
+      );
+      if (isCursorPagination && !first && !!last) {
+        res.reverse();
+      }
+      return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
     }
-    async aggregate(entityName, pipeline, ctx) {
-        return this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, ctx));
+    const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
+    const res = await this.rethrow(
+      this.getConnection('read').find(entityName, where, {
+        orderBy,
+        limit: options.limit,
+        offset: options.offset,
+        fields,
+        ctx: options.ctx,
+        ...this.buildQueryOptions(options),
+      }),
+    );
+    return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
+  }
+  async findOne(entityName, where, options = { populate: [], orderBy: {} }) {
+    if (this.metadata.find(entityName)?.virtual) {
+      const [item] = await this.findVirtual(entityName, where, options);
+      /* v8 ignore next */
+      return item ?? null;
     }
-    async *streamAggregate(entityName, pipeline, ctx) {
-        yield* this.getConnection('read').streamAggregate(entityName, pipeline, ctx);
+    if (Utils.isPrimaryKey(where)) {
+      where = this.buildFilterById(entityName, where);
     }
-    getPlatform() {
-        return this.platform;
+    const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
+    where = this.renameFields(entityName, where, true);
+    const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy, true));
+    const res = await this.rethrow(
+      this.getConnection('read').find(entityName, where, {
+        orderBy,
+        limit: 1,
+        fields,
+        ctx: options.ctx,
+        loggerContext: options.logging,
+        ...this.buildQueryOptions(options),
+      }),
+    );
+    return this.mapResult(res[0], this.metadata.find(entityName));
+  }
+  async findVirtual(entityName, where, options) {
+    const meta = this.metadata.find(entityName);
+    if (meta.expression instanceof Function) {
+      const em = this.createEntityManager();
+      return meta.expression(em, where, options);
     }
-    buildQueryOptions(options) {
-        if (options.collation != null && typeof options.collation === 'string') {
-            throw new Error("Collation option for MongoDB must be a CollationOptions object (e.g. { locale: 'en' }). Use a string only with SQL drivers.");
-        }
-        const ret = {};
-        if (options.collation) {
-            ret.collation = options.collation;
-        }
-        if (options.indexHint != null) {
-            ret.indexHint = options.indexHint;
-        }
-        if (options.maxTimeMS != null) {
-            ret.maxTimeMS = options.maxTimeMS;
-        }
-        if (options.allowDiskUse != null) {
-            ret.allowDiskUse = options.allowDiskUse;
-        }
-        return ret;
+    /* v8 ignore next */
+    return super.findVirtual(entityName, where, options);
+  }
+  async *streamVirtual(entityName, where, options) {
+    const meta = this.metadata.find(entityName);
+    if (meta.expression instanceof Function) {
+      const em = this.createEntityManager();
+      const stream = await meta.expression(em, where, options, true);
+      yield* stream;
+      return;
     }
-    renameFields(entityName, data, dotPaths = false, object, root = true) {
-        if (data == null && root) {
-            return {};
-        }
-        if (typeof data !== 'object' || data === null) {
-            return data;
-        }
-        // copy to new variable to prevent changing the T type or doing as unknown casts
-        const copiedData = Object.assign({}, data); // copy first
-        const meta = this.metadata.find(entityName);
-        if (meta?.serializedPrimaryKey && !meta.embeddable && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
-            Utils.renameKey(copiedData, meta.serializedPrimaryKey, meta.primaryKeys[0]);
-        }
-        if (meta && !meta.embeddable) {
-            this.inlineEmbeddables(meta, copiedData, dotPaths);
-        }
-        // If we had a query with $fulltext and some filter we end up with $and with $fulltext in it.
-        // We will try to move $fulltext to top level.
-        if (copiedData.$and) {
-            for (let i = 0; i < copiedData.$and.length; i++) {
-                const and = copiedData.$and[i];
-                if ('$fulltext' in and) {
-                    /* v8 ignore next */
-                    if ('$fulltext' in copiedData) {
-                        throw new Error('Cannot merge multiple $fulltext conditions to top level of the query object.');
-                    }
-                    copiedData.$fulltext = and.$fulltext;
-                    delete and.$fulltext;
-                }
-            }
-        }
-        // move search terms from data['$fulltext'] to mongo's structure: data['$text']['search']
-        if ('$fulltext' in copiedData) {
-            copiedData.$text = { $search: copiedData.$fulltext };
-            delete copiedData.$fulltext;
-        }
-        // mongo only allows the $text operator in the root of the object and will
-        // search all documents where the field has a text index.
-        if (Utils.hasNestedKey(copiedData, '$fulltext')) {
-            throw new Error('Full text search is only supported on the top level of the query object.');
-        }
-        Utils.keys(copiedData).forEach(k => {
-            if (Utils.isOperator(k)) {
-                if (Array.isArray(copiedData[k])) {
-                    copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v, dotPaths, object, false));
-                }
-                else {
-                    copiedData[k] = this.renameFields(entityName, copiedData[k], dotPaths, object, false);
-                }
-                return;
-            }
-            if (meta?.properties[k]) {
-                const prop = meta.properties[k];
-                let isObjectId = false;
-                if (prop.kind === ReferenceKind.SCALAR) {
-                    isObjectId = prop.type === 'ObjectId';
-                }
-                else if (prop.kind === ReferenceKind.EMBEDDED) {
-                    if (copiedData[prop.name] == null) {
-                        return;
-                    }
-                    if (prop.array && Array.isArray(copiedData[prop.name])) {
-                        copiedData[prop.name] = copiedData[prop.name].map((item) => this.renameFields(prop.targetMeta.class, item, dotPaths, true, false));
-                    }
-                    else {
-                        copiedData[prop.name] = this.renameFields(prop.targetMeta.class, copiedData[prop.name], dotPaths, prop.object || object, false);
-                    }
-                }
-                else if (prop.polymorphic && prop.fieldNames?.length >= 2) {
-                    // Polymorphic M:1: split into discriminator + FK fields
-                    const value = copiedData[k];
-                    delete copiedData[k];
-                    if (value instanceof PolymorphicRef) {
-                        copiedData[prop.fieldNames[0]] = value.discriminator;
-                        const idField = prop.fieldNames[1];
-                        const targetMeta = this.metadata.find(prop.discriminatorMap[value.discriminator]);
-                        const hasObjectId = targetMeta && targetMeta.properties[targetMeta.primaryKeys[0]]?.type === 'ObjectId';
-                        copiedData[idField] = hasObjectId ? this.convertObjectIds(value.id) : value.id;
-                    }
-                    else if (Array.isArray(value)) {
-                        // Tuple format: [discriminator, id]
-                        copiedData[prop.fieldNames[0]] = value[0];
-                        copiedData[prop.fieldNames[1]] = value[1] != null ? this.convertObjectIds(value[1]) : value[1];
-                    }
-                    else if (value == null) {
-                        prop.fieldNames.forEach(f => (copiedData[f] = null));
-                    }
-                    return;
-                }
-                else {
-                    const meta2 = this.metadata.find(prop.targetMeta.class);
-                    const pk = meta2.properties[meta2.primaryKeys[0]];
-                    isObjectId = pk.type === 'ObjectId';
-                }
-                if (isObjectId) {
-                    copiedData[k] = this.convertObjectIds(copiedData[k]);
-                }
-                if (prop.fieldNames) {
-                    Utils.renameKey(copiedData, k, prop.fieldNames[0]);
-                }
-            }
-            if (Utils.isPlainObject(copiedData[k]) && '$re' in copiedData[k]) {
-                copiedData[k] = new RegExp(copiedData[k].$re);
-            }
-        });
-        return copiedData;
-    }
-    convertObjectIds(data) {
-        if (data instanceof ObjectId) {
-            return data;
-        }
-        if (typeof data === 'string' && /^[0-9a-f]{24}$/i.exec(data)) {
-            return new ObjectId(data);
-        }
-        if (Array.isArray(data)) {
-            return data.map((item) => this.convertObjectIds(item));
-        }
-        if (Utils.isObject(data)) {
-            Object.keys(data).forEach(k => {
-                data[k] = this.convertObjectIds(data[k]);
-            });
-        }
-        return data;
+    /* v8 ignore next */
+    return super.findVirtual(entityName, where, options);
+  }
+  async count(entityName, where, options = {}) {
+    /* v8 ignore next */
+    if (this.metadata.find(entityName)?.virtual) {
+      return this.countVirtual(entityName, where, options);
     }
-    buildFilterById(entityName, id) {
-        const meta = this.metadata.find(entityName);
-        if (meta.properties[meta.primaryKeys[0]].type === 'ObjectId') {
-            return { _id: new ObjectId(id) };
-        }
-        return { _id: id };
-    }
-    buildFields(entityName, populate, fields, exclude) {
-        const meta = this.metadata.get(entityName);
-        const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => this.isPopulated(meta, prop, p)));
-        const ret = [];
-        if (fields) {
-            for (let field of fields) {
-                /* v8 ignore next */
-                if (Utils.isPlainObject(field)) {
-                    continue;
-                }
-                if (field.toString().includes('.')) {
-                    field = field.toString().substring(0, field.toString().indexOf('.'));
-                }
-                let prop = meta.properties[field];
-                /* v8 ignore next */
-                if (prop) {
-                    if (!prop.fieldNames) {
-                        continue;
-                    }
-                    prop = prop.serializedPrimaryKey ? meta.getPrimaryProps()[0] : prop;
-                    ret.push(prop.fieldNames[0]);
-                }
-                else if (field === '*') {
-                    const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate));
-                    ret.push(...Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
-                }
-                else {
-                    ret.push(field);
-                }
-            }
-            ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
-        }
-        else if (!Utils.isEmpty(exclude) || lazyProps.some(p => !p.formula)) {
-            const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, exclude));
-            ret.push(...Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
-        }
-        return ret.length > 0 ? ret : undefined;
+    where = this.renameFields(entityName, where, true);
+    const queryOpts = this.buildQueryOptions(options);
+    return this.rethrow(
+      this.getConnection('read').countDocuments(entityName, where, {
+        ctx: options.ctx,
+        loggerContext: options.logging,
+        ...queryOpts,
+      }),
+    );
+  }
+  async nativeInsert(entityName, data, options = {}) {
+    this.handleVersionProperty(entityName, data);
+    data = this.renameFields(entityName, data);
+    return this.rethrow(this.getConnection('write').insertOne(entityName, data, options.ctx));
+  }
+  async nativeInsertMany(entityName, data, options = {}) {
+    data = data.map(item => {
+      this.handleVersionProperty(entityName, item);
+      return this.renameFields(entityName, item);
+    });
+    const meta = this.metadata.find(entityName);
+    /* v8 ignore next */
+    const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
+    const res = await this.rethrow(this.getConnection('write').insertMany(entityName, data, options.ctx));
+    res.rows = res.insertedIds.map(id => ({ [pk]: id }));
+    return res;
+  }
+  async nativeUpdate(entityName, where, data, options = {}) {
+    if (Utils.isPrimaryKey(where)) {
+      where = this.buildFilterById(entityName, where);
+    }
+    this.handleVersionProperty(entityName, data, true);
+    data = this.renameFields(entityName, data);
+    where = this.renameFields(entityName, where, true);
+    options = { ...options };
+    const meta = this.metadata.find(entityName);
+    /* v8 ignore next */
+    const rename = field => (meta ? (meta.properties[field]?.fieldNames[0] ?? field) : field);
+    if (options.onConflictFields && Array.isArray(options.onConflictFields)) {
+      options.onConflictFields = options.onConflictFields.map(rename);
+    }
+    if (options.onConflictMergeFields) {
+      options.onConflictMergeFields = options.onConflictMergeFields.map(rename);
+    }
+    if (options.onConflictExcludeFields) {
+      options.onConflictExcludeFields = options.onConflictExcludeFields.map(rename);
+    }
+    return this.rethrow(
+      this.getConnection('write').updateMany(entityName, where, data, options.ctx, options.upsert, options),
+    );
+  }
+  async nativeUpdateMany(entityName, where, data, options = {}) {
+    where = where.map(row => {
+      if (Utils.isPlainObject(row)) {
+        return this.renameFields(entityName, row, true);
+      }
+      return row;
+    });
+    data = data.map(row => {
+      this.handleVersionProperty(entityName, row, true);
+      return this.renameFields(entityName, row);
+    });
+    options = { ...options };
+    const meta = this.metadata.find(entityName);
+    /* v8 ignore next */
+    const rename = field => (meta ? (meta.properties[field]?.fieldNames[0] ?? field) : field);
+    if (options.onConflictFields && Array.isArray(options.onConflictFields)) {
+      options.onConflictFields = options.onConflictFields.map(rename);
+    }
+    if (options.onConflictMergeFields) {
+      options.onConflictMergeFields = options.onConflictMergeFields.map(rename);
+    }
+    if (options.onConflictExcludeFields) {
+      options.onConflictExcludeFields = options.onConflictExcludeFields.map(rename);
+    }
+    /* v8 ignore next */
+    const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? '_id';
+    const res = await this.rethrow(
+      this.getConnection('write').bulkUpdateMany(entityName, where, data, options.ctx, options.upsert, options),
+    );
+    if (res.insertedIds) {
+      let i = 0;
+      res.rows = where.map(cond => {
+        if (Utils.isEmpty(cond)) {
+          return { [pk]: res.insertedIds[i++] };
+        }
+        return { [pk]: cond[pk] };
+      });
+    }
+    return res;
+  }
+  async nativeDelete(entityName, where, options = {}) {
+    if (Utils.isPrimaryKey(where)) {
+      where = this.buildFilterById(entityName, where);
+    }
+    where = this.renameFields(entityName, where, true);
+    return this.rethrow(this.getConnection('write').deleteMany(entityName, where, options.ctx));
+  }
+  async aggregate(entityName, pipeline, ctx) {
+    return this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, ctx));
+  }
+  async *streamAggregate(entityName, pipeline, ctx) {
+    yield* this.getConnection('read').streamAggregate(entityName, pipeline, ctx);
+  }
+  getPlatform() {
+    return this.platform;
+  }
+  buildQueryOptions(options) {
+    if (options.collation != null && typeof options.collation === 'string') {
+      throw new Error(
+        "Collation option for MongoDB must be a CollationOptions object (e.g. { locale: 'en' }). Use a string only with SQL drivers.",
+      );
+    }
+    const ret = {};
+    if (options.collation) {
+      ret.collation = options.collation;
+    }
+    if (options.indexHint != null) {
+      ret.indexHint = options.indexHint;
     }
-    handleVersionProperty(entityName, data, update = false) {
-        const meta = this.metadata.find(entityName);
-        if (!meta?.versionProperty) {
+    if (options.maxTimeMS != null) {
+      ret.maxTimeMS = options.maxTimeMS;
+    }
+    if (options.allowDiskUse != null) {
+      ret.allowDiskUse = options.allowDiskUse;
+    }
+    return ret;
+  }
+  renameFields(entityName, data, dotPaths = false, object, root = true) {
+    if (data == null && root) {
+      return {};
+    }
+    if (typeof data !== 'object' || data === null) {
+      return data;
+    }
+    // copy to new variable to prevent changing the T type or doing as unknown casts
+    const copiedData = Object.assign({}, data); // copy first
+    const meta = this.metadata.find(entityName);
+    if (meta?.serializedPrimaryKey && !meta.embeddable && meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
+      Utils.renameKey(copiedData, meta.serializedPrimaryKey, meta.primaryKeys[0]);
+    }
+    if (meta && !meta.embeddable) {
+      this.inlineEmbeddables(meta, copiedData, dotPaths);
+    }
+    // If we had a query with $fulltext and some filter we end up with $and with $fulltext in it.
+    // We will try to move $fulltext to top level.
+    if (copiedData.$and) {
+      for (let i = 0; i < copiedData.$and.length; i++) {
+        const and = copiedData.$and[i];
+        if ('$fulltext' in and) {
+          /* v8 ignore next */
+          if ('$fulltext' in copiedData) {
+            throw new Error('Cannot merge multiple $fulltext conditions to top level of the query object.');
+          }
+          copiedData.$fulltext = and.$fulltext;
+          delete and.$fulltext;
+        }
+      }
+    }
+    // move search terms from data['$fulltext'] to mongo's structure: data['$text']['search']
+    if ('$fulltext' in copiedData) {
+      copiedData.$text = { $search: copiedData.$fulltext };
+      delete copiedData.$fulltext;
+    }
+    // mongo only allows the $text operator in the root of the object and will
+    // search all documents where the field has a text index.
+    if (Utils.hasNestedKey(copiedData, '$fulltext')) {
+      throw new Error('Full text search is only supported on the top level of the query object.');
+    }
+    Utils.keys(copiedData).forEach(k => {
+      if (Utils.isOperator(k)) {
+        if (Array.isArray(copiedData[k])) {
+          copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v, dotPaths, object, false));
+        } else {
+          copiedData[k] = this.renameFields(entityName, copiedData[k], dotPaths, object, false);
+        }
+        return;
+      }
+      if (meta?.properties[k]) {
+        const prop = meta.properties[k];
+        let isObjectId = false;
+        if (prop.kind === ReferenceKind.SCALAR) {
+          isObjectId = prop.type === 'ObjectId';
+        } else if (prop.kind === ReferenceKind.EMBEDDED) {
+          if (copiedData[prop.name] == null) {
             return;
+          }
+          if (prop.array && Array.isArray(copiedData[prop.name])) {
+            copiedData[prop.name] = copiedData[prop.name].map(item =>
+              this.renameFields(prop.targetMeta.class, item, dotPaths, true, false),
+            );
+          } else {
+            copiedData[prop.name] = this.renameFields(
+              prop.targetMeta.class,
+              copiedData[prop.name],
+              dotPaths,
+              prop.object || object,
+              false,
+            );
+          }
+        } else if (prop.polymorphic && prop.fieldNames?.length >= 2) {
+          // Polymorphic M:1: split into discriminator + FK fields
+          const value = copiedData[k];
+          delete copiedData[k];
+          if (value instanceof PolymorphicRef) {
+            copiedData[prop.fieldNames[0]] = value.discriminator;
+            const idField = prop.fieldNames[1];
+            const targetMeta = this.metadata.find(prop.discriminatorMap[value.discriminator]);
+            const hasObjectId = targetMeta && targetMeta.properties[targetMeta.primaryKeys[0]]?.type === 'ObjectId';
+            copiedData[idField] = hasObjectId ? this.convertObjectIds(value.id) : value.id;
+          } else if (Array.isArray(value)) {
+            // Tuple format: [discriminator, id]
+            copiedData[prop.fieldNames[0]] = value[0];
+            copiedData[prop.fieldNames[1]] = value[1] != null ? this.convertObjectIds(value[1]) : value[1];
+          } else if (value == null) {
+            prop.fieldNames.forEach(f => (copiedData[f] = null));
+          }
+          return;
+        } else {
+          const meta2 = this.metadata.find(prop.targetMeta.class);
+          const pk = meta2.properties[meta2.primaryKeys[0]];
+          isObjectId = pk.type === 'ObjectId';
+        }
+        if (isObjectId) {
+          copiedData[k] = this.convertObjectIds(copiedData[k]);
+        }
+        if (prop.fieldNames) {
+          Utils.renameKey(copiedData, k, prop.fieldNames[0]);
+        }
+      }
+      if (Utils.isPlainObject(copiedData[k]) && '$re' in copiedData[k]) {
+        copiedData[k] = new RegExp(copiedData[k].$re);
+      }
+    });
+    return copiedData;
+  }
+  convertObjectIds(data) {
+    if (data instanceof ObjectId) {
+      return data;
+    }
+    if (typeof data === 'string' && /^[0-9a-f]{24}$/i.exec(data)) {
+      return new ObjectId(data);
+    }
+    if (Array.isArray(data)) {
+      return data.map(item => this.convertObjectIds(item));
+    }
+    if (Utils.isObject(data)) {
+      Object.keys(data).forEach(k => {
+        data[k] = this.convertObjectIds(data[k]);
+      });
+    }
+    return data;
+  }
+  buildFilterById(entityName, id) {
+    const meta = this.metadata.find(entityName);
+    if (meta.properties[meta.primaryKeys[0]].type === 'ObjectId') {
+      return { _id: new ObjectId(id) };
+    }
+    return { _id: id };
+  }
+  buildFields(entityName, populate, fields, exclude) {
+    const meta = this.metadata.get(entityName);
+    const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => this.isPopulated(meta, prop, p)));
+    const ret = [];
+    if (fields) {
+      for (let field of fields) {
+        /* v8 ignore next */
+        if (Utils.isPlainObject(field)) {
+          continue;
         }
-        const versionProperty = meta.properties[meta.versionProperty];
-        if (versionProperty.runtimeType === 'Date') {
-            data[versionProperty.name] ??= new Date();
-        }
-        else {
-            data[versionProperty.name] ??= update ? { $inc: 1 } : 1;
+        if (field.toString().includes('.')) {
+          field = field.toString().substring(0, field.toString().indexOf('.'));
         }
+        let prop = meta.properties[field];
+        /* v8 ignore next */
+        if (prop) {
+          if (!prop.fieldNames) {
+            continue;
+          }
+          prop = prop.serializedPrimaryKey ? meta.getPrimaryProps()[0] : prop;
+          ret.push(prop.fieldNames[0]);
+        } else if (field === '*') {
+          const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate));
+          ret.push(...Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
+        } else {
+          ret.push(field);
+        }
+      }
+      ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
+    } else if (!Utils.isEmpty(exclude) || lazyProps.some(p => !p.formula)) {
+      const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, exclude));
+      ret.push(...Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
+    }
+    return ret.length > 0 ? ret : undefined;
+  }
+  handleVersionProperty(entityName, data, update = false) {
+    const meta = this.metadata.find(entityName);
+    if (!meta?.versionProperty) {
+      return;
     }
-    /** @inheritDoc */
-    getORMClass() {
-        return MongoMikroORM;
+    const versionProperty = meta.properties[meta.versionProperty];
+    if (versionProperty.runtimeType === 'Date') {
+      data[versionProperty.name] ??= new Date();
+    } else {
+      data[versionProperty.name] ??= update ? { $inc: 1 } : 1;
     }
+  }
+  /** @inheritDoc */
+  getORMClass() {
+    return MongoMikroORM;
+  }
 }