@mikro-orm/mongodb 7.0.0-dev.34 → 7.0.0-dev.36

package/MongoConnection.d.ts

@@ -24,12 +24,15 @@ export declare class MongoConnection extends Connection {
     getDb(): Db;
     execute(query: string): Promise<any>;
     find<T extends object>(collection: string, where: FilterQuery<T>, orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[], limit?: number, offset?: number, fields?: string[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<EntityData<T>[]>;
+    stream<T extends object>(collection: string, where: FilterQuery<T>, orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[], limit?: number, offset?: number, fields?: string[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
+    private _find;
     insertOne<T extends object>(collection: string, data: Partial<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
     insertMany<T extends object>(collection: string, data: Partial<T>[], ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
     updateMany<T extends object>(collection: string, where: FilterQuery<T>, data: Partial<T>, ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertOptions<T>): Promise<QueryResult<T>>;
     bulkUpdateMany<T extends object>(collection: string, where: FilterQuery<T>[], data: Partial<T>[], ctx?: Transaction<ClientSession>, upsert?: boolean, upsertOptions?: UpsertManyOptions<T>): Promise<QueryResult<T>>;
     deleteMany<T extends object>(collection: string, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<QueryResult<T>>;
     aggregate<T extends object = any>(collection: string, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions): Promise<T[]>;
+    streamAggregate<T extends object>(collection: string, pipeline: any[], ctx?: Transaction<ClientSession>, loggerContext?: LoggingOptions, stream?: boolean): AsyncIterableIterator<T>;
     countDocuments<T extends object>(collection: string, where: FilterQuery<T>, ctx?: Transaction<ClientSession>): Promise<number>;
     transactional<T>(cb: (trx: Transaction<ClientSession>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;

package/MongoConnection.js

@@ -109,6 +109,18 @@ export class MongoConnection extends Connection {
         throw new Error(`${this.constructor.name} does not support generic execute method`);
     }
     async find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
+        const { cursor, query } = await this._find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext);
+        const now = Date.now();
+        const res = await cursor.toArray();
+        this.logQuery(`${query}.toArray();`, { took: Date.now() - now, results: res.length, ...loggerContext });
+        return res;
+    }
+    async *stream(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
+        const { cursor, query } = await this._find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext);
+        this.logQuery(`${query}.toArray();`, loggerContext);
+        yield* cursor;
+    }
+    async _find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
         await this.ensureConnection();
         collection = this.getCollectionName(collection);
         const options = ctx ? { session: ctx } : {};
@@ -128,7 +140,6 @@ export class MongoConnection extends Connection {
             });
             if (orderByTuples.length > 0) {
                 query += `.sort(${this.logObject(orderByTuples)})`;
-                // @ts-expect-error ??
                 resultSet.sort(orderByTuples);
             }
         }
@@ -140,10 +151,7 @@ export class MongoConnection extends Connection {
             query += `.skip(${offset})`;
             resultSet.skip(offset);
         }
-        const now = Date.now();
-        const res = await resultSet.toArray();
-        this.logQuery(`${query}.toArray();`, { took: Date.now() - now, results: res.length, ...loggerContext });
-        return res;
+        return { cursor: resultSet, query };
     }
     async insertOne(collection, data, ctx) {
         return this.runQuery('insertOne', collection, data, undefined, ctx);
@@ -171,6 +179,16 @@ export class MongoConnection extends Connection {
         this.logQuery(query, { took: Date.now() - now, results: res.length, ...loggerContext });
         return res;
     }
+    async *streamAggregate(collection, pipeline, ctx, loggerContext, stream = false) {
+        await this.ensureConnection();
+        collection = this.getCollectionName(collection);
+        /* v8 ignore next */
+        const options = ctx ? { session: ctx } : {};
+        const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)})};`;
+        const cursor = this.getCollection(collection).aggregate(pipeline, options);
+        this.logQuery(query, { ...loggerContext });
+        yield* cursor;
+    }
     async countDocuments(collection, where, ctx) {
         return this.runQuery('countDocuments', collection, undefined, where, ctx);
     }

package/MongoDriver.d.ts

@@ -1,5 +1,5 @@
 import { type ClientSession } from 'mongodb';
-import { type Configuration, type CountOptions, DatabaseDriver, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type FilterQuery, type FindOneOptions, type FindOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type PopulatePath, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type Configuration, type CountOptions, DatabaseDriver, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityName, type FilterQuery, type FindOneOptions, type FindOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type PopulatePath, type QueryResult, type StreamOptions, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import { MongoConnection } from './MongoConnection.js';
 import { MongoPlatform } from './MongoPlatform.js';
 import { MongoEntityManager } from './MongoEntityManager.js';
@@ -9,9 +9,13 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
     protected readonly platform: MongoPlatform;
     constructor(config: Configuration);
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any, any, any> & {
+        rawResults?: boolean;
+    }): AsyncIterableIterator<T>;
     find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
     findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     findVirtual<T extends object>(entityName: string, 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: string, where: FilterQuery<T>, options?: CountOptions<T>, ctx?: Transaction<ClientSession>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
@@ -21,6 +25,7 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
         ctx?: Transaction<ClientSession>;
     }): Promise<QueryResult<T>>;
     aggregate(entityName: string, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
+    streamAggregate<T extends object>(entityName: string, pipeline: any[], ctx?: Transaction<ClientSession>): AsyncIterableIterator<T>;
     getPlatform(): MongoPlatform;
     private renameFields;
     private convertObjectIds;

package/MongoDriver.js

@@ -14,6 +14,25 @@ export class MongoDriver extends DatabaseDriver {
         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;
+        }
+        entityName = Utils.className(entityName);
+        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, options.limit, options.offset, fields, options.ctx);
+        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);
@@ -67,7 +86,18 @@ export class MongoDriver extends DatabaseDriver {
             const em = this.createEntityManager();
             return meta.expression(em, where, options);
         }
-        /* v8 ignore next */
+        /* v8 ignore next 2 */
+        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 2 */
         return super.findVirtual(entityName, where, options);
     }
     async count(entityName, where, options = {}, ctx) {
@@ -165,6 +195,9 @@ export class MongoDriver extends DatabaseDriver {
     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;
     }

package/MongoEntityManager.d.ts

@@ -1,4 +1,4 @@
-import { EntityManager, type EntityName, type EntityRepository, type GetRepository, type TransactionOptions } from '@mikro-orm/core';
+import { EntityManager, type EntityName, type EntityRepository, type GetRepository, type TransactionOptions, type StreamOptions, type NoInfer, type Loaded } 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';
@@ -10,6 +10,14 @@ export declare class MongoEntityManager<Driver extends MongoDriver = MongoDriver
      * Shortcut to driver's aggregate method. Available in MongoDriver only.
      */
     aggregate(entityName: EntityName<any>, pipeline: any[]): Promise<any[]>;
+    /**
+     * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
+     */
+    streamAggregate<T extends object>(entityName: EntityName<any>, pipeline: any[]): AsyncIterableIterator<T>;
+    /**
+     * @inheritDoc
+     */
+    stream<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
     getCollection<T extends Document>(entityName: EntityName<T>): Collection<T>;
     /**
      * @inheritDoc

package/MongoEntityManager.js

@@ -1,4 +1,4 @@
-import { EntityManager, Utils } from '@mikro-orm/core';
+import { EntityManager, Utils, } from '@mikro-orm/core';
 /**
  * @inheritDoc
  */
@@ -8,7 +8,23 @@ export class MongoEntityManager extends EntityManager {
      */
     async aggregate(entityName, pipeline) {
         entityName = Utils.className(entityName);
-        return this.getDriver().aggregate(entityName, pipeline);
+        return this.getDriver().aggregate(entityName, pipeline, this.getTransactionContext());
+    }
+    /**
+     * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
+     */
+    async *streamAggregate(entityName, pipeline) {
+        entityName = Utils.className(entityName);
+        yield* this.getDriver().streamAggregate(entityName, pipeline, this.getTransactionContext());
+    }
+    /**
+     * @inheritDoc
+     */
+    async *stream(entityName, options = {}) {
+        if (!Utils.isEmpty(options.populate)) {
+            throw new Error('Populate option is not supported when streaming results in MongoDB');
+        }
+        yield* super.stream(entityName, options);
     }
     getCollection(entityName) {
         return this.getConnection().getCollection(entityName);

package/MongoPlatform.d.ts

@@ -1,5 +1,5 @@
 import { ObjectId } from 'mongodb';
-import { Platform, type IPrimaryKey, type Primary, type NamingStrategy, type Constructor, type EntityRepository, type EntityProperty, type PopulateOptions, type EntityMetadata, type IDatabaseDriver, type EntityManager, type Configuration, type MikroORM } from '@mikro-orm/core';
+import { Platform, type IPrimaryKey, type Primary, type NamingStrategy, type Constructor, type EntityRepository, type EntityProperty, type PopulateOptions, type EntityMetadata, type IDatabaseDriver, type EntityManager, type Configuration, type MikroORM, type TransformContext } from '@mikro-orm/core';
 import { MongoExceptionConverter } from './MongoExceptionConverter.js';
 import { MongoSchemaGenerator } from './MongoSchemaGenerator.js';
 export declare class MongoPlatform extends Platform {
@@ -21,7 +21,7 @@ export declare class MongoPlatform extends Platform {
     usesImplicitTransactions(): boolean;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown): unknown;
-    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
+    convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     marshallArray(values: string[]): string;
     cloneEmbeddable<T>(data: T): T;
     shouldHaveColumn<T>(prop: EntityProperty<T>, populate: PopulateOptions<T>[], exclude?: string[]): boolean;

package/MongoPlatform.js

@@ -60,7 +60,7 @@ export class MongoPlatform extends Platform {
     convertJsonToDatabaseValue(value) {
         return Utils.copy(value);
     }
-    convertJsonToJSValue(value, prop) {
+    convertJsonToJSValue(value, context) {
         return value;
     }
     marshallArray(values) {

package/MongoSchemaGenerator.d.ts

@@ -17,7 +17,9 @@ export declare class MongoSchemaGenerator extends AbstractSchemaGenerator<MongoD
         collectionsWithFailedIndexes?: string[];
     }): Promise<void>;
     ensureIndexes(options?: EnsureIndexesOptions): Promise<void>;
+    private mapIndexProperties;
     private createIndexes;
+    private executeQuery;
     private createUniqueIndexes;
     private createPropertyIndexes;
 }

package/MongoSchemaGenerator.js

@@ -1,3 +1,4 @@
+import { inspect } from 'node:util';
 import { AbstractSchemaGenerator, Utils, } from '@mikro-orm/core';
 export class MongoSchemaGenerator extends AbstractSchemaGenerator {
     static register(orm) {
@@ -61,7 +62,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
                 const isIdIndex = index.key._id === 1 && Utils.getObjectKeysSize(index.key) === 1;
                 /* v8 ignore next 3 */
                 if (!isIdIndex && !options?.skipIndexes?.find(idx => idx.collection === collection.name && idx.indexName === index.name)) {
-                    promises.push(db.collection(collection.name).dropIndex(index.name));
+                    promises.push(this.executeQuery(db.collection(collection.name), 'dropIndex', index.name));
                 }
             }
         }
@@ -113,11 +114,21 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             });
         }
     }
+    mapIndexProperties(index, meta) {
+        return Utils.flatten(Utils.asArray(index.properties).map(propName => {
+            const rootPropName = propName.substring(0, propName.indexOf('.'));
+            const prop = meta.properties[rootPropName];
+            if (propName.includes('.')) {
+                return [prop.fieldNames[0] + propName.substring(propName.indexOf('.'))];
+            }
+            return prop?.fieldNames ?? propName;
+        }));
+    }
     createIndexes(meta) {
         const res = [];
         meta.indexes.forEach(index => {
             let fieldOrSpec;
-            const properties = Utils.flatten(Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+            const properties = this.mapIndexProperties(index, meta);
             const collection = this.connection.getCollection(meta.className);
             if (Array.isArray(index.options) && index.options.length === 2 && properties.length === 0) {
                 res.push([collection.collectionName, collection.createIndex(index.options[0], index.options[1])]);
@@ -138,7 +149,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             else {
                 fieldOrSpec = properties.reduce((o, i) => { o[i] = 1; return o; }, {});
             }
-            res.push([collection.collectionName, collection.createIndex(fieldOrSpec, {
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: index.name,
                     unique: false,
                     ...index.options,
@@ -146,13 +157,26 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         });
         return res;
     }
+    async executeQuery(collection, method, ...args) {
+        const now = Date.now();
+        return collection[method](...args).then((res) => {
+            Utils.dropUndefinedProperties(args);
+            const query = `db.getCollection('${collection.collectionName}').${method}(${args.map(arg => inspect(arg)).join(', ')});`;
+            this.config.getLogger().logQuery({
+                level: 'info',
+                query,
+                took: Date.now() - now,
+            });
+            return res;
+        });
+    }
     createUniqueIndexes(meta) {
         const res = [];
         meta.uniques.forEach(index => {
-            const properties = Utils.flatten(Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+            const properties = this.mapIndexProperties(index, meta);
             const fieldOrSpec = properties.reduce((o, i) => { o[i] = 1; return o; }, {});
             const collection = this.connection.getCollection(meta.className);
-            res.push([collection.collectionName, collection.createIndex(fieldOrSpec, {
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: index.name,
                     unique: true,
                     ...index.options,
@@ -168,7 +192,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         const fieldOrSpec = prop.embeddedPath
             ? prop.embeddedPath.join('.')
             : prop.fieldNames.reduce((o, i) => { o[i] = 1; return o; }, {});
-        return [[collection.collectionName, collection.createIndex(fieldOrSpec, {
+        return [[collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: (Utils.isString(prop[type]) ? prop[type] : undefined),
                     unique: type === 'unique',
                     sparse: prop.nullable === true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/mongodb",
   "type": "module",
-  "version": "7.0.0-dev.34",
+  "version": "7.0.0-dev.36",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -53,9 +53,9 @@
     "mongodb": "6.20.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7"
+    "@mikro-orm/core": "^6.5.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.34"
+    "@mikro-orm/core": "7.0.0-dev.36"
   }
 }