@yandjin-mikro-orm/mongodb 6.1.4-rc-sti-changes-1

package/MongoDriver.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDriver = void 0;
+const bson_1 = require("bson");
+const core_1 = require("@yandjin-mikro-orm/core");
+const MongoConnection_1 = require("./MongoConnection");
+const MongoPlatform_1 = require("./MongoPlatform");
+const MongoEntityManager_1 = require("./MongoEntityManager");
+class MongoDriver extends core_1.DatabaseDriver {
+    [core_1.EntityManagerType];
+    connection = new MongoConnection_1.MongoConnection(this.config);
+    platform = new MongoPlatform_1.MongoPlatform();
+    constructor(config) {
+        super(config, ["mongodb"]);
+    }
+    createEntityManager(useContext) {
+        const EntityManagerClass = this.config.get("entityManager", MongoEntityManager_1.MongoEntityManager);
+        return new EntityManagerClass(this.config, this, this.metadata, useContext);
+    }
+    async find(entityName, where, options = {}) {
+        if (this.metadata.find(entityName)?.virtual) {
+            return this.findVirtual(entityName, where, options);
+        }
+        const { first, last, before, after } = options;
+        const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
+        where = this.renameFields(entityName, where, true);
+        const isCursorPagination = [first, last, before, after].some((v) => v != null);
+        if (isCursorPagination) {
+            const andWhere = (cond1, cond2) => {
+                if (core_1.Utils.isEmpty(cond1)) {
+                    return cond2;
+                }
+                if (core_1.Utils.isEmpty(cond2)) {
+                    return cond1;
+                }
+                return { $and: [cond1, cond2] };
+            };
+            const meta = this.metadata.find(entityName);
+            const { orderBy: newOrderBy, where: newWhere } = this.processCursorOptions(meta, options, options.orderBy);
+            const newWhereConverted = this.renameFields(entityName, newWhere, true);
+            const orderBy = core_1.Utils.asArray(newOrderBy).map((order) => this.renameFields(entityName, order));
+            const res = await this.rethrow(this.getConnection("read").find(entityName, andWhere(where, newWhereConverted), orderBy, options.limit, options.offset, fields, options.ctx, options.logging));
+            if (isCursorPagination && !first && !!last) {
+                res.reverse();
+            }
+            return res.map((r) => this.mapResult(r, this.metadata.find(entityName)));
+        }
+        const orderBy = core_1.Utils.asArray(options.orderBy).map((orderBy) => this.renameFields(entityName, orderBy, false));
+        const res = await this.rethrow(this.getConnection("read").find(entityName, where, orderBy, options.limit, options.offset, fields, options.ctx));
+        return res.map((r) => this.mapResult(r, this.metadata.find(entityName)));
+    }
+    async findOne(entityName, where, options = { populate: [], orderBy: {} }) {
+        if (this.metadata.find(entityName)?.virtual) {
+            const [item] = await this.findVirtual(entityName, where, options);
+            /* istanbul ignore next */
+            return item ?? null;
+        }
+        if (core_1.Utils.isPrimaryKey(where)) {
+            where = this.buildFilterById(entityName, where);
+        }
+        const fields = this.buildFields(entityName, options.populate || [], options.fields, options.exclude);
+        where = this.renameFields(entityName, where, true);
+        const orderBy = core_1.Utils.asArray(options.orderBy).map((orderBy) => this.renameFields(entityName, orderBy, false));
+        const res = await this.rethrow(this.getConnection("read").find(entityName, where, orderBy, 1, undefined, fields, options.ctx, options.logging));
+        return this.mapResult(res[0], this.metadata.find(entityName));
+    }
+    async findVirtual(entityName, where, options) {
+        const meta = this.metadata.find(entityName);
+        if (meta.expression instanceof Function) {
+            const em = this.createEntityManager();
+            return meta.expression(em, where, options);
+        }
+        /* istanbul ignore next */
+        return super.findVirtual(entityName, where, options);
+    }
+    async count(entityName, where, options = {}, ctx) {
+        /* istanbul ignore next */
+        if (this.metadata.find(entityName)?.virtual) {
+            return this.countVirtual(entityName, where, options);
+        }
+        where = this.renameFields(entityName, where, true);
+        return this.rethrow(this.getConnection("read").countDocuments(entityName, where, ctx));
+    }
+    async nativeInsert(entityName, data, options = {}) {
+        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));
+        const meta = this.metadata.find(entityName);
+        /* istanbul ignore next */
+        const pk = meta?.getPrimaryProps()[0].fieldNames[0] ?? "_id";
+        const res = await this.rethrow(this.getConnection("write").insertMany(entityName, data, options.ctx));
+        res.rows = res.insertedIds.map((id) => ({ [pk]: id }));
+        return res;
+    }
+    async nativeUpdate(entityName, where, data, options = {}) {
+        if (core_1.Utils.isPrimaryKey(where)) {
+            where = this.buildFilterById(entityName, where);
+        }
+        where = this.renameFields(entityName, where, true);
+        data = this.renameFields(entityName, data);
+        options = { ...options };
+        const meta = this.metadata.find(entityName);
+        /* istanbul ignore next */
+        const rename = (field) => meta
+            ? (meta.properties[field]?.fieldNames[0] ??
+                field)
+            : field;
+        if (options.onConflictFields) {
+            options.onConflictFields = options.onConflictFields.map(rename);
+        }
+        if (options.onConflictMergeFields) {
+            options.onConflictMergeFields = options.onConflictMergeFields.map(rename);
+        }
+        if (options.onConflictExcludeFields) {
+            options.onConflictExcludeFields =
+                options.onConflictExcludeFields.map(rename);
+        }
+        return this.rethrow(this.getConnection("write").updateMany(entityName, where, data, options.ctx, options.upsert, options));
+    }
+    async nativeUpdateMany(entityName, where, data, options = {}) {
+        where = where.map((row) => {
+            if (core_1.Utils.isPlainObject(row)) {
+                return this.renameFields(entityName, row, true);
+            }
+            return row;
+        });
+        data = data.map((row) => this.renameFields(entityName, row));
+        options = { ...options };
+        const meta = this.metadata.find(entityName);
+        /* istanbul ignore next */
+        const rename = (field) => meta
+            ? (meta.properties[field]?.fieldNames[0] ??
+                field)
+            : field;
+        if (options.onConflictFields) {
+            options.onConflictFields = options.onConflictFields.map(rename);
+        }
+        if (options.onConflictMergeFields) {
+            options.onConflictMergeFields = options.onConflictMergeFields.map(rename);
+        }
+        if (options.onConflictExcludeFields) {
+            options.onConflictExcludeFields =
+                options.onConflictExcludeFields.map(rename);
+        }
+        return this.rethrow(this.getConnection("write").bulkUpdateMany(entityName, where, data, options.ctx, options.upsert, options));
+    }
+    async nativeDelete(entityName, where, options = {}) {
+        if (core_1.Utils.isPrimaryKey(where)) {
+            where = this.buildFilterById(entityName, where);
+        }
+        where = this.renameFields(entityName, where, true);
+        return this.rethrow(this.getConnection("write").deleteMany(entityName, where, options.ctx));
+    }
+    async aggregate(entityName, pipeline, ctx) {
+        return this.rethrow(this.getConnection("read").aggregate(entityName, pipeline, ctx));
+    }
+    getPlatform() {
+        return this.platform;
+    }
+    renameFields(entityName, data, where = false, object) {
+        // copy to new variable to prevent changing the T type or doing as unknown casts
+        const copiedData = Object.assign({}, data); // copy first
+        const meta = this.metadata.find(entityName);
+        if (meta?.serializedPrimaryKey &&
+            !meta.embeddable &&
+            meta.serializedPrimaryKey !== meta.primaryKeys[0]) {
+            core_1.Utils.renameKey(copiedData, meta.serializedPrimaryKey, meta.primaryKeys[0]);
+        }
+        if (meta && !meta.embeddable) {
+            this.inlineEmbeddables(meta, copiedData, where);
+        }
+        // If we had a query with $fulltext and some filter we end up with $and with $fulltext in it.
+        // We will try to move $fulltext to top level.
+        if (copiedData.$and) {
+            for (let i = 0; i < copiedData.$and.length; i++) {
+                const and = copiedData.$and[i];
+                if ("$fulltext" in and) {
+                    /* istanbul ignore next */
+                    if ("$fulltext" in copiedData) {
+                        throw new Error("Cannot merge multiple $fulltext conditions to top level of the query object.");
+                    }
+                    copiedData.$fulltext = and.$fulltext;
+                    delete and.$fulltext;
+                }
+            }
+        }
+        // move search terms from data['$fulltext'] to mongo's structure: data['$text']['search']
+        if ("$fulltext" in copiedData) {
+            copiedData.$text = { $search: copiedData.$fulltext };
+            delete copiedData.$fulltext;
+        }
+        // mongo only allows the $text operator in the root of the object and will
+        // search all documents where the field has a text index.
+        if (core_1.Utils.hasNestedKey(copiedData, "$fulltext")) {
+            throw new Error("Full text search is only supported on the top level of the query object.");
+        }
+        core_1.Utils.keys(copiedData).forEach((k) => {
+            if (core_1.Utils.isGroupOperator(k)) {
+                /* istanbul ignore else */
+                if (Array.isArray(copiedData[k])) {
+                    copiedData[k] = copiedData[k].map((v) => this.renameFields(entityName, v));
+                }
+                else {
+                    copiedData[k] = this.renameFields(entityName, copiedData[k]);
+                }
+                return;
+            }
+            if (meta?.properties[k]) {
+                const prop = meta.properties[k];
+                let isObjectId = false;
+                if (prop.kind === core_1.ReferenceKind.SCALAR) {
+                    isObjectId = prop.type.toLowerCase() === "objectid";
+                }
+                else if (prop.kind === core_1.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, where, true));
+                    }
+                    else {
+                        copiedData[prop.name] = this.renameFields(prop.type, copiedData[prop.name], where, prop.object || object);
+                    }
+                }
+                else {
+                    const meta2 = this.metadata.find(prop.type);
+                    const pk = meta2.properties[meta2.primaryKeys[0]];
+                    isObjectId = pk.type.toLowerCase() === "objectid";
+                }
+                if (isObjectId) {
+                    copiedData[k] = this.convertObjectIds(copiedData[k]);
+                }
+                if (prop.fieldNames) {
+                    core_1.Utils.renameKey(copiedData, k, prop.fieldNames[0]);
+                }
+            }
+            if (core_1.Utils.isPlainObject(copiedData[k]) && "$re" in copiedData[k]) {
+                copiedData[k] = new RegExp(copiedData[k].$re);
+            }
+        });
+        return copiedData;
+    }
+    convertObjectIds(data) {
+        if (data instanceof bson_1.ObjectId) {
+            return data;
+        }
+        if (core_1.Utils.isString(data) && data.match(/^[0-9a-f]{24}$/i)) {
+            return new bson_1.ObjectId(data);
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => this.convertObjectIds(item));
+        }
+        if (core_1.Utils.isObject(data)) {
+            Object.keys(data).forEach((k) => {
+                data[k] = this.convertObjectIds(data[k]);
+            });
+        }
+        return data;
+    }
+    buildFilterById(entityName, id) {
+        const meta = this.metadata.find(entityName);
+        if (meta.properties[meta.primaryKeys[0]].type.toLowerCase() === "objectid") {
+            return { _id: new bson_1.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 ret = [];
+        if (fields) {
+            for (let field of fields) {
+                /* istanbul ignore next */
+                if (core_1.Utils.isPlainObject(field)) {
+                    continue;
+                }
+                if (field.toString().includes(".")) {
+                    field = field
+                        .toString()
+                        .substring(0, field.toString().indexOf("."));
+                }
+                let prop = meta.properties[field];
+                /* istanbul ignore else */
+                if (prop) {
+                    if (!prop.fieldNames) {
+                        continue;
+                    }
+                    prop = prop.serializedPrimaryKey ? meta.getPrimaryProps()[0] : prop;
+                    ret.push(prop.fieldNames[0]);
+                }
+                else if (field === "*") {
+                    const props = meta.props.filter((prop) => this.platform.shouldHaveColumn(prop, populate));
+                    ret.push(...core_1.Utils.flatten(props
+                        .filter((p) => !lazyProps.includes(p))
+                        .map((p) => p.fieldNames)));
+                }
+                else {
+                    ret.push(field);
+                }
+            }
+            ret.unshift(...meta.primaryKeys.filter((pk) => !fields.includes(pk)));
+        }
+        else if (!core_1.Utils.isEmpty(exclude) || lazyProps.some((p) => !p.formula)) {
+            const props = meta.props.filter((prop) => this.platform.shouldHaveColumn(prop, populate, exclude));
+            ret.push(...core_1.Utils.flatten(props.filter((p) => !lazyProps.includes(p)).map((p) => p.fieldNames)));
+        }
+        return ret.length > 0 ? ret : undefined;
+    }
+}
+exports.MongoDriver = MongoDriver;

package/MongoEntityManager.d.ts

@@ -0,0 +1,26 @@
+import { EntityManager, type EntityName, type EntityRepository, type GetRepository, type TransactionOptions, type EntityManagerType } from "@yandjin-mikro-orm/core";
+import type { Collection, Document, TransactionOptions as MongoTransactionOptions } from "mongodb";
+import type { MongoDriver } from "./MongoDriver";
+import type { MongoEntityRepository } from "./MongoEntityRepository";
+/**
+ * @inheritDoc
+ */
+export declare class MongoEntityManager<Driver extends MongoDriver = MongoDriver> extends EntityManager<Driver> {
+    /**
+     * Shortcut to driver's aggregate method. Available in MongoDriver only.
+     */
+    aggregate(entityName: EntityName<any>, pipeline: any[]): Promise<any[]>;
+    getCollection<T extends Document>(entityName: EntityName<T>): Collection<T>;
+    /**
+     * @inheritDoc
+     */
+    getRepository<T extends object, U extends EntityRepository<T> = MongoEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
+    /**
+     * @inheritDoc
+     */
+    begin(options?: Omit<TransactionOptions, "ignoreNestedTransactions"> & MongoTransactionOptions): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    transactional<T>(cb: (em: Driver[typeof EntityManagerType]) => Promise<T>, options?: TransactionOptions & MongoTransactionOptions): Promise<T>;
+}

package/MongoEntityManager.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoEntityManager = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+/**
+ * @inheritDoc
+ */
+class MongoEntityManager extends core_1.EntityManager {
+    /**
+     * Shortcut to driver's aggregate method. Available in MongoDriver only.
+     */
+    async aggregate(entityName, pipeline) {
+        entityName = core_1.Utils.className(entityName);
+        return this.getDriver().aggregate(entityName, pipeline);
+    }
+    getCollection(entityName) {
+        return this.getConnection().getCollection(entityName);
+    }
+    /**
+     * @inheritDoc
+     */
+    getRepository(entityName) {
+        return super.getRepository(entityName);
+    }
+    /**
+     * @inheritDoc
+     */
+    async begin(options = {}) {
+        return super.begin(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    async transactional(cb, options = {}) {
+        return super.transactional(cb, options);
+    }
+}
+exports.MongoEntityManager = MongoEntityManager;

package/MongoEntityRepository.d.ts

@@ -0,0 +1,16 @@
+import { EntityRepository, type EntityName } from "@yandjin-mikro-orm/core";
+import type { Collection } from "mongodb";
+import type { MongoEntityManager } from "./MongoEntityManager";
+export declare class MongoEntityRepository<T extends object> extends EntityRepository<T> {
+    protected readonly em: MongoEntityManager;
+    constructor(em: MongoEntityManager, entityName: EntityName<T>);
+    /**
+     * Shortcut to driver's aggregate method. Available in MongoDriver only.
+     */
+    aggregate(pipeline: any[]): Promise<any[]>;
+    getCollection(): Collection<T>;
+    /**
+     * @inheritDoc
+     */
+    getEntityManager(): MongoEntityManager;
+}

package/MongoEntityRepository.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoEntityRepository = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class MongoEntityRepository extends core_1.EntityRepository {
+    em;
+    constructor(em, entityName) {
+        super(em, entityName);
+        this.em = em;
+    }
+    /**
+     * Shortcut to driver's aggregate method. Available in MongoDriver only.
+     */
+    async aggregate(pipeline) {
+        return this.getEntityManager().aggregate(this.entityName, pipeline);
+    }
+    getCollection() {
+        return this.getEntityManager().getCollection(this.entityName);
+    }
+    /**
+     * @inheritDoc
+     */
+    getEntityManager() {
+        return this.em;
+    }
+}
+exports.MongoEntityRepository = MongoEntityRepository;

package/MongoExceptionConverter.d.ts

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

package/MongoExceptionConverter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoExceptionConverter = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class MongoExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @link https://gist.github.com/rluvaton/a97a8da46ab6541a3e5702e83b9d357b
+     */
+    convertException(exception) {
+        switch (exception.code) {
+            case 48:
+                return new core_1.TableExistsException(exception);
+            case 11000:
+                return new core_1.UniqueConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.MongoExceptionConverter = MongoExceptionConverter;

package/MongoMikroORM.d.ts

@@ -0,0 +1,19 @@
+import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from "@yandjin-mikro-orm/core";
+import { MongoDriver } from "./MongoDriver";
+import type { MongoEntityManager } from "./MongoEntityManager";
+/**
+ * @inheritDoc
+ */
+export declare class MongoMikroORM<EM extends EntityManager = MongoEntityManager> extends MikroORM<MongoDriver, EM> {
+    private static DRIVER;
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    /**
+     * @inheritDoc
+     */
+    static initSync<D extends IDatabaseDriver = MongoDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+}
+export type MongoOptions = Options<MongoDriver>;
+export declare function defineMongoConfig(options: MongoOptions): Options<MongoDriver, MongoEntityManager<MongoDriver> & EntityManager<IDatabaseDriver<import("@yandjin-mikro-orm/core").Connection>>>;

package/MongoMikroORM.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineMongoConfig = exports.MongoMikroORM = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const MongoDriver_1 = require("./MongoDriver");
+/**
+ * @inheritDoc
+ */
+class MongoMikroORM extends core_1.MikroORM {
+    static DRIVER = MongoDriver_1.MongoDriver;
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    static initSync(options) {
+        return super.initSync(options);
+    }
+}
+exports.MongoMikroORM = MongoMikroORM;
+/* istanbul ignore next */
+function defineMongoConfig(options) {
+    return (0, core_1.defineConfig)({ driver: MongoDriver_1.MongoDriver, ...options });
+}
+exports.defineMongoConfig = defineMongoConfig;

package/MongoPlatform.d.ts

@@ -0,0 +1,28 @@
+import { ObjectId } from "bson";
+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 "@yandjin-mikro-orm/core";
+import { MongoExceptionConverter } from "./MongoExceptionConverter";
+import { MongoSchemaGenerator } from "./MongoSchemaGenerator";
+export declare class MongoPlatform extends Platform {
+    protected readonly exceptionConverter: MongoExceptionConverter;
+    setConfig(config: Configuration): void;
+    getNamingStrategy(): {
+        new (): NamingStrategy;
+    };
+    getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
+    /** @inheritDoc */
+    lookupExtensions(orm: MikroORM): void;
+    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): unknown;
+    marshallArray(values: string[]): string;
+    cloneEmbeddable<T>(data: T): T;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: PopulateOptions<T>[], exclude?: string[]): boolean;
+    validateMetadata(meta: EntityMetadata): void;
+    isAllowedTopLevelOperator(operator: string): boolean;
+}

package/MongoPlatform.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoPlatform = void 0;
+const bson_1 = require("bson");
+const core_1 = require("@yandjin-mikro-orm/core");
+const MongoExceptionConverter_1 = require("./MongoExceptionConverter");
+const MongoEntityRepository_1 = require("./MongoEntityRepository");
+const MongoSchemaGenerator_1 = require("./MongoSchemaGenerator");
+class MongoPlatform extends core_1.Platform {
+    exceptionConverter = new MongoExceptionConverter_1.MongoExceptionConverter();
+    setConfig(config) {
+        config.set("autoJoinOneToOneOwner", false);
+        config.set("loadStrategy", "select-in");
+        config.get("discovery").inferDefaultValues = false;
+        super.setConfig(config);
+    }
+    getNamingStrategy() {
+        return core_1.MongoNamingStrategy;
+    }
+    getRepositoryClass() {
+        return MongoEntityRepository_1.MongoEntityRepository;
+    }
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        MongoSchemaGenerator_1.MongoSchemaGenerator.register(orm);
+    }
+    /* istanbul ignore next: kept for type inference only */
+    getSchemaGenerator(driver, em) {
+        return new MongoSchemaGenerator_1.MongoSchemaGenerator(em ?? driver);
+    }
+    normalizePrimaryKey(data) {
+        if (data instanceof bson_1.ObjectId) {
+            return data.toHexString();
+        }
+        return data;
+    }
+    denormalizePrimaryKey(data) {
+        return new bson_1.ObjectId(data);
+    }
+    getSerializedPrimaryKeyField(field) {
+        return "id";
+    }
+    usesDifferentSerializedPrimaryKey() {
+        return true;
+    }
+    usesImplicitTransactions() {
+        return false;
+    }
+    convertsJsonAutomatically() {
+        return true;
+    }
+    convertJsonToDatabaseValue(value) {
+        return value;
+    }
+    convertJsonToJSValue(value) {
+        return value;
+    }
+    marshallArray(values) {
+        return values;
+    }
+    cloneEmbeddable(data) {
+        const ret = super.cloneEmbeddable(data);
+        core_1.Utils.dropUndefinedProperties(ret);
+        return ret;
+    }
+    shouldHaveColumn(prop, populate, exclude) {
+        if (super.shouldHaveColumn(prop, populate, exclude)) {
+            return true;
+        }
+        return prop.kind === core_1.ReferenceKind.MANY_TO_MANY && prop.owner;
+    }
+    validateMetadata(meta) {
+        const pk = meta.getPrimaryProps()[0];
+        if (pk && pk.fieldNames?.[0] !== "_id") {
+            throw core_1.MetadataError.invalidPrimaryKey(meta, pk, "_id");
+        }
+    }
+    isAllowedTopLevelOperator(operator) {
+        return ["$not", "$fulltext"].includes(operator);
+    }
+}
+exports.MongoPlatform = MongoPlatform;

package/MongoSchemaGenerator.d.ts

@@ -0,0 +1,32 @@
+import { AbstractSchemaGenerator, type CreateSchemaOptions, type MikroORM } from "@yandjin-mikro-orm/core";
+import type { MongoDriver } from "./MongoDriver";
+export declare class MongoSchemaGenerator extends AbstractSchemaGenerator<MongoDriver> {
+    static register(orm: MikroORM): void;
+    createSchema(options?: MongoCreateSchemaOptions): Promise<void>;
+    dropSchema(options?: {
+        dropMigrationsTable?: boolean;
+    }): Promise<void>;
+    updateSchema(options?: MongoCreateSchemaOptions): Promise<void>;
+    ensureDatabase(): Promise<boolean>;
+    refreshDatabase(options?: MongoCreateSchemaOptions): Promise<void>;
+    dropIndexes(options?: {
+        skipIndexes?: {
+            collection: string;
+            indexName: string;
+        }[];
+        collectionsWithFailedIndexes?: string[];
+    }): Promise<void>;
+    ensureIndexes(options?: EnsureIndexesOptions): Promise<void>;
+    private createIndexes;
+    private createUniqueIndexes;
+    private createPropertyIndexes;
+}
+export interface MongoCreateSchemaOptions extends CreateSchemaOptions {
+    /** create indexes? defaults to true */
+    ensureIndexes?: boolean;
+}
+export interface EnsureIndexesOptions {
+    ensureCollections?: boolean;
+    retry?: boolean | string[];
+    retryLimit?: number;
+}