@mikro-orm/mongodb 7.1.0-dev.3 → 7.1.0-dev.30

package/MongoConnection.d.ts

@@ -68,6 +68,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,9 @@ export class MongoConnection extends Connection {
         if (opts.allowDiskUse != null) {
             options.allowDiskUse = opts.allowDiskUse;
         }
+        if (opts.chunkSize != null) {
+            options.batchSize = opts.chunkSize;
+        }
         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);

package/MongoDriver.d.ts

@@ -15,6 +15,7 @@ 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>>;
@@ -31,7 +32,8 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
     streamAggregate<T extends object>(entityName: EntityName<T>, pipeline: any[], ctx?: Transaction<ClientSession>): 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));
+        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);
@@ -268,6 +315,13 @@ 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;
         }
@@ -276,6 +330,7 @@ export class MongoDriver extends DatabaseDriver {
         }
         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

@@ -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());
+        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/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

@@ -132,10 +132,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 +173,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 +219,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mongodb",
-  "version": "7.1.0-dev.3",
+  "version": "7.1.0-dev.30",
   "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",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "mongodb": "7.1.1"
+    "mongodb": "7.2.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.3"
+    "@mikro-orm/core": "7.1.0-dev.30"
   },
   "engines": {
     "node": ">= 22.17.0"