@mikro-orm/mongodb 7.0.0-dev.12 → 7.0.0-dev.120

package/MongoDriver.js

@@ -1,8 +1,9 @@
 import { ObjectId } from 'mongodb';
-import { DatabaseDriver, EntityManagerType, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { DatabaseDriver, EntityManagerType, GroupOperator, 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';
 export class MongoDriver extends DatabaseDriver {
     [EntityManagerType];
     connection = new MongoConnection(this.config);
@@ -14,6 +15,24 @@ 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;
+        }
+        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);
@@ -70,8 +89,19 @@ export class MongoDriver extends DatabaseDriver {
         /* 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 = {}, ctx) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (this.metadata.find(entityName)?.virtual) {
             return this.countVirtual(entityName, where, options);
         }
@@ -79,11 +109,15 @@ export class MongoDriver extends DatabaseDriver {
         return this.rethrow(this.getConnection('read').countDocuments(entityName, where, ctx));
     }
     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(d => this.renameFields(entityName, d));
+        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';
@@ -95,8 +129,9 @@ export class MongoDriver extends DatabaseDriver {
         if (Utils.isPrimaryKey(where)) {
             where = this.buildFilterById(entityName, where);
         }
-        where = this.renameFields(entityName, where, true);
+        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 */
@@ -119,7 +154,10 @@ export class MongoDriver extends DatabaseDriver {
             }
             return row;
         });
-        data = data.map(row => this.renameFields(entityName, 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 */
@@ -157,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;
     }
@@ -176,7 +217,7 @@ export class MongoDriver extends DatabaseDriver {
             for (let i = 0; i < copiedData.$and.length; i++) {
                 const and = copiedData.$and[i];
                 if ('$fulltext' in and) {
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     if ('$fulltext' in copiedData) {
                         throw new Error('Cannot merge multiple $fulltext conditions to top level of the query object.');
                     }
@@ -196,8 +237,8 @@ export class MongoDriver extends DatabaseDriver {
             throw new Error('Full text search is only supported on the top level of the query object.');
         }
         Utils.keys(copiedData).forEach(k => {
-            if (Utils.isGroupOperator(k)) {
-                /* v8 ignore next 5 */
+            if (k in GroupOperator) {
+                /* v8 ignore next */
                 if (Array.isArray(copiedData[k])) {
                     copiedData[k] = copiedData[k].map(v => this.renameFields(entityName, v));
                 }
@@ -210,23 +251,23 @@ export class MongoDriver extends DatabaseDriver {
                 const prop = meta.properties[k];
                 let isObjectId = false;
                 if (prop.kind === ReferenceKind.SCALAR) {
-                    isObjectId = prop.type.toLowerCase() === 'objectid';
+                    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.type, item, dotPaths, true));
+                        copiedData[prop.name] = copiedData[prop.name].map((item) => this.renameFields(prop.targetMeta.class, item, dotPaths, true));
                     }
                     else {
-                        copiedData[prop.name] = this.renameFields(prop.type, copiedData[prop.name], dotPaths, prop.object || object);
+                        copiedData[prop.name] = this.renameFields(prop.targetMeta.class, copiedData[prop.name], dotPaths, prop.object || object);
                     }
                 }
                 else {
-                    const meta2 = this.metadata.find(prop.type);
+                    const meta2 = this.metadata.find(prop.targetMeta.class);
                     const pk = meta2.properties[meta2.primaryKeys[0]];
-                    isObjectId = pk.type.toLowerCase() === 'objectid';
+                    isObjectId = pk.type === 'ObjectId';
                 }
                 if (isObjectId) {
                     copiedData[k] = this.convertObjectIds(copiedData[k]);
@@ -245,7 +286,7 @@ export class MongoDriver extends DatabaseDriver {
         if (data instanceof ObjectId) {
             return data;
         }
-        if (Utils.isString(data) && data.match(/^[0-9a-f]{24}$/i)) {
+        if (typeof data === 'string' && data.match(/^[0-9a-f]{24}$/i)) {
             return new ObjectId(data);
         }
         if (Array.isArray(data)) {
@@ -260,21 +301,18 @@ export class MongoDriver extends DatabaseDriver {
     }
     buildFilterById(entityName, id) {
         const meta = this.metadata.find(entityName);
-        if (meta.properties[meta.primaryKeys[0]].type.toLowerCase() === 'objectid') {
+        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.find(entityName);
-        if (!meta) {
-            return fields;
-        }
-        const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
+        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 3 */
+                /* v8 ignore next */
                 if (Utils.isPlainObject(field)) {
                     continue;
                 }
@@ -282,7 +320,7 @@ export class MongoDriver extends DatabaseDriver {
                     field = field.toString().substring(0, field.toString().indexOf('.'));
                 }
                 let prop = meta.properties[field];
-                /* v8 ignore start */
+                /* v8 ignore next */
                 if (prop) {
                     if (!prop.fieldNames) {
                         continue;
@@ -297,7 +335,6 @@ export class MongoDriver extends DatabaseDriver {
                 else {
                     ret.push(field);
                 }
-                /* v8 ignore stop */
             }
             ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
         }
@@ -307,4 +344,21 @@ export class MongoDriver extends DatabaseDriver {
         }
         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;
+    }
 }

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';
@@ -9,7 +9,15 @@ 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[]>;
+    aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
+    /**
+     * Shortcut to driver's aggregate method. Returns a stream. Available in MongoDriver only.
+     */
+    streamAggregate<T extends object>(entityName: EntityName, 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
  */
@@ -7,8 +7,22 @@ export class MongoEntityManager extends EntityManager {
      * Shortcut to driver's aggregate method. Available in MongoDriver only.
      */
     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) {
+        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/MongoExceptionConverter.d.ts

@@ -1,7 +1,7 @@
 import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
 export declare class MongoExceptionConverter extends ExceptionConverter {
     /**
-     * @link https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
+     * @see https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
      */
     convertException(exception: Error & Dictionary): DriverException;
 }

package/MongoExceptionConverter.js

@@ -1,9 +1,9 @@
 import { UniqueConstraintViolationException, ExceptionConverter, TableExistsException } from '@mikro-orm/core';
-/* v8 ignore start */
 export class MongoExceptionConverter extends ExceptionConverter {
     /**
-     * @link https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
+     * @see https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
      */
+    /* v8 ignore next */
     convertException(exception) {
         switch (exception.code) {
             case 48:
@@ -14,4 +14,3 @@ export class MongoExceptionConverter extends ExceptionConverter {
         return super.convertException(exception);
     }
 }
-/* v8 ignore stop */

package/MongoMikroORM.d.ts

@@ -1,19 +1,22 @@
-import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType, type IMigrator } from '@mikro-orm/core';
 import { MongoDriver } from './MongoDriver.js';
 import type { MongoEntityManager } from './MongoEntityManager.js';
+export type MongoOptions<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Options<MongoDriver, EM, Entities>;
+export declare function defineMongoConfig<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: MongoOptions<EM, Entities>): Options<MongoDriver, EM, Entities>;
 /**
  * @inheritDoc
  */
-export declare class MongoMikroORM<EM extends EntityManager = MongoEntityManager> extends MikroORM<MongoDriver, EM> {
-    private static DRIVER;
+export declare class MongoMikroORM<EM extends MongoEntityManager = MongoEntityManager, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MongoDriver, EM, Entities> {
     /**
      * @inheritDoc
      */
-    static init<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    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: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * @inheritDoc
      */
-    static initSync<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    constructor(options: Options<MongoDriver, EM, Entities>);
+    /**
+     * Gets the Migrator.
+     */
+    get migrator(): IMigrator;
 }
-export type MongoOptions = Options<MongoDriver>;
-export declare function defineMongoConfig(options: MongoOptions): Options<MongoDriver, MongoEntityManager<MongoDriver> & EntityManager<IDatabaseDriver<import("@mikro-orm/core").Connection>>>;

package/MongoMikroORM.js

@@ -1,24 +1,28 @@
 import { defineConfig, MikroORM, } from '@mikro-orm/core';
 import { MongoDriver } from './MongoDriver.js';
+export function defineMongoConfig(options) {
+    return defineConfig({ driver: MongoDriver, ...options });
+}
 /**
  * @inheritDoc
  */
 export class MongoMikroORM extends MikroORM {
-    static DRIVER = MongoDriver;
     /**
      * @inheritDoc
      */
     static async init(options) {
-        return super.init(options);
+        return super.init(defineMongoConfig(options));
     }
     /**
      * @inheritDoc
      */
-    static initSync(options) {
-        return super.initSync(options);
+    constructor(options) {
+        super(defineMongoConfig(options));
+    }
+    /**
+     * Gets the Migrator.
+     */
+    get migrator() {
+        return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations-mongodb', this.em);
     }
-}
-/* v8 ignore next 3 */
-export function defineMongoConfig(options) {
-    return defineConfig({ driver: MongoDriver, ...options });
 }

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 {
@@ -16,12 +16,10 @@ export declare class MongoPlatform extends Platform {
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): MongoSchemaGenerator;
     normalizePrimaryKey<T extends number | string = number | string>(data: Primary<T> | IPrimaryKey | ObjectId): T;
     denormalizePrimaryKey(data: number | string): IPrimaryKey;
-    getSerializedPrimaryKeyField(field: string): string;
-    usesDifferentSerializedPrimaryKey(): boolean;
     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

@@ -32,24 +32,18 @@ export class MongoPlatform extends Platform {
         /* v8 ignore next */
         return super.getExtension(extensionName, extensionKey, moduleName, em);
     }
-    /* v8 ignore next 3: kept for type inference only */
+    /* v8 ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
         return new MongoSchemaGenerator(em ?? driver);
     }
     normalizePrimaryKey(data) {
-        if (Utils.isObjectID(data)) {
+        if (Utils.isObject(data) && data.constructor?.name === 'ObjectId') {
             return data.toHexString();
         }
         return data;
     }
     denormalizePrimaryKey(data) {
-        return new ObjectId(data);
-    }
-    getSerializedPrimaryKeyField(field) {
-        return 'id';
-    }
-    usesDifferentSerializedPrimaryKey() {
-        return true;
+        return new ObjectId('' + data);
     }
     usesImplicitTransactions() {
         return false;
@@ -60,7 +54,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

@@ -2,13 +2,13 @@ import { AbstractSchemaGenerator, type CreateSchemaOptions, type MikroORM } from
 import type { MongoDriver } from './MongoDriver.js';
 export declare class MongoSchemaGenerator extends AbstractSchemaGenerator<MongoDriver> {
     static register(orm: MikroORM): void;
-    createSchema(options?: MongoCreateSchemaOptions): Promise<void>;
-    dropSchema(options?: {
+    create(options?: MongoCreateSchemaOptions): Promise<void>;
+    drop(options?: {
         dropMigrationsTable?: boolean;
     }): Promise<void>;
-    updateSchema(options?: MongoCreateSchemaOptions): Promise<void>;
+    update(options?: MongoCreateSchemaOptions): Promise<void>;
     ensureDatabase(): Promise<boolean>;
-    refreshDatabase(options?: MongoCreateSchemaOptions): Promise<void>;
+    refresh(options?: MongoCreateSchemaOptions): Promise<void>;
     dropIndexes(options?: {
         skipIndexes?: {
             collection: string;
@@ -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,30 +1,29 @@
-import { AbstractSchemaGenerator, Utils, } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, Utils, inspect, } from '@mikro-orm/core';
 export class MongoSchemaGenerator extends AbstractSchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new MongoSchemaGenerator(orm.em));
     }
-    async createSchema(options = {}) {
+    async create(options = {}) {
         await this.connection.ensureConnection();
         options.ensureIndexes ??= true;
         const existing = await this.connection.listCollections();
         const metadata = this.getOrderedMetadata();
-        /* v8 ignore start */
+        /* v8 ignore next */
         const promises = metadata
             .filter(meta => !existing.includes(meta.collection))
-            .map(meta => this.connection.createCollection(meta.collection).catch(err => {
+            .map(meta => this.connection.createCollection(meta.class).catch(err => {
             const existsErrorMessage = `Collection ${this.config.get('dbName')}.${meta.collection} already exists.`;
             // ignore errors about the collection already existing
             if (!(err.name === 'MongoServerError' && err.message.includes(existsErrorMessage))) {
                 throw err;
             }
         }));
-        /* v8 ignore stop */
         if (options.ensureIndexes) {
             await this.ensureIndexes({ ensureCollections: false });
         }
         await Promise.all(promises);
     }
-    async dropSchema(options = {}) {
+    async drop(options = {}) {
         await this.connection.ensureConnection();
         const existing = await this.connection.listCollections();
         const metadata = this.getOrderedMetadata();
@@ -33,19 +32,19 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         }
         const promises = metadata
             .filter(meta => existing.includes(meta.collection))
-            .map(meta => this.connection.dropCollection(meta.collection));
+            .map(meta => this.connection.dropCollection(meta.class));
         await Promise.all(promises);
     }
-    async updateSchema(options = {}) {
-        await this.createSchema(options);
+    async update(options = {}) {
+        await this.create(options);
     }
     async ensureDatabase() {
         return false;
     }
-    async refreshDatabase(options = {}) {
+    async refresh(options = {}) {
         await this.ensureDatabase();
-        await this.dropSchema();
-        await this.createSchema(options);
+        await this.drop();
+        await this.create(options);
     }
     async dropIndexes(options) {
         await this.connection.ensureConnection();
@@ -59,9 +58,9 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             const indexes = await db.collection(collection.name).listIndexes().toArray();
             for (const index of indexes) {
                 const isIdIndex = index.key._id === 1 && Utils.getObjectKeysSize(index.key) === 1;
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 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));
                 }
             }
         }
@@ -72,7 +71,7 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         options.ensureCollections ??= true;
         options.retryLimit ??= 3;
         if (options.ensureCollections) {
-            await this.createSchema({ ensureIndexes: false });
+            await this.create({ ensureIndexes: false });
         }
         const promises = [];
         for (const meta of this.getOrderedMetadata()) {
@@ -113,12 +112,22 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
             });
         }
     }
+    mapIndexProperties(index, meta) {
+        return Utils.flatten(Utils.asArray(index.properties).map(propName => {
+            const rootPropName = propName.split('.')[0];
+            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 collection = this.connection.getCollection(meta.className);
+            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])]);
                 return;
@@ -138,7 +147,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 +155,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, {
+            const collection = this.connection.getCollection(meta.class);
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
                     name: index.name,
                     unique: true,
                     ...index.options,
@@ -164,12 +186,12 @@ export class MongoSchemaGenerator extends AbstractSchemaGenerator {
         if (!prop[type] || !meta.collection) {
             return [];
         }
-        const collection = this.connection.getCollection(meta.className);
+        const collection = this.connection.getCollection(meta.class);
         const fieldOrSpec = prop.embeddedPath
             ? prop.embeddedPath.join('.')
             : prop.fieldNames.reduce((o, i) => { o[i] = 1; return o; }, {});
-        return [[collection.collectionName, collection.createIndex(fieldOrSpec, {
-                    name: (Utils.isString(prop[type]) ? prop[type] : undefined),
+        return [[collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, {
+                    name: typeof prop[type] === 'string' ? prop[type] : undefined,
                     unique: type === 'unique',
                     sparse: prop.nullable === true,
                 })]];

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).