@steedos/objectql 3.0.13-beta.3 → 3.0.13-beta.30

package/lib/driver/mongo.js

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SteedosMongoDriver = void 0;
-var tslib_1 = require("tslib");
-var index_1 = require("./index");
-var mongodb_1 = require("mongodb");
-var filters_1 = require("@steedos/filters");
-var odata_v4_mongodb_1 = require("@steedos/odata-v4-mongodb");
-var _ = require("underscore");
-var field_encrytion_1 = require("./field-encrytion");
-var format_1 = require("./format");
-var monitor_enabled = false;
-var SLOW_QUERY_THRESHOLD_MS = 0;
+const index_1 = require("./index");
+const mongodb_1 = require("mongodb");
+const filters_1 = require("@steedos/filters");
+const odata_v4_mongodb_1 = require("@steedos/odata-v4-mongodb");
+const _ = require("underscore");
+const field_encrytion_1 = require("./field-encrytion");
+const format_1 = require("./format");
+let monitor_enabled = false;
+let SLOW_QUERY_THRESHOLD_MS = 0;
 if (process.env.STEEDOS_MONGODB_SLOW_QUERY_THRESHOLD) {
     monitor_enabled = true;
     SLOW_QUERY_THRESHOLD_MS = Number(process.env.STEEDOS_MONGODB_SLOW_QUERY_THRESHOLD);
 }
-var runningCommands = new Map();
+const runningCommands = new Map();
 function connectAndMonitor(client) {
-    client.on("commandStarted", function (event) {
+    client.on("commandStarted", (event) => {
         runningCommands.set(event.requestId, {
             startTime: Date.now(),
             commandName: event.commandName,
@@ -25,53 +24,58 @@ function connectAndMonitor(client) {
             command: event.command,
         });
     });
-    client.on("commandSucceeded", function (event) {
-        var commandInfo = runningCommands.get(event.requestId);
+    client.on("commandSucceeded", (event) => {
+        const commandInfo = runningCommands.get(event.requestId);
         if (!commandInfo)
             return;
-        var duration = Date.now() - commandInfo.startTime;
+        const duration = Date.now() - commandInfo.startTime;
         runningCommands.delete(event.requestId);
         if (duration >= SLOW_QUERY_THRESHOLD_MS) {
-            console.warn("\uD83D\uDEA8 \u6162\u67E5\u8BE2\u68C0\u6D4B\u5230 (\u6210\u529F):");
-            console.warn("   \u547D\u4EE4: ".concat(commandInfo.commandName));
-            console.warn("   \u8017\u65F6: ".concat(duration, " ms"));
-            console.warn("   \u6570\u636E\u5E93: ".concat(commandInfo.databaseName));
-            console.warn("   command: ".concat(JSON.stringify(commandInfo.command)));
+            console.warn(`🚨 慢查询检测到 (成功):`);
+            console.warn(`   命令: ${commandInfo.commandName}`);
+            console.warn(`   耗时: ${duration} ms`);
+            console.warn(`   数据库: ${commandInfo.databaseName}`);
+            console.warn(`   command: ${JSON.stringify(commandInfo.command)}`);
         }
     });
-    client.on("commandFailed", function (event) {
-        var commandInfo = runningCommands.get(event.requestId);
+    client.on("commandFailed", (event) => {
+        const commandInfo = runningCommands.get(event.requestId);
         if (!commandInfo)
             return;
-        var duration = Date.now() - commandInfo.startTime;
+        const duration = Date.now() - commandInfo.startTime;
         runningCommands.delete(event.requestId);
         if (duration >= SLOW_QUERY_THRESHOLD_MS) {
-            console.error("\u274C \u6162\u64CD\u4F5C\u68C0\u6D4B\u5230 (\u5931\u8D25):");
-            console.error("   \u547D\u4EE4: ".concat(commandInfo.commandName));
-            console.error("   \u8017\u65F6: ".concat(duration, " ms"));
-            console.error("   \u9519\u8BEF: ".concat(event.failure.message));
-            console.error("   command: ".concat(JSON.stringify(commandInfo.command)));
+            console.error(`❌ 慢操作检测到 (失败):`);
+            console.error(`   命令: ${commandInfo.commandName}`);
+            console.error(`   耗时: ${duration} ms`);
+            console.error(`   错误: ${event.failure.message}`);
+            console.error(`   command: ${JSON.stringify(commandInfo.command)}`);
         }
     });
 }
-var SteedosMongoDriver = (function () {
-    function SteedosMongoDriver(config) {
+class SteedosMongoDriver {
+    _url;
+    _client;
+    _config;
+    _collections;
+    _encryption;
+    constructor(config) {
         this._collections = {};
         this._config = config;
         this._url = this.buildConnectionUrl();
     }
-    SteedosMongoDriver.prototype.buildConnectionUrl = function () {
+    buildConnectionUrl() {
         if (this._config.url)
             return this._config.url;
-        var credentialsUrlPart = this._config.username && this._config.password
-            ? "".concat(this._config.username, ":").concat(this._config.password, "@")
+        const credentialsUrlPart = this._config.username && this._config.password
+            ? `${this._config.username}:${this._config.password}@`
             : "";
         if (!this._config.database) {
             throw new Error("Not find database");
         }
-        return "mongodb://".concat(credentialsUrlPart).concat(this._config.host || "127.0.0.1", ":").concat(this._config.port || "27017", "/").concat(this._config.database);
-    };
-    SteedosMongoDriver.prototype.getSupportedColumnTypes = function () {
+        return `mongodb://${credentialsUrlPart}${this._config.host || "127.0.0.1"}:${this._config.port || "27017"}/${this._config.database}`;
+    }
+    getSupportedColumnTypes() {
         return [
             index_1.SteedosFieldDBType.varchar,
             index_1.SteedosFieldDBType.text,
@@ -82,118 +86,74 @@ var SteedosMongoDriver = (function () {
             index_1.SteedosFieldDBType.json,
             index_1.SteedosFieldDBType.array,
         ];
-    };
-    SteedosMongoDriver.prototype.encryptValue = function (value) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var altKeyName, encryption, encryptValue;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this._encryption) return [3, 2];
-                        altKeyName = (0, field_encrytion_1.getMongoFieldEncryptionConsts)().altKeyName;
-                        encryption = this._encryption;
-                        return [4, encryption.encrypt(value, {
-                                keyAltName: altKeyName,
-                                algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
-                            })];
-                    case 1:
-                        encryptValue = _a.sent();
-                        return [2, encryptValue];
-                    case 2: return [2, value];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.decryptValue = function (value) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var encryption, decryptValue;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this._encryption) return [3, 2];
-                        encryption = this._encryption;
-                        return [4, encryption.decrypt(value)];
-                    case 1:
-                        decryptValue = _a.sent();
-                        return [2, decryptValue];
-                    case 2: return [2, value];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.connect = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var ClientEncryption, _a, keyVaultNamespace, getKMSProviders, kmsProvider, _b, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!!this._client) return [3, 6];
-                        if (!process.env.STEEDOS_CSFLE_MASTER_KEY) return [3, 3];
-                        ClientEncryption = require("mongodb-client-encryption").ClientEncryption;
-                        _a = (0, field_encrytion_1.getMongoFieldEncryptionConsts)(), keyVaultNamespace = _a.keyVaultNamespace, getKMSProviders = _a.getKMSProviders;
-                        return [4, getKMSProviders()];
-                    case 1:
-                        kmsProvider = _d.sent();
-                        _b = this;
-                        return [4, mongodb_1.MongoClient.connect(this._url, {
-                                useNewUrlParser: true,
-                                useUnifiedTopology: true,
-                                monitorCommands: true,
-                                autoEncryption: {
-                                    keyVaultNamespace: keyVaultNamespace,
-                                    kmsProviders: kmsProvider,
-                                    bypassAutoEncryption: true,
-                                },
-                            })];
-                    case 2:
-                        _b._client = _d.sent();
-                        this._encryption = new ClientEncryption(this._client, {
-                            keyVaultNamespace: keyVaultNamespace,
-                            kmsProviders: kmsProvider,
-                        });
-                        return [3, 5];
-                    case 3:
-                        _c = this;
-                        return [4, mongodb_1.MongoClient.connect(this._url, {
-                                useNewUrlParser: true,
-                                useUnifiedTopology: true,
-                                monitorCommands: monitor_enabled,
-                            })];
-                    case 4:
-                        _c._client = _d.sent();
-                        _d.label = 5;
-                    case 5:
-                        if (monitor_enabled) {
-                            connectAndMonitor(this._client);
-                        }
-                        return [2, true];
-                    case 6: return [2];
-                }
+    }
+    async encryptValue(value) {
+        if (this._encryption) {
+            const { altKeyName } = (0, field_encrytion_1.getMongoFieldEncryptionConsts)();
+            const encryption = this._encryption;
+            let encryptValue = await encryption.encrypt(value, {
+                keyAltName: altKeyName,
+                algorithm: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
             });
-        });
-    };
-    SteedosMongoDriver.prototype.getClient = function () {
+            return encryptValue;
+        }
+        return value;
+    }
+    async decryptValue(value) {
+        if (this._encryption) {
+            const encryption = this._encryption;
+            let decryptValue = await encryption.decrypt(value);
+            return decryptValue;
+        }
+        return value;
+    }
+    async connect() {
+        if (!this._client) {
+            if (process.env.STEEDOS_CSFLE_MASTER_KEY) {
+                const { ClientEncryption } = require("mongodb-client-encryption");
+                const { keyVaultNamespace, getKMSProviders } = (0, field_encrytion_1.getMongoFieldEncryptionConsts)();
+                const kmsProvider = await getKMSProviders();
+                this._client = await mongodb_1.MongoClient.connect(this._url, {
+                    useNewUrlParser: true,
+                    useUnifiedTopology: true,
+                    monitorCommands: true,
+                    autoEncryption: {
+                        keyVaultNamespace: keyVaultNamespace,
+                        kmsProviders: kmsProvider,
+                        bypassAutoEncryption: true,
+                    },
+                });
+                this._encryption = new ClientEncryption(this._client, {
+                    keyVaultNamespace: keyVaultNamespace,
+                    kmsProviders: kmsProvider,
+                });
+            }
+            else {
+                this._client = await mongodb_1.MongoClient.connect(this._url, {
+                    useNewUrlParser: true,
+                    useUnifiedTopology: true,
+                    monitorCommands: monitor_enabled,
+                });
+            }
+            if (monitor_enabled) {
+                connectAndMonitor(this._client);
+            }
+            return true;
+        }
+    }
+    getClient() {
         return this._client;
-    };
-    SteedosMongoDriver.prototype.close = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this._client) return [3, 2];
-                        return [4, this._client.close()];
-                    case 1:
-                        _a.sent();
-                        this._client = null;
-                        return [2, true];
-                    case 2: return [2];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.formatFiltersToMongoQuery = function (filters) {
-        var emptyFilters = {};
-        var odataQuery = "";
+    }
+    async close() {
+        if (this._client) {
+            await this._client.close();
+            this._client = null;
+            return true;
+        }
+    }
+    formatFiltersToMongoQuery(filters) {
+        let emptyFilters = {};
+        let odataQuery = "";
         if (_.isString(filters)) {
             odataQuery = filters;
         }
@@ -203,11 +163,11 @@ var SteedosMongoDriver = (function () {
         if (!odataQuery) {
             return emptyFilters;
         }
-        var query = (0, odata_v4_mongodb_1.createFilter)(odataQuery);
+        let query = (0, odata_v4_mongodb_1.createFilter)(odataQuery);
         return query;
-    };
-    SteedosMongoDriver.prototype.getMongoFilters = function (filters) {
-        var emptyFilters = {};
+    }
+    getMongoFilters(filters) {
+        let emptyFilters = {};
         if (_.isUndefined(filters)) {
             return emptyFilters;
         }
@@ -217,63 +177,63 @@ var SteedosMongoDriver = (function () {
         if (_.isArray(filters) && !filters.length) {
             return emptyFilters;
         }
-        var mongoFilters = this.formatFiltersToMongoQuery(filters);
+        let mongoFilters = this.formatFiltersToMongoQuery(filters);
         return mongoFilters;
-    };
-    SteedosMongoDriver.prototype.getMongoFieldsOptions = function (fields) {
+    }
+    getMongoFieldsOptions(fields) {
         if (typeof fields == "string") {
-            fields = fields.split(",").map(function (n) {
+            fields = fields.split(",").map((n) => {
                 return n.trim();
             });
         }
         if (!(fields && fields.length)) {
             return {};
         }
-        var projection = {};
-        fields.forEach(function (field) {
+        let projection = {};
+        fields.forEach((field) => {
             if (field) {
                 projection[field] = 1;
             }
         });
         return projection;
-    };
-    SteedosMongoDriver.prototype.getMongoSortOptions = function (sort) {
-        var result = undefined;
+    }
+    getMongoSortOptions(sort) {
+        let result = undefined;
         if (sort && typeof sort === "string") {
-            var arraySort = sort.split(",").map(function (n) {
+            let arraySort = sort.split(",").map((n) => {
                 return n.trim();
             });
-            var stringSort_1 = "";
-            arraySort.forEach(function (n) {
+            let stringSort = "";
+            arraySort.forEach((n) => {
                 if (n) {
-                    stringSort_1 += "".concat(n, ",");
+                    stringSort += `${n},`;
                 }
             });
-            stringSort_1 = stringSort_1.replace(/,$/g, "");
-            result = (0, odata_v4_mongodb_1.createQuery)("$orderby=".concat(stringSort_1)).sort;
+            stringSort = stringSort.replace(/,$/g, "");
+            result = (0, odata_v4_mongodb_1.createQuery)(`$orderby=${stringSort}`).sort;
         }
         return result;
-    };
-    SteedosMongoDriver.prototype.getMongoOptions = function (options) {
+    }
+    getMongoOptions(options) {
         if (_.isUndefined(options)) {
             return {};
         }
-        var result = {};
-        var projection = this.getMongoFieldsOptions(options.fields);
-        var sort = this.getMongoSortOptions(options.sort);
+        let result = {};
+        let projection = this.getMongoFieldsOptions(options.fields);
+        let sort = this.getMongoSortOptions(options.sort);
         result.projection = projection;
         result.sort = sort;
         result.limit = options.top;
         result.skip = options.skip;
         return result;
-    };
-    SteedosMongoDriver.prototype.getAggregateOptions = function (options) {
+    }
+    getAggregateOptions(options) {
         if (_.isUndefined(options)) {
             return [];
         }
-        var result = [];
-        var projection = this.getMongoFieldsOptions(options.fields);
-        var sort = this.getMongoSortOptions(options.sort);
+        let result = [];
+        let projection = this.getMongoFieldsOptions(options.fields);
+        let sort = this.getMongoSortOptions(options.sort);
         if (!_.isEmpty(projection)) {
             result.push({ $project: projection });
         }
@@ -287,345 +247,200 @@ var SteedosMongoDriver = (function () {
             result.push({ $limit: options.top });
         }
         return result;
-    };
-    SteedosMongoDriver.prototype.collection = function (name) {
+    }
+    collection(name) {
         if (!this._collections[name]) {
-            var db = this._client.db();
+            const db = this._client.db();
             this._collections[name] = db.collection(name);
         }
         return this._collections[name];
-    };
-    SteedosMongoDriver.prototype.find = function (tableName, query) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, mongoFilters, mongoOptions, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        mongoFilters = this.getMongoFilters(query.filters);
-                        mongoOptions = this.getMongoOptions(query);
-                        return [4, collection.find(mongoFilters, mongoOptions).toArray()];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.aggregate = function (tableName, query, externalPipeline) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, pipeline, mongoFilters, aggregateOptions, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        pipeline = [];
-                        mongoFilters = this.getMongoFilters(query.filters);
-                        aggregateOptions = this.getAggregateOptions(query);
-                        pipeline.push({ $match: mongoFilters });
-                        pipeline = pipeline.concat(aggregateOptions).concat(externalPipeline);
-                        return [4, collection.aggregate(pipeline).toArray()];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directAggregate = function (tableName, query, externalPipeline, userId) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, pipeline, mongoFilters, aggregateOptions, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        pipeline = [];
-                        if (query.filters) {
-                            mongoFilters = this.getMongoFilters(query.filters);
-                            aggregateOptions = this.getAggregateOptions(query);
-                            pipeline.push({ $match: mongoFilters });
-                            pipeline = pipeline.concat(aggregateOptions);
-                        }
-                        pipeline = pipeline.concat(externalPipeline);
-                        return [4, collection.aggregate(pipeline).toArray()];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directAggregatePrefixalPipeline = function (tableName, query, prefixalPipeline, userId) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, pipeline, mongoFilters, aggregateOptions, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        pipeline = [];
-                        mongoFilters = this.getMongoFilters(query.filters);
-                        aggregateOptions = this.getAggregateOptions(query);
-                        pipeline.push({ $match: mongoFilters });
-                        pipeline = prefixalPipeline.concat(pipeline).concat(aggregateOptions);
-                        return [4, collection.aggregate(pipeline).toArray()];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.count = function (tableName, query) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, mongoFilters, mongoOptions, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        mongoFilters = this.getMongoFilters(query.filters);
-                        mongoOptions = this.getMongoOptions(query);
-                        return [4, collection.find(mongoFilters, mongoOptions).count()];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.findOne = function (tableName, id, query) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, mongoOptions, mongoFilters, selector, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        mongoOptions = this.getMongoOptions(query);
-                        mongoFilters = this.getMongoFilters(query.filters);
-                        selector = { _id: id };
-                        if (_.isObject(id)) {
-                            selector = this.getMongoFilters(id["filters"]);
-                        }
-                        if (!_.isEmpty(mongoFilters)) {
-                            selector = Object.assign(mongoFilters, selector);
-                        }
-                        return [4, collection.findOne(selector, mongoOptions)];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.insert = function (tableName, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        data._id = data._id || new mongodb_1.ObjectId().toHexString();
-                        collection = this.collection(tableName);
-                        return [4, collection.insertOne(data)];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result.ops[0]];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.update = function (tableName, id, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, selector, options, keys, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (_.isEmpty(data)) {
-                            throw new Error("the params 'data' must not be empty");
-                        }
-                        return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        if (_.isObject(id)) {
-                            selector = this.getMongoFilters(id["filters"]);
-                        }
-                        else {
-                            selector = { _id: id };
-                        }
-                        options = { $set: {}, $unset: {} };
-                        keys = _.keys(data);
-                        _.each(keys, function (key) {
-                            if (_.include([
-                                "$inc",
-                                "$min",
-                                "$max",
-                                "$mul",
-                                "$push",
-                                "$addToSet",
-                                "$pop",
-                                "$pull",
-                                "$pullAll",
-                            ], key)) {
-                                options[key] = data[key];
-                            }
-                            else {
-                                if (null === data[key]) {
-                                    options.$unset[key] = 1;
-                                }
-                                else {
-                                    options.$set[key] = data[key];
-                                }
-                            }
-                        });
-                        if (_.isEmpty(options.$set)) {
-                            delete options.$set;
-                        }
-                        if (_.isEmpty(options.$unset)) {
-                            delete options.$unset;
-                        }
-                        return [4, collection.updateOne(selector, options)];
-                    case 2:
-                        result = _a.sent();
-                        if (!result.result.ok) return [3, 4];
-                        return [4, collection.findOne(selector)];
-                    case 3:
-                        result = _a.sent();
-                        return [2, result];
-                    case 4: return [2];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.updateOne = function (tableName, id, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, selector, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (_.isEmpty(data)) {
-                            throw new Error("the params 'data' must not be empty");
-                        }
-                        return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        if (_.isObject(id)) {
-                            selector = this.getMongoFilters(id["filters"]);
-                        }
-                        else {
-                            selector = { _id: id };
-                        }
-                        return [4, collection.updateOne(selector, { $set: data })];
-                    case 2:
-                        result = _a.sent();
-                        if (!result.result.ok) return [3, 4];
-                        return [4, collection.findOne(selector)];
-                    case 3:
-                        result = _a.sent();
-                        return [2, result];
-                    case 4: return [2];
-                }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.updateMany = function (tableName, queryFilters, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, mongoFilters;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (_.isEmpty(data)) {
-                            throw new Error("the params 'data' must not be empty");
-                        }
-                        return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        mongoFilters = this.getMongoFilters(queryFilters);
-                        return [4, collection.update(mongoFilters, { $set: data }, { multi: true })];
-                    case 2: return [2, _a.sent()];
+    }
+    async find(tableName, query) {
+        await this.connect();
+        const collection = this.collection(tableName);
+        const mongoFilters = this.getMongoFilters(query.filters);
+        const mongoOptions = this.getMongoOptions(query);
+        const result = await collection.find(mongoFilters, mongoOptions).toArray();
+        return result;
+    }
+    async aggregate(tableName, query, externalPipeline) {
+        await this.connect();
+        const collection = this.collection(tableName);
+        let pipeline = [];
+        const mongoFilters = this.getMongoFilters(query.filters);
+        const aggregateOptions = this.getAggregateOptions(query);
+        pipeline.push({ $match: mongoFilters });
+        pipeline = pipeline.concat(aggregateOptions).concat(externalPipeline);
+        const result = await collection.aggregate(pipeline).toArray();
+        return result;
+    }
+    async directAggregate(tableName, query, externalPipeline, userId) {
+        await this.connect();
+        let collection = this.collection(tableName);
+        let pipeline = [];
+        if (query.filters) {
+            let mongoFilters = this.getMongoFilters(query.filters);
+            let aggregateOptions = this.getAggregateOptions(query);
+            pipeline.push({ $match: mongoFilters });
+            pipeline = pipeline.concat(aggregateOptions);
+        }
+        pipeline = pipeline.concat(externalPipeline);
+        let result = await collection.aggregate(pipeline).toArray();
+        return result;
+    }
+    async directAggregatePrefixalPipeline(tableName, query, prefixalPipeline, userId) {
+        await this.connect();
+        let collection = this.collection(tableName);
+        let pipeline = [];
+        let mongoFilters = this.getMongoFilters(query.filters);
+        let aggregateOptions = this.getAggregateOptions(query);
+        pipeline.push({ $match: mongoFilters });
+        pipeline = prefixalPipeline.concat(pipeline).concat(aggregateOptions);
+        let result = await collection.aggregate(pipeline).toArray();
+        return result;
+    }
+    async count(tableName, query) {
+        await this.connect();
+        let collection = this.collection(tableName);
+        let mongoFilters = this.getMongoFilters(query.filters);
+        let mongoOptions = this.getMongoOptions(query);
+        let result = await collection.find(mongoFilters, mongoOptions).count();
+        return result;
+    }
+    async findOne(tableName, id, query) {
+        await this.connect();
+        let collection = this.collection(tableName);
+        let mongoOptions = this.getMongoOptions(query);
+        let mongoFilters = this.getMongoFilters(query.filters);
+        let selector = { _id: id };
+        if (_.isObject(id)) {
+            selector = this.getMongoFilters(id["filters"]);
+        }
+        if (!_.isEmpty(mongoFilters)) {
+            selector = Object.assign(mongoFilters, selector);
+        }
+        let result = await collection.findOne(selector, mongoOptions);
+        return result;
+    }
+    async insert(tableName, data) {
+        await this.connect();
+        data._id = data._id || new mongodb_1.ObjectId().toHexString();
+        let collection = this.collection(tableName);
+        let result = await collection.insertOne(data);
+        return result.ops[0];
+    }
+    async update(tableName, id, data) {
+        if (_.isEmpty(data)) {
+            throw new Error("the params 'data' must not be empty");
+        }
+        await this.connect();
+        let collection = this.collection(tableName);
+        let selector;
+        if (_.isObject(id)) {
+            selector = this.getMongoFilters(id["filters"]);
+        }
+        else {
+            selector = { _id: id };
+        }
+        const options = { $set: {}, $unset: {} };
+        const keys = _.keys(data);
+        _.each(keys, function (key) {
+            if (_.include([
+                "$inc",
+                "$min",
+                "$max",
+                "$mul",
+                "$push",
+                "$addToSet",
+                "$pop",
+                "$pull",
+                "$pullAll",
+            ], key)) {
+                options[key] = data[key];
+            }
+            else {
+                if (null === data[key]) {
+                    options.$unset[key] = 1;
                 }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.delete = function (tableName, id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var collection, selector, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.connect()];
-                    case 1:
-                        _a.sent();
-                        collection = this.collection(tableName);
-                        if (_.isObject(id)) {
-                            selector = this.getMongoFilters(id["filters"]);
-                        }
-                        else {
-                            selector = { _id: id };
-                        }
-                        return [4, collection.deleteOne(selector)];
-                    case 2:
-                        result = _a.sent();
-                        return [2, result === null || result === void 0 ? void 0 : result.deletedCount];
+                else {
+                    options.$set[key] = data[key];
                 }
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directFind = function (tableName, query) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.find(tableName, query)];
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directInsert = function (tableName, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.insert(tableName, data)];
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directUpdate = function (tableName, id, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.update(tableName, id, data)];
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directDelete = function (tableName, id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.delete(tableName, id)];
-            });
-        });
-    };
-    SteedosMongoDriver.prototype.directUpdateMany = function (tableName, queryFilters, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.updateMany(tableName, queryFilters, data)];
-            });
+            }
         });
-    };
-    SteedosMongoDriver.prototype._makeNewID = function (tableName) {
+        if (_.isEmpty(options.$set)) {
+            delete options.$set;
+        }
+        if (_.isEmpty(options.$unset)) {
+            delete options.$unset;
+        }
+        let result = await collection.updateOne(selector, options);
+        if (result.result.ok) {
+            result = await collection.findOne(selector);
+            return result;
+        }
+    }
+    async updateOne(tableName, id, data) {
+        if (_.isEmpty(data)) {
+            throw new Error("the params 'data' must not be empty");
+        }
+        await this.connect();
+        let collection = this.collection(tableName);
+        let selector;
+        if (_.isObject(id)) {
+            selector = this.getMongoFilters(id["filters"]);
+        }
+        else {
+            selector = { _id: id };
+        }
+        let result = await collection.updateOne(selector, { $set: data });
+        if (result.result.ok) {
+            result = await collection.findOne(selector);
+            return result;
+        }
+    }
+    async updateMany(tableName, queryFilters, data) {
+        if (_.isEmpty(data)) {
+            throw new Error("the params 'data' must not be empty");
+        }
+        await this.connect();
+        let collection = this.collection(tableName);
+        let mongoFilters = this.getMongoFilters(queryFilters);
+        return await collection.update(mongoFilters, { $set: data }, { multi: true });
+    }
+    async delete(tableName, id) {
+        await this.connect();
+        let collection = this.collection(tableName);
+        let selector;
+        if (_.isObject(id)) {
+            selector = this.getMongoFilters(id["filters"]);
+        }
+        else {
+            selector = { _id: id };
+        }
+        const result = await collection.deleteOne(selector);
+        return result?.deletedCount;
+    }
+    async directFind(tableName, query) {
+        return this.find(tableName, query);
+    }
+    async directInsert(tableName, data) {
+        return this.insert(tableName, data);
+    }
+    async directUpdate(tableName, id, data) {
+        return this.update(tableName, id, data);
+    }
+    async directDelete(tableName, id) {
+        return this.delete(tableName, id);
+    }
+    async directUpdateMany(tableName, queryFilters, data) {
+        return this.updateMany(tableName, queryFilters, data);
+    }
+    _makeNewID(tableName) {
         return new mongodb_1.ObjectId().toHexString();
-    };
-    SteedosMongoDriver.prototype.formatRecord = function (doc, objectConfig) {
+    }
+    formatRecord(doc, objectConfig) {
         return (0, format_1.formatRecord)(doc, objectConfig);
-    };
-    return SteedosMongoDriver;
-}());
+    }
+}
 exports.SteedosMongoDriver = SteedosMongoDriver;
 //# sourceMappingURL=mongo.js.map