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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MongoConnection.d.ts

@@ -0,0 +1,51 @@
+import { MongoClient, type ClientSession, type Collection, type Db, type MongoClientOptions, type TransactionOptions } from "mongodb";
+import { Connection, type AnyEntity, type Configuration, type ConnectionConfig, type ConnectionOptions, type ConnectionType, type EntityData, type EntityName, type FilterQuery, type IsolationLevel, type QueryOrderMap, type QueryResult, type Transaction, type TransactionEventBroadcaster, type UpsertOptions, type UpsertManyOptions, type LoggingOptions } from "@yandjin-mikro-orm/core";
+export declare class MongoConnection extends Connection {
+    protected client: MongoClient;
+    protected db: Db;
+    constructor(config: Configuration, options?: ConnectionOptions, type?: ConnectionType);
+    connect(): Promise<void>;
+    close(force?: boolean): Promise<void>;
+    isConnected(): Promise<boolean>;
+    checkConnection(): Promise<{
+        ok: boolean;
+        reason?: string;
+        error?: Error;
+    }>;
+    getClient(): MongoClient;
+    getCollection<T extends object>(name: EntityName<T>): Collection<T>;
+    createCollection<T extends object>(name: EntityName<T>): Promise<Collection<T>>;
+    listCollections(): Promise<string[]>;
+    dropCollection(name: EntityName<AnyEntity>): Promise<boolean>;
+    getDefaultClientUrl(): string;
+    getConnectionOptions(): MongoClientOptions & ConnectionConfig;
+    getClientUrl(): string;
+    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>[]>;
+    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[]>;
+    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;
+        ctx?: Transaction<ClientSession>;
+        eventBroadcaster?: TransactionEventBroadcaster;
+    } & TransactionOptions): Promise<T>;
+    begin(options?: {
+        isolationLevel?: IsolationLevel;
+        ctx?: ClientSession;
+        eventBroadcaster?: TransactionEventBroadcaster;
+    } & TransactionOptions): Promise<ClientSession>;
+    commit(ctx: ClientSession, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    rollback(ctx: ClientSession, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    private runQuery;
+    private rethrow;
+    private createUpdatePayload;
+    private transformResult;
+    private getCollectionName;
+    private logObject;
+}

package/MongoConnection.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoConnection = void 0;
+const mongodb_1 = require("mongodb");
+const bson_1 = require("bson");
+const util_1 = require("util");
+const core_1 = require("@yandjin-mikro-orm/core");
+class MongoConnection extends core_1.Connection {
+    client;
+    db;
+    constructor(config, options, type = "write") {
+        super(config, options, type);
+        // @ts-ignore
+        bson_1.ObjectId.prototype[util_1.inspect.custom] = function () {
+            return `ObjectId('${this.toHexString()}')`;
+        };
+        // @ts-ignore
+        Date.prototype[util_1.inspect.custom] = function () {
+            return `ISODate('${this.toISOString()}')`;
+        };
+    }
+    async connect() {
+        const driverOptions = this.config.get("driverOptions");
+        if (driverOptions instanceof mongodb_1.MongoClient) {
+            this.logger.log("info", "Reusing MongoClient provided via `driverOptions`");
+            this.client = driverOptions;
+        }
+        else {
+            this.client = new mongodb_1.MongoClient(this.config.getClientUrl(), this.getConnectionOptions());
+            await this.client.connect();
+        }
+        this.db = this.client.db(this.config.get("dbName"));
+        this.connected = true;
+    }
+    async close(force) {
+        await this.client?.close(!!force);
+        this.connected = false;
+    }
+    async isConnected() {
+        try {
+            const res = await this.db?.command({ ping: 1 });
+            return (this.connected = !!res.ok);
+        }
+        catch (error) {
+            return (this.connected = false);
+        }
+    }
+    async checkConnection() {
+        try {
+            const res = await this.db?.command({ ping: 1 });
+            return { ok: !!res.ok };
+        }
+        catch (error) {
+            return { ok: false, reason: error.message, error };
+        }
+    }
+    getClient() {
+        return this.client;
+    }
+    getCollection(name) {
+        return this.db.collection(this.getCollectionName(name));
+    }
+    async createCollection(name) {
+        return this.db.createCollection(this.getCollectionName(name));
+    }
+    async listCollections() {
+        const collections = await this.db
+            .listCollections({}, { nameOnly: true })
+            .toArray();
+        return collections.map((c) => c.name);
+    }
+    async dropCollection(name) {
+        return this.db.dropCollection(this.getCollectionName(name));
+    }
+    getDefaultClientUrl() {
+        return "mongodb://127.0.0.1:27017";
+    }
+    getConnectionOptions() {
+        const ret = {};
+        const pool = this.config.get("pool");
+        const username = this.config.get("user");
+        const password = this.config.get("password");
+        if (this.config.get("host")) {
+            throw new core_1.ValidationError("Mongo driver does not support `host` options, use `clientUrl` instead!");
+        }
+        if (username && password) {
+            ret.auth = { username, password };
+        }
+        if (pool.min) {
+            ret.minPoolSize = pool.min;
+        }
+        if (pool.max) {
+            ret.maxPoolSize = pool.max;
+        }
+        return core_1.Utils.mergeConfig(ret, this.config.get("driverOptions"));
+    }
+    getClientUrl() {
+        const options = this.getConnectionOptions();
+        const clientUrl = this.config.getClientUrl(true);
+        const match = clientUrl.match(/^(\w+):\/\/((.*@.+)|.+)$/);
+        return match
+            ? `${match[1]}://${options.auth ? options.auth.username + ":*****@" : ""}${match[2]}`
+            : clientUrl;
+    }
+    getDb() {
+        return this.db;
+    }
+    async execute(query) {
+        throw new Error(`${this.constructor.name} does not support generic execute method`);
+    }
+    async find(collection, where, orderBy, limit, offset, fields, ctx, loggerContext) {
+        await this.ensureConnection();
+        collection = this.getCollectionName(collection);
+        const options = ctx ? { session: ctx } : {};
+        if (fields) {
+            options.projection = fields.reduce((o, k) => ({ ...o, [k]: 1 }), {});
+        }
+        const resultSet = this.getCollection(collection).find(where, options);
+        let query = `db.getCollection('${collection}').find(${this.logObject(where)}, ${this.logObject(options)})`;
+        orderBy = core_1.Utils.asArray(orderBy);
+        if (Array.isArray(orderBy) && orderBy.length > 0) {
+            const orderByTuples = [];
+            orderBy.forEach((o) => {
+                core_1.Utils.keys(o).forEach((k) => {
+                    const direction = o[k];
+                    orderByTuples.push([
+                        k.toString(),
+                        core_1.Utils.isString(direction)
+                            ? direction.toUpperCase() === core_1.QueryOrder.ASC
+                                ? 1
+                                : -1
+                            : direction,
+                    ]);
+                });
+            });
+            if (orderByTuples.length > 0) {
+                query += `.sort(${this.logObject(orderByTuples)})`;
+                // @ts-expect-error ??
+                resultSet.sort(orderByTuples);
+            }
+        }
+        if (limit !== undefined) {
+            query += `.limit(${limit})`;
+            resultSet.limit(limit);
+        }
+        if (offset !== undefined) {
+            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;
+    }
+    async insertOne(collection, data, ctx) {
+        return this.runQuery("insertOne", collection, data, undefined, ctx);
+    }
+    async insertMany(collection, data, ctx) {
+        return this.runQuery("insertMany", collection, data, undefined, ctx);
+    }
+    async updateMany(collection, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery("updateMany", collection, data, where, ctx, upsert, upsertOptions);
+    }
+    async bulkUpdateMany(collection, where, data, ctx, upsert, upsertOptions) {
+        return this.runQuery("bulkUpdateMany", collection, data, where, ctx, upsert, upsertOptions);
+    }
+    async deleteMany(collection, where, ctx) {
+        return this.runQuery("deleteMany", collection, undefined, where, ctx);
+    }
+    async aggregate(collection, pipeline, ctx, loggerContext) {
+        await this.ensureConnection();
+        collection = this.getCollectionName(collection);
+        /* istanbul ignore next */
+        const options = ctx ? { session: ctx } : {};
+        const query = `db.getCollection('${collection}').aggregate(${this.logObject(pipeline)}, ${this.logObject(options)}).toArray();`;
+        const now = Date.now();
+        const res = await this.getCollection(collection)
+            .aggregate(pipeline, options)
+            .toArray();
+        this.logQuery(query, {
+            took: Date.now() - now,
+            results: res.length,
+            ...loggerContext,
+        });
+        return res;
+    }
+    async countDocuments(collection, where, ctx) {
+        return this.runQuery("countDocuments", collection, undefined, where, ctx);
+    }
+    async transactional(cb, options = {}) {
+        await this.ensureConnection();
+        const session = await this.begin(options);
+        try {
+            const ret = await cb(session);
+            await this.commit(session, options.eventBroadcaster);
+            return ret;
+        }
+        catch (error) {
+            await this.rollback(session, options.eventBroadcaster);
+            throw error;
+        }
+        finally {
+            await session.endSession();
+        }
+    }
+    async begin(options = {}) {
+        await this.ensureConnection();
+        const { ctx, isolationLevel, eventBroadcaster, ...txOptions } = options;
+        if (!ctx) {
+            await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
+        }
+        const session = ctx || this.client.startSession();
+        session.startTransaction(txOptions);
+        this.logQuery("db.begin();");
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, session);
+        return session;
+    }
+    async commit(ctx, eventBroadcaster) {
+        await this.ensureConnection();
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionCommit, ctx);
+        await ctx.commitTransaction();
+        this.logQuery("db.commit();");
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionCommit, ctx);
+    }
+    async rollback(ctx, eventBroadcaster) {
+        await this.ensureConnection();
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionRollback, ctx);
+        await ctx.abortTransaction();
+        this.logQuery("db.rollback();");
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
+    }
+    async runQuery(method, collection, data, where, ctx, upsert, upsertOptions, loggerContext) {
+        await this.ensureConnection();
+        collection = this.getCollectionName(collection);
+        const logger = this.config.getLogger();
+        const options = ctx ? { session: ctx, upsert } : { upsert };
+        if (options.upsert === undefined) {
+            delete options.upsert;
+        }
+        const now = Date.now();
+        let res;
+        let query;
+        const log = (msg) => (logger.isEnabled("query") ? msg() : "");
+        switch (method) {
+            case "insertOne":
+                Object.keys(data)
+                    .filter((k) => typeof data[k] === "undefined")
+                    .forEach((k) => delete data[k]);
+                query = log(() => `db.getCollection('${collection}').insertOne(${this.logObject(data)}, ${this.logObject(options)});`);
+                res = await this.rethrow(this.getCollection(collection).insertOne(data, options), query);
+                break;
+            case "insertMany":
+                data.forEach((data) => Object.keys(data)
+                    .filter((k) => typeof data[k] === "undefined")
+                    .forEach((k) => delete data[k]));
+                query = log(() => `db.getCollection('${collection}').insertMany(${this.logObject(data)}, ${this.logObject(options)});`);
+                res = await this.rethrow(this.getCollection(collection).insertMany(data, options), query);
+                break;
+            case "updateMany": {
+                const payload = Object.keys(data).some((k) => k.startsWith("$"))
+                    ? data
+                    : this.createUpdatePayload(data, upsertOptions);
+                query = log(() => `db.getCollection('${collection}').updateMany(${this.logObject(where)}, ${this.logObject(payload)}, ${this.logObject(options)});`);
+                res = (await this.rethrow(this.getCollection(collection).updateMany(where, payload, options), query));
+                break;
+            }
+            case "bulkUpdateMany": {
+                query = log(() => `bulk = db.getCollection('${collection}').initializeUnorderedBulkOp(${this.logObject(options)});\n`);
+                const bulk = this.getCollection(collection).initializeUnorderedBulkOp(options);
+                data.forEach((row, idx) => {
+                    const id = where[idx];
+                    const cond = core_1.Utils.isPlainObject(id) ? id : { _id: id };
+                    const doc = this.createUpdatePayload(row, upsertOptions);
+                    if (upsert) {
+                        query += log(() => `bulk.find(${this.logObject(cond)}).upsert().update(${this.logObject(doc)});\n`);
+                        bulk.find(cond).upsert().update(doc);
+                        return;
+                    }
+                    query += log(() => `bulk.find(${this.logObject(cond)}).update(${this.logObject(doc)});\n`);
+                    bulk.find(cond).update(doc);
+                });
+                query += log(() => `bulk.execute()`);
+                res = await this.rethrow(bulk.execute(), query);
+                break;
+            }
+            case "deleteMany":
+            case "countDocuments":
+                query = log(() => `db.getCollection('${collection}').${method}(${this.logObject(where)}, ${this.logObject(options)});`);
+                res = await this.rethrow(this.getCollection(collection)[method](where, options), query);
+                break;
+        }
+        this.logQuery(query, { took: Date.now() - now, ...loggerContext });
+        if (method === "countDocuments") {
+            return res;
+        }
+        return this.transformResult(res);
+    }
+    rethrow(promise, query) {
+        return promise.catch((e) => {
+            this.logQuery(query, { level: "error" });
+            e.message += "\nQuery: " + query;
+            throw e;
+        });
+    }
+    createUpdatePayload(row, upsertOptions) {
+        const doc = { $set: row };
+        const $unset = {};
+        core_1.Utils.keys(row)
+            .filter((k) => typeof row[k] === "undefined")
+            .forEach((k) => {
+            $unset[k] = "";
+            delete row[k];
+        });
+        if (upsertOptions) {
+            if (upsertOptions.onConflictAction === "ignore") {
+                doc.$setOnInsert = doc.$set;
+                delete doc.$set;
+            }
+            if (upsertOptions.onConflictMergeFields) {
+                doc.$setOnInsert = {};
+                upsertOptions.onConflictMergeFields.forEach((f) => {
+                    doc.$setOnInsert[f] = doc.$set[f];
+                    delete doc.$set[f];
+                });
+                const { $set, $setOnInsert } = doc;
+                doc.$set = $setOnInsert;
+                doc.$setOnInsert = $set;
+            }
+            else if (upsertOptions.onConflictExcludeFields) {
+                doc.$setOnInsert = {};
+                upsertOptions.onConflictExcludeFields.forEach((f) => {
+                    doc.$setOnInsert[f] = doc.$set[f];
+                    delete doc.$set[f];
+                });
+            }
+        }
+        if (core_1.Utils.hasObjectKeys($unset)) {
+            doc.$unset = $unset;
+            if (!core_1.Utils.hasObjectKeys(doc.$set)) {
+                delete doc.$set;
+            }
+        }
+        return doc;
+    }
+    transformResult(res) {
+        return {
+            affectedRows: res.modifiedCount || res.deletedCount || res.insertedCount || 0,
+            insertId: res.insertedId ?? res.insertedIds?.[0],
+            insertedIds: res.insertedIds ? Object.values(res.insertedIds) : undefined,
+        };
+    }
+    getCollectionName(name) {
+        name = core_1.Utils.className(name);
+        const meta = this.metadata.find(name);
+        return meta ? meta.collection : name;
+    }
+    logObject(o) {
+        if (o.session) {
+            o = { ...o, session: `[ClientSession]` };
+        }
+        return (0, util_1.inspect)(o, { depth: 5, compact: true, breakLength: 300 });
+    }
+}
+exports.MongoConnection = MongoConnection;

package/MongoDriver.d.ts

@@ -0,0 +1,29 @@
+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 IDatabaseDriver, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from "@yandjin-mikro-orm/core";
+import { MongoConnection } from "./MongoConnection";
+import { MongoPlatform } from "./MongoPlatform";
+import { MongoEntityManager } from "./MongoEntityManager";
+export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
+    [EntityManagerType]: MongoEntityManager<this>;
+    protected readonly connection: MongoConnection;
+    protected readonly platform: MongoPlatform;
+    constructor(config: Configuration);
+    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    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 = "*", 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>[]>;
+    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>>;
+    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: {
+        ctx?: Transaction<ClientSession>;
+    }): Promise<QueryResult<T>>;
+    aggregate(entityName: string, pipeline: any[], ctx?: Transaction<ClientSession>): Promise<any[]>;
+    getPlatform(): MongoPlatform;
+    private renameFields;
+    private convertObjectIds;
+    private buildFilterById;
+    protected buildFields<T extends object, P extends string = never>(entityName: string, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;
+}