@pi-r/mongodb 0.5.1 → 0.6.1

package/client/index.js

@@ -9,14 +9,17 @@ const Db = require("@e-mc/db");
 const Request = require("@e-mc/request");
 const DbPool = require('@e-mc/db/pool');
 class MongoDBPool extends DbPool {
-    getConnection() {
+    async getConnection() {
         return this.client.connect();
     }
-    detach(force) {
+    async detach(force) {
         this.remove();
-        return this.closed ? Promise.resolve() : this.close(force);
+        if (this.closed) {
+            return;
+        }
+        return this.close(force);
     }
-    close(force = false) {
+    async close(force = false) {
         return this.client.close(force);
     }
     isEmpty() {
@@ -69,7 +72,7 @@ function getPoolKey(credential) {
     const options = credential.options;
     if (options && credential.uri) {
         const auth = options.auth;
-        let result = credential.uri + (auth ? '_' + (auth.username || '') + '@' + (auth.password || '') : '') + '_' + (options.authMechanism || '') + Db.asString(options.authMechanismProperties);
+        let result = credential.uri + (auth ? '_' + (auth.username || '') + '@' + (auth.password || '') : '') + '_' + (options.authMechanism || '') + Db.asString(options.authMechanismProperties, true);
         if (options.tls || options.ssl) {
             const { tlsCertificateKeyFile = '', tlsCAFile = '', tlsCRLFile = '', tlsCertificateKeyFilePassword = '', tlsAllowInvalidHostnames, tlsAllowInvalidCertificates, tlsInsecure } = options;
             result += tlsCertificateKeyFile + tlsCAFile + tlsCRLFile + tlsCertificateKeyFilePassword + (tlsAllowInvalidHostnames ? '1' : '0') + (tlsAllowInvalidCertificates ? '1' : '0') + (tlsInsecure ? '1' : '0');
@@ -107,13 +110,10 @@ function setCredential(item) {
         else {
             options.auth || (options.auth = { username, password });
         }
-        if (uri.indexOf('?') === -1) {
-            if (uri[uri.length - 1] !== '/') {
-                uri += '/';
-            }
-            uri += '?';
+        if (!uri.includes('?')) {
+            uri += (uri.endsWith('/') ? '' : '/') + '?';
         }
-        uri += (uri[uri.length - 1] !== '?' ? '&' : '') + 'authMechanism=' + encodeURIComponent(authMechanism);
+        uri += (uri.endsWith('?') ? '' : '&') + 'authMechanism=' + encodeURIComponent(authMechanism);
         switch (authMechanism) {
             case 'MONGODB-X509': {
                 const checkFile = (value) => {
@@ -175,53 +175,52 @@ function setCredential(item) {
         throw (0, types_1.errorMessage)("mongodb" /* STRINGS.MODULE_NAME */, 'Not defined - credentials');
     }
     const usePool = item.usePool;
-    if (usePool) {
-        let username, password, pool;
-        if (typeof usePool === 'string' && (username = options.auth?.username || item.uri && (0, util_1.parseConnectionString)(item.uri)?.username)) {
-            [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
-            if (pool) {
-                pool.add(item, password);
-                return;
-            }
+    if (!usePool) {
+        return;
+    }
+    let username, password, pool;
+    if (typeof usePool === 'string' && (username = options.auth?.username || item.uri && (0, util_1.parseConnectionString)(item.uri)?.username)) {
+        [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
+        if (pool) {
+            pool.add(item, password);
+            return;
         }
-        const poolKey = getPoolKey(item);
-        if (poolKey) {
-            if (!(pool = POOL_STATE[poolKey]) || pool.closed) {
-                const config = this.getPoolConfig("mongodb" /* STRINGS.MODULE_NAME */, password);
-                if (config) {
-                    const { min, max, idle, queue_max, queue_idle, timeout, socket_timeout } = config;
-                    if (min >= 0) {
-                        options.minPoolSize ?? (options.minPoolSize = min);
-                    }
-                    if (max > 0) {
-                        options.maxPoolSize ?? (options.maxPoolSize = max);
-                    }
-                    if (idle >= 0) {
-                        options.maxIdleTimeMS ?? (options.maxIdleTimeMS = idle);
-                    }
-                    if (queue_max > 0) {
-                        options.maxConnecting ?? (options.maxConnecting = queue_max);
-                    }
-                    if (queue_idle >= 0) {
-                        options.waitQueueTimeoutMS ?? (options.waitQueueTimeoutMS = queue_idle);
-                    }
-                    if (timeout > 0) {
-                        options.connectTimeoutMS ?? (options.connectTimeoutMS = timeout);
-                    }
-                    if (socket_timeout > 0) {
-                        options.socketTimeoutMS ?? (options.socketTimeoutMS = socket_timeout);
-                    }
-                }
-                new MongoDBPool(new mongodb.MongoClient(item.uri, options), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
-            }
-            else {
-                pool.add(item);
-            }
+    }
+    const poolKey = getPoolKey(item);
+    if (!poolKey) {
+        item.usePool = false;
+        return;
+    }
+    if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
+        pool.add(item);
+        return;
+    }
+    const config = this.getPoolConfig("mongodb" /* STRINGS.MODULE_NAME */, password);
+    if (config) {
+        const { min, max, idle, queue_max, queue_idle, timeout, socket_timeout } = config;
+        if (min >= 0) {
+            options.minPoolSize ?? (options.minPoolSize = min);
         }
-        else {
-            item.usePool = false;
+        if (max > 0) {
+            options.maxPoolSize ?? (options.maxPoolSize = max);
+        }
+        if (idle >= 0) {
+            options.maxIdleTimeMS ?? (options.maxIdleTimeMS = idle);
+        }
+        if (queue_max > 0) {
+            options.maxConnecting ?? (options.maxConnecting = queue_max);
+        }
+        if (queue_idle >= 0) {
+            options.waitQueueTimeoutMS ?? (options.waitQueueTimeoutMS = queue_idle);
+        }
+        if (timeout > 0) {
+            options.connectTimeoutMS ?? (options.connectTimeoutMS = timeout);
+        }
+        if (socket_timeout > 0) {
+            options.socketTimeoutMS ?? (options.socketTimeoutMS = socket_timeout);
         }
     }
+    new MongoDBPool(new mongodb.MongoClient(item.uri, options), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
 }
 exports.setCredential = setCredential;
 async function executeQuery(item, options) {
@@ -289,6 +288,9 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState &= ~64 /* DB_TRANSACTION.AUTH */;
         return client;
     };
+    if (this.host?.username) {
+        this.applyCommand(...batch);
+    }
     for (let i = 0; i < length; ++i) {
         const item = batch[i];
         const { source, name, table, id, aggregate, sort, client, cacheObjectKey, ignoreCache } = item;
@@ -312,17 +314,18 @@ async function executeBatchQuery(batch, options = '', outResult) {
             continue;
         }
         item.transactionState = 1 /* DB_TRANSACTION.ACTIVE */;
-        const getCollection = (target) => target.db(name, client?.db).collection(table, client?.collection);
+        const getInstance = (target) => target.db(name, client?.db);
+        const getCollection = (target) => getInstance(target).collection(table, client?.collection);
+        const runCommand = async (target, document) => getInstance(target).command(document, client?.command);
         const credential = mongoCredential || onceCredential || getCacheObject(item);
-        const renewCache = ignoreCache === 0;
-        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
+        const cacheValue = ignoreCache === undefined ? sessionKey : Array.isArray(ignoreCache) ? { sessionKey, exclusiveOf: ignoreCache } : { sessionKey, renewCache: ignoreCache === 0 };
         const coercing = this.hasCoerce("mongodb" /* STRINGS.MODULE_NAME */, 'options', credential.uuidKey);
         const targetObject = typeof checkObject === 'string' ? coercing && (0, types_1.asFunction)(checkObject) : checkObject;
         if (typeof streamRow === 'string') {
             streamRow = coercing && (0, types_1.asFunction)(streamRow);
         }
         let queryString = '', rows, pipeline;
-        if ((caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) && (!targetObject || typeof cacheObjectKey === 'string') && !streamRow) {
+        if (caching && ignoreCache !== true && (!targetObject || typeof cacheObjectKey === 'string') && !streamRow) {
             queryString = (name || '') + '_' + table + '_' + limit + Db.asString(sort, true) + Db.asString(client, true) + (targetObject ? targetObject.toString() + cacheObjectKey : '');
         }
         if (aggregate) {
@@ -373,11 +376,34 @@ async function executeBatchQuery(batch, options = '', outResult) {
         tasks[i] = new Promise(async (resolve, reject) => {
             let commandType;
             try {
+                const instance = mongoClient || await getConnection(item, credential);
+                const command = item.command;
+                if (command) {
+                    await Promise.all((!Array.isArray(command) ? [command] : command).map(async (cmd) => runCommand(instance, cmd)))
+                        .then(items => items.forEach(output => this.addLog(this.statusType.INFO, output, "mongodb" /* STRINGS.MODULE_NAME */, 'runCommand')));
+                }
+                const collection = getCollection(instance);
+                if (update && coercing) {
+                    (0, types_1.coerceObject)(update);
+                }
+                if (Array.isArray(update)) {
+                    commandType = this.commandType.INSERT;
+                    const insertOptions = item.execute?.insert;
+                    if (insertOptions && coercing) {
+                        (0, types_1.coerceObject)(insertOptions);
+                    }
+                    if (update.length === 1) {
+                        await collection.insertOne(update[0], insertOptions);
+                    }
+                    else if (update.length > 1) {
+                        await collection.insertMany(update, insertOptions);
+                    }
+                    update = undefined;
+                }
                 let cursor;
                 if (pipeline || query) {
-                    const collection = getCollection(mongoClient || await getConnection(item, credential));
                     if (pipeline) {
-                        const aggregateOptions = aggregate?.options;
+                        const aggregateOptions = (0, types_1.isPlainObject)(aggregate) ? aggregate.options : undefined;
                         if (coercing) {
                             pipeline.forEach(doc => (0, types_1.coerceObject)(doc));
                             if (aggregateOptions) {
@@ -393,41 +419,22 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                     }
                     else {
-                        const [filter, command] = getFilterValue(query, coercing);
-                        if (update && coercing) {
-                            (0, types_1.coerceObject)(update);
-                        }
-                        if ((0, types_1.isArray)(update)) {
-                            commandType = this.commandType.INSERT;
-                            const insertOptions = item.execute?.insert;
-                            if (insertOptions && coercing) {
-                                (0, types_1.coerceObject)(insertOptions);
-                            }
-                            if (update.length === 1) {
-                                await collection.insertOne(update[0], insertOptions);
-                            }
-                            else {
-                                await collection.insertMany(update, insertOptions);
-                            }
-                            update = undefined;
-                        }
-                        else if (item.updateType === 1) {
-                            update = undefined;
-                        }
+                        const [filter, operation] = getFilterValue(query, coercing);
+                        const updateType = item.updateType;
                         if (limit === 1) {
                             let document;
                             if (update) {
                                 commandType = this.commandType.UPDATE;
-                                document = await collection[item.updateType === 2 ? 'findOneAndReplace' : item.updateType === 3 ? 'findOneAndDelete' : 'findOneAndUpdate'](filter, update, command);
+                                document = await collection[updateType === 2 ? 'findOneAndReplace' : updateType === 3 ? 'findOneAndDelete' : 'findOneAndUpdate'](filter, update, operation);
                             }
                             else {
                                 commandType = this.commandType.SELECT;
-                                document = await collection.findOne(filter, command);
+                                document = await collection.findOne(filter, operation);
                             }
                             rows = document ? [document] : [];
                         }
                         else {
-                            if (update) {
+                            if (update && updateType === 1) {
                                 commandType = this.commandType.UPDATE;
                                 const updateOptions = item.execute?.update;
                                 if (updateOptions && coercing) {
@@ -435,12 +442,12 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                 }
                                 await collection.updateMany(filter, update, updateOptions);
                             }
-                            cursor = collection.find(filter, command);
+                            cursor = collection.find(filter, operation);
                         }
                     }
                 }
                 else if (!aggregate) {
-                    cursor = getCollection(mongoClient || await getConnection(item, credential)).find();
+                    cursor = collection.find();
                 }
                 if (cursor) {
                     commandType = this.commandType.SELECT;
@@ -518,12 +525,12 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
-        disconnect: () => clients.forEach(item => item.close(true)),
+        disconnect: () => clients.forEach(async (item) => item.close(true)),
         parallel
     }, outResult);
 }
 exports.executeBatchQuery = executeBatchQuery;
-function checkTimeout(value, limit = 0) {
+async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
 exports.checkTimeout = checkTimeout;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/mongodb",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "MongoDB client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,9 +21,9 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.7.0",
-    "@e-mc/request": "^0.7.0",
-    "@e-mc/types": "^0.7.0",
+    "@e-mc/db": "^0.8.1",
+    "@e-mc/request": "^0.8.1",
+    "@e-mc/types": "^0.8.1",
     "mongodb": "^6.3.0"
   }
 }

package/types/index.d.ts

@@ -2,7 +2,7 @@ import type { DbDataSource } from '@e-mc/types/lib/squared';
 
 import type { CascadeAction, ServerAuth } from '@e-mc/types/lib/db';
 
-import type { AggregateOptions, CollectionOptions, CommandOperationOptions, DbOptions, Document, Filter, MongoClientOptions, OptionalUnlessRequiredId, Sort, SortDirection, UpdateFilter } from 'mongodb';
+import type { AggregateOptions, CollectionOptions, CommandOperationOptions, DbOptions, Document, Filter, MongoClientOptions, OptionalUnlessRequiredId, RunCommandOptions, Sort, SortDirection, UpdateFilter } from 'mongodb';
 
 export interface MongoDBDataSource extends DbDataSource<Filter<Document> | MongoDBQueryWithOptions, MongoClientOptions, UpdateFilter<Document> | OptionalUnlessRequiredId<unknown>[], string | MongoDBCredential, string>, MongoDBClientDBOptions, CascadeAction {
     source: "mongodb";
@@ -26,12 +26,14 @@ export interface MongoDBClientDBOptions {
     client?: {
         db?: DbOptions;
         collection?: CollectionOptions;
+        command?: RunCommandOptions;
     };
     execute?: {
         insert?: CommandOperationOptions;
         update?: CommandOperationOptions;
     };
-    aggregate?: MongoDBAggregate;
+    command?: ArrayOf<Document>;
+    aggregate?: MongoDBAggregate | Document[];
     sort?: Sort | string | MongoDBSortValue;
 }