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

package/MongoDriver.js

@@ -1,454 +1,444 @@
 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));
-      }
-    }
-  }
-  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);
-  }
-  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 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;
+    [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));
+            }
+        }
     }
-    if (options.maxTimeMS != null) {
-      ret.maxTimeMS = options.maxTimeMS;
+    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);
     }
-    if (options.allowDiskUse != null) {
-      ret.allowDiskUse = options.allowDiskUse;
+    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;
     }
-    return ret;
-  }
-  renameFields(entityName, data, dotPaths = false, object, root = true) {
-    if (data == null && root) {
-      return {};
+    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));
     }
-    if (typeof data !== 'object' || data === null) {
-      return data;
+    async aggregate(entityName, pipeline, ctx) {
+        return this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, ctx));
     }
-    // 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]);
+    async *streamAggregate(entityName, pipeline, ctx) {
+        yield* this.getConnection('read').streamAggregate(entityName, pipeline, ctx);
     }
-    if (meta && !meta.embeddable) {
-      this.inlineEmbeddables(meta, copiedData, dotPaths);
+    getPlatform() {
+        return this.platform;
     }
-    // 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;
-        }
-      }
+    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;
     }
-    // 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;
+    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;
     }
-    // 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.');
+    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;
     }
-    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) {
+    handleVersionProperty(entityName, data, update = false) {
+        const meta = this.metadata.find(entityName);
+        if (!meta?.versionProperty) {
             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;
         }
-        if (field.toString().includes('.')) {
-          field = field.toString().substring(0, field.toString().indexOf('.'));
+        const versionProperty = meta.properties[meta.versionProperty];
+        if (versionProperty.runtimeType === 'Date') {
+            data[versionProperty.name] ??= new Date();
+        }
+        else {
+            data[versionProperty.name] ??= update ? { $inc: 1 } : 1;
         }
-        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;
     }
-    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;
     }
-  }
-  /** @inheritDoc */
-  getORMClass() {
-    return MongoMikroORM;
-  }
 }