@mikro-orm/mongodb 7.0.17 → 7.0.18-dev.1

package/MongoConnection.d.ts

@@ -28,13 +28,13 @@ export declare class MongoConnection extends Connection {
     find<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, opts?: MongoFindOptions<T>): Promise<EntityData<T>[]>;
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, opts?: MongoFindOptions<T>): AsyncIterableIterator<T>;
     private _find;
-    insertOne<T extends object>(entityName: EntityName<T>, data: Partial<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
-    insertMany<T extends object>(entityName: EntityName<T>, data: Partial<T>[], ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
-    updateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertOptions<T>): Promise<QueryResult<T>>;
-    bulkUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: Partial<T>[], ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    deleteMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
-    aggregate<T extends object = any>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<T[]>;
-    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, stream?: boolean): AsyncIterableIterator<T>;
+    insertOne<T extends object>(entityName: EntityName<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, signal?: AbortSignal): Promise<QueryResult<T>>;
+    insertMany<T extends object>(entityName: EntityName<T>, data: Partial<T>[], ctx?: Transaction<ClientSession>, signal?: AbortSignal): Promise<QueryResult<T>>;
+    updateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertOptions<T>, signal?: AbortSignal): Promise<QueryResult<T>>;
+    bulkUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: Partial<T>[], ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertManyOptions<T>, signal?: AbortSignal): Promise<QueryResult<T>>;
+    deleteMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, ctx?: Transaction<ClientSession>, signal?: AbortSignal): Promise<QueryResult<T>>;
+    aggregate<T extends object = any>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, signal?: AbortSignal): Promise<T[]>;
+    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, stream?: boolean, signal?: AbortSignal): AsyncIterableIterator<T>;
     countDocuments<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, opts?: MongoCountOptions): Promise<number>;
     transactional<T>(cb: (trx: Transaction<ClientSession>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
@@ -61,6 +61,11 @@ export interface MongoQueryOptions {
     indexHint?: string | Dictionary;
     maxTimeMS?: number;
     allowDiskUse?: boolean;
+    /**
+     * Forwarded to the MongoDB driver. When fired, the driver aborts the in-flight operation
+     * by closing the underlying socket; the rejection reason is `signal.reason`.
+     */
+    signal?: AbortSignal;
 }
 /** Options for MongoDB find operations. */
 export interface MongoFindOptions<T extends object> extends MongoQueryOptions {
@@ -68,6 +73,7 @@ export interface MongoFindOptions<T extends object> extends MongoQueryOptions {
     limit?: number;
     offset?: number;
     fields?: string[];
+    chunkSize?: number;
     ctx?: Transaction<ClientSession>;
     loggerContext?: LoggingOptions;
 }

package/MongoConnection.js

@@ -143,6 +143,12 @@ export class MongoConnection extends Connection {
         if (opts.allowDiskUse != null) {
             options.allowDiskUse = opts.allowDiskUse;
         }
+        if (opts.chunkSize != null) {
+            options.batchSize = opts.chunkSize;
+        }
+        if (opts.signal) {
+            options.signal = opts.signal;
+        }
         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);
@@ -174,37 +180,43 @@ export class MongoConnection extends Connection {
         }
         return { cursor: resultSet, query };
     }
-    async insertOne(entityName, data, ctx) {
-        return this.runQuery('insertOne', entityName, data, undefined, ctx);
+    async insertOne(entityName, data, ctx, signal) {
+        return this.runQuery('insertOne', entityName, data, undefined, ctx, { signal });
     }
-    async insertMany(entityName, data, ctx) {
-        return this.runQuery('insertMany', entityName, data, undefined, ctx);
+    async insertMany(entityName, data, ctx, signal) {
+        return this.runQuery('insertMany', entityName, data, undefined, ctx, { signal });
     }
-    async updateMany(entityName, where, data, ctx, upsert, upsertOptions) {
-        return this.runQuery('updateMany', entityName, data, where, ctx, { upsert, upsertOptions });
+    async updateMany(entityName, where, data, ctx, upsert, upsertOptions, signal) {
+        return this.runQuery('updateMany', entityName, data, where, ctx, { upsert, upsertOptions, signal });
     }
-    async bulkUpdateMany(entityName, where, data, ctx, upsert, upsertOptions) {
-        return this.runQuery('bulkUpdateMany', entityName, data, where, ctx, { upsert, upsertOptions });
+    async bulkUpdateMany(entityName, where, data, ctx, upsert, upsertOptions, signal) {
+        return this.runQuery('bulkUpdateMany', entityName, data, where, ctx, { upsert, upsertOptions, signal });
     }
-    async deleteMany(entityName, where, ctx) {
-        return this.runQuery('deleteMany', entityName, undefined, where, ctx);
+    async deleteMany(entityName, where, ctx, signal) {
+        return this.runQuery('deleteMany', entityName, undefined, where, ctx, { signal });
     }
-    async aggregate(entityName, pipeline, ctx, loggerContext) {
+    async aggregate(entityName, pipeline, ctx, loggerContext, signal) {
         await this.ensureConnection();
         const collection = this.getCollectionName(entityName);
         /* v8 ignore next */
         const options = ctx ? { session: ctx } : {};
+        if (signal) {
+            options.signal = signal;
+        }
         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) {
+    async *streamAggregate(entityName, pipeline, ctx, loggerContext, stream = false, signal) {
         await this.ensureConnection();
         const collection = this.getCollectionName(entityName);
         /* v8 ignore next */
         const options = ctx ? { session: ctx } : {};
+        if (signal) {
+            options.signal = signal;
+        }
         const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)})};`;
         const cursor = this.getCollection(entityName).aggregate(pipeline, options);
         this.logQuery(query, { ...loggerContext });
@@ -216,6 +228,7 @@ export class MongoConnection extends Connection {
             collation: opts.collation,
             indexHint: opts.indexHint,
             maxTimeMS: opts.maxTimeMS,
+            signal: opts.signal,
         });
     }
     async transactional(cb, options = {}) {
@@ -262,13 +275,16 @@ export class MongoConnection extends Connection {
     }
     async runQuery(method, entityName, data, where, ctx, opts) {
         await this.ensureConnection();
-        const { upsert, upsertOptions, loggerContext, collation, indexHint, maxTimeMS } = opts ?? {};
+        const { upsert, upsertOptions, loggerContext, collation, indexHint, maxTimeMS, signal } = 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;
         }
+        if (signal) {
+            options.signal = signal;
+        }
         const now = Date.now();
         let res;
         let query;

package/MongoDriver.d.ts

@@ -15,22 +15,26 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
         rawResults?: boolean;
     }): AsyncIterableIterator<T>;
     find<T extends object, P extends string = never, F extends string = never, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    private findWithPartitionLimit;
     findOne<T extends object, P extends string = never, F extends string = never, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     streamVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): AsyncIterableIterator<EntityData<T>>;
     count<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeClone<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, overrides?: EntityData<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: {
         ctx?: Transaction<ClientSession>;
+        signal?: AbortSignal;
     }): Promise<QueryResult<T>>;
-    aggregate(entityName: EntityName, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
-    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>): AsyncIterableIterator<T>;
+    aggregate(entityName: EntityName, pipeline: any[], ctx?: Transaction<ClientSession>, signal?: AbortSignal): Promise<any[]>;
+    streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>, signal?: AbortSignal): AsyncIterableIterator<T>;
     getPlatform(): MongoPlatform;
     private buildQueryOptions;
-    private renameFields;
+    /** @internal */
+    renameFields<T extends object>(entityName: EntityName<T>, data: T, dotPaths?: boolean, object?: boolean, root?: boolean): T;
     private convertObjectIds;
     private buildFilterById;
     protected buildFields<T extends object, P extends string = never>(entityName: EntityName<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;

package/MongoDriver.js

@@ -30,6 +30,7 @@ export class MongoDriver extends DatabaseDriver {
             offset: options.offset,
             fields,
             ctx: options.ctx,
+            chunkSize: options.chunkSize ?? 100,
             ...this.buildQueryOptions(options),
         });
         for await (const item of res) {
@@ -78,6 +79,10 @@ export class MongoDriver extends DatabaseDriver {
             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 partitionLimit = options._partitionLimit;
+        if (partitionLimit) {
+            return this.findWithPartitionLimit(entityName, where, orderBy, fields ?? [], partitionLimit, options);
+        }
         const res = await this.rethrow(this.getConnection('read').find(entityName, where, {
             orderBy,
             limit: options.limit,
@@ -88,6 +93,48 @@ export class MongoDriver extends DatabaseDriver {
         }));
         return res.map(r => this.mapResult(r, this.metadata.find(entityName)));
     }
+    async findWithPartitionLimit(entityName, where, orderBy, fields, partitionLimit, options) {
+        const meta = this.metadata.find(entityName);
+        const { limit, offset = 0 } = partitionLimit;
+        // Resolve the partition property to its DB field name; callers always pass
+        // a declared property on the target meta (FK of the owning side).
+        const prop = meta.properties[partitionLimit.partitionBy];
+        const partitionField = prop.fieldNames[0];
+        const pipeline = [];
+        pipeline.push({ $match: where });
+        if (orderBy.length > 0) {
+            const sortSpec = {};
+            for (const order of orderBy) {
+                for (const [key, dir] of Object.entries(order)) {
+                    sortSpec[key] = dir === 'ASC' || dir === 'asc' || dir === 1 ? 1 : -1;
+                }
+            }
+            pipeline.push({ $sort: sortSpec });
+        }
+        // $sort before $group ensures $push collects in correct order
+        pipeline.push({
+            $group: {
+                _id: `$${partitionField}`,
+                __docs: { $push: '$$ROOT' },
+            },
+        });
+        pipeline.push({
+            $project: {
+                __docs: { $slice: ['$__docs', offset, limit] },
+            },
+        });
+        pipeline.push({ $unwind: '$__docs' });
+        pipeline.push({ $replaceRoot: { newRoot: '$__docs' } });
+        if (fields.length > 0) {
+            const projection = {};
+            for (const field of fields) {
+                projection[field] = 1;
+            }
+            pipeline.push({ $project: projection });
+        }
+        const res = await this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, options.ctx, options.logging, options.signal));
+        return res.map(r => this.mapResult(r, meta));
+    }
     async findOne(entityName, where, options = { populate: [], orderBy: {} }) {
         if (this.metadata.find(entityName)?.virtual) {
             const [item] = await this.findVirtual(entityName, where, options);
@@ -146,7 +193,28 @@ export class MongoDriver extends DatabaseDriver {
     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));
+        return this.rethrow(this.getConnection('write').insertOne(entityName, data, options.ctx, options.signal));
+    }
+    async nativeClone(entityName, where, overrides, options = {}) {
+        const meta = this.metadata.find(entityName);
+        const pk = meta.getPrimaryProps()[0].fieldNames[0] ?? '_id';
+        const normalizedWhere = Utils.isPrimaryKey(where) ? { [pk]: where } : where;
+        const renameWhere = this.renameFields(entityName, normalizedWhere);
+        const source = await this.rethrow(this.getConnection('read').find(entityName, renameWhere, { ctx: options.ctx, limit: 1 }));
+        if (!source.length) {
+            throw new Error('Cannot clone: no entity found matching the given condition');
+        }
+        const doc = source[0];
+        delete doc[pk];
+        if (overrides) {
+            const mapped = this.renameFields(entityName, overrides);
+            Object.assign(doc, mapped);
+        }
+        if (meta.versionProperty) {
+            const vProp = meta.properties[meta.versionProperty];
+            doc[vProp.fieldNames[0]] = vProp.runtimeType === 'Date' ? new Date() : 1;
+        }
+        return this.rethrow(this.getConnection('write').insertOne(entityName, doc, options.ctx));
     }
     async nativeInsertMany(entityName, data, options = {}) {
         data = data.map(item => {
@@ -156,7 +224,7 @@ export class MongoDriver extends DatabaseDriver {
         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));
+        const res = await this.rethrow(this.getConnection('write').insertMany(entityName, data, options.ctx, options.signal));
         res.rows = res.insertedIds.map(id => ({ [pk]: id }));
         return res;
     }
@@ -180,7 +248,7 @@ export class MongoDriver extends DatabaseDriver {
         if (options.onConflictExcludeFields) {
             options.onConflictExcludeFields = options.onConflictExcludeFields.map(rename);
         }
-        return this.rethrow(this.getConnection('write').updateMany(entityName, where, data, options.ctx, options.upsert, options));
+        return this.rethrow(this.getConnection('write').updateMany(entityName, where, data, options.ctx, options.upsert, options, options.signal));
     }
     async nativeUpdateMany(entityName, where, data, options = {}) {
         where = where.map(row => {
@@ -208,7 +276,7 @@ export class MongoDriver extends DatabaseDriver {
         }
         /* 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));
+        const res = await this.rethrow(this.getConnection('write').bulkUpdateMany(entityName, where, data, options.ctx, options.upsert, options, options.signal));
         if (res.insertedIds) {
             let i = 0;
             res.rows = where.map(cond => {
@@ -225,13 +293,13 @@ export class MongoDriver extends DatabaseDriver {
             where = this.buildFilterById(entityName, where);
         }
         where = this.renameFields(entityName, where, true);
-        return this.rethrow(this.getConnection('write').deleteMany(entityName, where, options.ctx));
+        return this.rethrow(this.getConnection('write').deleteMany(entityName, where, options.ctx, options.signal));
     }
-    async aggregate(entityName, pipeline, ctx) {
-        return this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, ctx));
+    async aggregate(entityName, pipeline, ctx, signal) {
+        return this.rethrow(this.getConnection('read').aggregate(entityName, pipeline, ctx, undefined, signal));
     }
-    async *streamAggregate(entityName, pipeline, ctx) {
-        yield* this.getConnection('read').streamAggregate(entityName, pipeline, ctx);
+    async *streamAggregate(entityName, pipeline, ctx, signal) {
+        yield* this.getConnection('read').streamAggregate(entityName, pipeline, ctx, undefined, false, signal);
     }
     getPlatform() {
         return this.platform;
@@ -247,14 +315,25 @@ export class MongoDriver extends DatabaseDriver {
         if (options.indexHint != null) {
             ret.indexHint = options.indexHint;
         }
+        else if (options.using != null) {
+            const names = Utils.asArray(options.using);
+            if (names.length > 1) {
+                throw new Error('MongoDB only supports a single index hint per query. Provide one index name instead of an array.');
+            }
+            ret.indexHint = names[0];
+        }
         if (options.maxTimeMS != null) {
             ret.maxTimeMS = options.maxTimeMS;
         }
         if (options.allowDiskUse != null) {
             ret.allowDiskUse = options.allowDiskUse;
         }
+        if (options.signal) {
+            ret.signal = options.signal;
+        }
         return ret;
     }
+    /** @internal */
     renameFields(entityName, data, dotPaths = false, object, root = true) {
         if (data == null && root) {
             return {};

package/MongoEntityManager.d.ts

@@ -1,4 +1,4 @@
-import { EntityManager, type EntityName, type EntityRepository, type GetRepository, type TransactionOptions, type StreamOptions, type Loaded } from '@mikro-orm/core';
+import { EntityManager, type CountByOptions, type Dictionary, type EntityKey, type EntityName, type EntityRepository, type GetRepository, type Loaded, type StreamOptions, type TransactionOptions, type WithUsingOptions } from '@mikro-orm/core';
 import type { Collection, Document, TransactionOptions as MongoTransactionOptions } from 'mongodb';
 import type { MongoDriver } from './MongoDriver.js';
 import type { MongoEntityRepository } from './MongoEntityRepository.js';
@@ -17,8 +17,12 @@ export declare class MongoEntityManager<Driver extends MongoDriver = MongoDriver
     /**
      * @inheritDoc
      */
-    stream<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+    stream<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never, Using extends string = never>(entityName: EntityName<Entity>, options?: WithUsingOptions<StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>, NoInfer<Entity>, Using>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
     getCollection<T extends Document>(entityOrCollectionName: EntityName<T> | string): Collection<T>;
+    /**
+     * @inheritDoc
+     */
+    countBy<Entity extends object>(entityName: EntityName<Entity>, groupBy: EntityKey<Entity> | readonly EntityKey<Entity>[], options?: CountByOptions<Entity>): Promise<Dictionary<number>>;
     /**
      * @inheritDoc
      */

package/MongoEntityManager.js

@@ -7,13 +7,13 @@ export class MongoEntityManager extends EntityManager {
      * Shortcut to driver's aggregate method. Available in MongoDriver only.
      */
     async aggregate(entityName, pipeline) {
-        return this.getDriver().aggregate(entityName, pipeline, this.getTransactionContext());
+        return this.getDriver().aggregate(entityName, pipeline, this.getTransactionContext(), this.signal);
     }
     /**
      * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
      */
     async *streamAggregate(entityName, pipeline) {
-        yield* this.getDriver().streamAggregate(entityName, pipeline, this.getTransactionContext());
+        yield* this.getDriver().streamAggregate(entityName, pipeline, this.getTransactionContext(), this.signal);
     }
     /**
      * @inheritDoc
@@ -27,6 +27,37 @@ export class MongoEntityManager extends EntityManager {
     getCollection(entityOrCollectionName) {
         return this.getConnection().getCollection(entityOrCollectionName);
     }
+    /**
+     * @inheritDoc
+     */
+    async countBy(entityName, groupBy, options = {}) {
+        const em = this.getContext(false);
+        options = { ...options };
+        em.prepareOptions(options);
+        const meta = em.getMetadata().find(entityName);
+        const fields = Utils.asArray(groupBy);
+        if (options.having) {
+            throw new Error('The `having` option is not supported for MongoDB in `countBy`.');
+        }
+        await em.tryFlush(entityName, options);
+        const rawWhere = options.where;
+        const where = await em.processWhere(entityName, rawWhere ?? {}, options, 'read');
+        const renamedWhere = em.getDriver().renameFields(meta.class, where, true);
+        const fieldNames = fields.map(f => meta.properties[f]?.fieldNames?.[0] ?? f);
+        const groupId = fieldNames.length === 1 ? `$${fieldNames[0]}` : Object.fromEntries(fieldNames.map(f => [f, `$${f}`]));
+        const pipeline = [];
+        if (renamedWhere && Object.keys(renamedWhere).length > 0) {
+            pipeline.push({ $match: renamedWhere });
+        }
+        pipeline.push({ $group: { _id: groupId, count: { $sum: 1 } } });
+        const rows = await em.getDriver().aggregate(meta.class, pipeline, em.getTransactionContext(), em.signal);
+        const results = {};
+        for (const row of rows) {
+            const key = fieldNames.length === 1 ? String(row._id) : fieldNames.map(f => String(row._id[f])).join(Utils.PK_SEPARATOR);
+            results[key] = +row.count;
+        }
+        return results;
+    }
     /**
      * @inheritDoc
      */

package/MongoMikroORM.d.ts

@@ -2,17 +2,17 @@ import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Opt
 import { MongoDriver } from './MongoDriver.js';
 import type { MongoEntityManager } from './MongoEntityManager.js';
 /** Configuration options for the MongoDB driver. */
-export type MongoOptions<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<MongoDriver, EM, Entities>>;
+export type MongoOptions<EM extends MongoEntityManager = MongoEntityManager, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<MongoDriver, EM, Entities>>;
 /** Creates a type-safe configuration object for the MongoDB driver. */
-export declare function defineMongoConfig<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: MongoOptions<EM, Entities>): MongoOptions<EM, Entities>;
+export declare function defineMongoConfig<EM extends MongoEntityManager = MongoEntityManager, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: MongoOptions<EM, Entities>): MongoOptions<EM, Entities>;
 /**
  * @inheritDoc
  */
-export declare class MongoMikroORM<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MongoDriver, EM, Entities> {
+export declare class MongoMikroORM<EM extends MongoEntityManager = MongoEntityManager, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MongoDriver, EM, Entities> {
     /**
      * @inheritDoc
      */
-    static init<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * @inheritDoc
      */

package/MongoPlatform.js

@@ -73,9 +73,13 @@ export class MongoPlatform extends Platform {
         return prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner;
     }
     validateMetadata(meta) {
+        super.validateMetadata(meta);
         if (meta.inheritanceType === 'tpt') {
             throw MetadataError.tptNotSupportedByDriver(meta);
         }
+        if (meta.triggers?.length > 0) {
+            throw MetadataError.triggersNotSupportedByDriver(meta);
+        }
         const pk = meta.getPrimaryProps()[0];
         if (pk && pk.fieldNames?.[0] !== '_id') {
             throw MetadataError.invalidPrimaryKey(meta, pk, '_id');

package/MongoSchemaGenerator.d.ts

@@ -21,6 +21,11 @@ export declare class MongoSchemaGenerator extends AbstractSchemaGenerator<MongoD
     ensureIndexes(options?: EnsureIndexesOptions): Promise<void>;
     private mapIndexProperties;
     private createIndexes;
+    /**
+     * An explicit `options.partialFilterExpression` wins over `where` — this preserves the
+     * long-standing `options: { partialFilterExpression }` escape hatch.
+     */
+    private applyPartialFilter;
     private executeQuery;
     private createUniqueIndexes;
     private createPropertyIndexes;

package/MongoSchemaGenerator.js

@@ -20,10 +20,13 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
                 throw err;
             }
         }));
+        // Collections must exist before we touch indexes. `createIndex` on a missing collection
+        // races with the explicit `createCollection` above, and on retries the recovery path can
+        // see partial state and drop indexes that were already created successfully.
+        await Promise.all(promises);
         if (options.ensureIndexes) {
             await this.ensureIndexes({ ensureCollections: false });
         }
-        await Promise.all(promises);
     }
     async drop(options = {}) {
         await this.connection.ensureConnection();
@@ -132,10 +135,21 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             const properties = this.mapIndexProperties(index, meta);
             const collection = this.connection.getCollection(meta.class);
             if (Array.isArray(index.options) && index.options.length === 2 && properties.length === 0) {
-                res.push([collection.collectionName, collection.createIndex(index.options[0], index.options[1])]);
+                // The array-form escape hatch passes raw [spec, options] to the driver; fold `where`
+                // into the options dict (on a clone, to avoid mutating the user's metadata).
+                const opts = { ...index.options[1] };
+                this.applyPartialFilter(opts, index.where, index.name, meta.className);
+                res.push([collection.collectionName, collection.createIndex(index.options[0], opts)]);
                 return;
             }
             if (index.options && properties.length === 0) {
+                // The plain escape hatch forwards `index.options` as the sole argument; there is
+                // no options slot for `partialFilterExpression`, so warn instead of silently dropping.
+                if (index.where != null) {
+                    this.config
+                        .getLogger()
+                        .warn('schema', `Index '${index.name ?? '(unnamed)'}' on entity '${meta.className}': \`where\` was ignored because \`options\` is used as the raw index spec and leaves no slot for \`partialFilterExpression\` — pass \`options: [spec, { partialFilterExpression }]\` (array form) to combine both.`);
+                }
                 res.push([collection.collectionName, collection.createIndex(index.options)]);
                 return;
             }
@@ -162,10 +176,30 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             if (index.invisible) {
                 indexOptions.hidden = true;
             }
+            this.applyPartialFilter(indexOptions, index.where, index.name, meta.className);
             res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, indexOptions)]);
         });
         return res;
     }
+    /**
+     * An explicit `options.partialFilterExpression` wins over `where` — this preserves the
+     * long-standing `options: { partialFilterExpression }` escape hatch.
+     */
+    applyPartialFilter(options, where, indexName, entityName) {
+        if (where == null) {
+            return;
+        }
+        if (options.partialFilterExpression != null) {
+            this.config
+                .getLogger()
+                .warn('schema', `Index '${indexName ?? '(unnamed)'}' on entity '${entityName}': both \`where\` and \`options.partialFilterExpression\` are set; \`options.partialFilterExpression\` wins.`);
+            return;
+        }
+        if (typeof where === 'string') {
+            throw new Error(`Index '${indexName ?? '(unnamed)'}' on entity '${entityName}': string \`where\` is not supported on MongoDB; pass an object/FilterQuery (it maps to MongoDB's \`partialFilterExpression\`).`);
+        }
+        options.partialFilterExpression = where;
+    }
     async executeQuery(collection, method, ...args) {
         const now = Date.now();
         return collection[method](...args).then((res) => {
@@ -188,14 +222,13 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
                 return o;
             }, {});
             const collection = this.connection.getCollection(meta.class);
-            res.push([
-                collection.collectionName,
-                this.executeQuery(collection, 'createIndex', fieldOrSpec, {
-                    name: index.name,
-                    unique: true,
-                    ...index.options,
-                }),
-            ]);
+            const indexOptions = {
+                name: index.name,
+                unique: true,
+                ...index.options,
+            };
+            this.applyPartialFilter(indexOptions, index.where, index.name, meta.className);
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, indexOptions)]);
         });
         return res;
     }

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mongodb",
-  "version": "7.0.17",
+  "version": "7.0.18-dev.1",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.17"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.17"
+    "@mikro-orm/core": "7.0.18-dev.1"
   },
   "engines": {
     "node": ">= 22.17.0"