@pi-r/mongodb 0.7.3 → 0.8.0

package/client/index.js

@@ -1,79 +1,23 @@
 "use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.getSortValue = exports.getFilterValue = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = void 0;
+exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
+exports.setCredential = setCredential;
+exports.executeQuery = executeQuery;
+exports.executeBatchQuery = executeBatchQuery;
+exports.checkTimeout = checkTimeout;
+exports.getFilterValue = getFilterValue;
+exports.getSortValue = getSortValue;
 const path = require("path");
 const mongodb = require("mongodb");
-const types_1 = require("@e-mc/types");
-const util_1 = require("@e-mc/db/util");
 const Db = require("@e-mc/db");
 const Request = require("@e-mc/request");
-const DbPool = require('@e-mc/db/pool');
-class MongoDBPool extends DbPool {
-    async getConnection() {
-        return this.client.connect();
-    }
-    async detach(force) {
-        this.remove();
-        if (this.closed) {
-            return;
-        }
-        return this.close(force);
-    }
-    async close(force = false) {
-        return this.client.close(force);
-    }
-    isEmpty() {
-        if (this.closed) {
-            return true;
-        }
-        const topology = this.client.topology;
-        if (topology) {
-            const name = Object.getOwnPropertySymbols(topology).find(sym => sym.toString() === 'Symbol(waitQueue)');
-            return (0, util_1.checkEmpty)(name ? topology[name] : topology.s.servers);
-        }
-        return false;
-    }
-    get closeable() {
-        const topology = this.client.topology;
-        return topology ? super.closeable || topology.s.state === 'closing' : true;
-    }
-    get closed() {
-        const topology = this.client.topology;
-        if (topology && (this.success > 0 || this.failed > 0)) {
-            return topology.isDestroyed();
-        }
-        return this.client.s?.hasBeenClosed === true;
-    }
-}
+const types_1 = require("@e-mc/types");
+const util_1 = require("@e-mc/db/util");
+const DbPool = require("@pi-r/mongodb/client/pool");
 const POOL_STATE = {};
-const POOL_UNUSED = ['maxPoolSize', 'minPoolSize', 'connectTimeoutMS', 'socketTimeoutMS', 'maxConnecting', 'maxIdleTimeMS', 'waitQueueTimeoutMS', 'serverSelectionTimeoutMS', 'heartbeatFrequencyMS', 'minHeartbeatFrequencyMS', 'compressors', 'zlibCompressionLevel', 'srvMaxHosts'];
-const POOL_ACTIVE = new WeakSet();
-function removePoolProperties(credential) {
-    const options = credential.options;
-    if (options && !credential.uuidKey && POOL_ACTIVE.has(credential)) {
-        let result;
-        for (let i = 0, length = POOL_UNUSED.length; i < length; ++i) {
-            const attr = POOL_UNUSED[i];
-            if (attr in options) {
-                result ||= { ...options };
-                delete result[attr];
-            }
-        }
-        if (result) {
-            return { uri: credential.uri, options: result };
-        }
-    }
-    return credential;
-}
 function getCacheObject(item) {
     const credential = item.credential;
     return { uri: item.uri, options: item.options, uuidKey: credential?.uuidKey };
 }
-function getPoolKey(credential) {
-    const { options, uri } = credential;
-    if (uri && options) {
-        return uri + JSON.stringify(credential.options);
-    }
-}
 function setCredential(item) {
     const credential = this.getCredential(item);
     const options = item.options ||= {};
@@ -110,24 +54,54 @@ function setCredential(item) {
         uri += (uri.endsWith('?') ? '' : '&') + 'authMechanism=' + encodeURIComponent(authMechanism);
         switch (authMechanism) {
             case 'MONGODB-X509': {
-                const checkFile = (value) => {
-                    if ((0, types_1.isString)(value) && !Request.isCert(value = value.trim()) && Db.isPath(value = path.resolve(value)) && this.canRead(value, { ownPermissionOnly: true })) {
-                        return value;
+                for (const attr of ['tlsCertificateKeyFile', 'tlsCAFile', 'tlsCRLFile']) {
+                    let value = credential[attr];
+                    if ((0, types_1.isString)(value)) {
+                        if (Db.isPath(value = value.trim(), true)) {
+                            const pathname = path.resolve(value);
+                            if (this.canRead(pathname, { ownPermissionOnly: true })) {
+                                options[attr] = pathname;
+                                continue;
+                            }
+                        }
+                        else if (Request.isCert(value)) {
+                            if (attr === 'tlsCertificateKeyFile') {
+                                const pattern = /-+([^-]+)-+\s+[^-]+-+[^-]+-+/g;
+                                const key = [];
+                                const cert = [];
+                                let match;
+                                while (match = pattern.exec(value)) {
+                                    if (match[1].includes('BEGIN')) {
+                                        if (match[1].includes('KEY')) {
+                                            key.push(match[0]);
+                                        }
+                                        else {
+                                            cert.push(match[0]);
+                                        }
+                                    }
+                                }
+                                if (key.length > 0) {
+                                    options.key = Buffer.from(key.join('\n'), 'utf-8');
+                                }
+                                if (cert.length > 0) {
+                                    options.cert = Buffer.from(cert.join('\n'), 'utf-8');
+                                }
+                            }
+                            else {
+                                options[attr === 'tlsCAFile' ? 'ca' : 'crl'] = Buffer.from(value, 'utf-8');
+                            }
+                        }
                     }
-                    return '';
-                };
-                let { tlsCertificateKeyFile, tlsCAFile, tlsCRLFile } = credential;
-                if (tlsCertificateKeyFile && (tlsCertificateKeyFile = checkFile(tlsCertificateKeyFile))) {
+                }
+                if (options.tlsCertificateKeyFile || credential.cert && credential.key) {
                     const { tlsCertificateKeyFilePassword, tlsAllowInvalidHostnames, tlsAllowInvalidCertificates, tlsInsecure } = credential;
-                    options.tlsCertificateKeyFile = tlsCertificateKeyFile;
-                    if (tlsCAFile = checkFile(tlsCAFile)) {
-                        options.tlsCAFile = tlsCAFile;
-                    }
-                    if (tlsCRLFile = checkFile(tlsCRLFile)) {
-                        options.tlsCRLFile = tlsCRLFile;
-                    }
                     if (tlsCertificateKeyFilePassword) {
-                        options.tlsCertificateKeyFilePassword = tlsCertificateKeyFilePassword;
+                        if (credential.tlsCertificateKeyFile) {
+                            options.tlsCertificateKeyFilePassword = tlsCertificateKeyFilePassword;
+                        }
+                        else {
+                            options.passphrase = tlsCertificateKeyFilePassword;
+                        }
                     }
                     if (typeof tlsAllowInvalidHostnames === 'boolean') {
                         options.tlsAllowInvalidHostnames = tlsAllowInvalidHostnames;
@@ -164,6 +138,12 @@ function setCredential(item) {
             uri += '&authSource=' + encodeURIComponent(authSource);
         }
         item.uri = uri;
+        if (!options.writeConcern && ('w' in options || 'wtimeoutMS' in options || 'journal' in options)) {
+            options.writeConcern = new mongodb.WriteConcern(options.w, options.wtimeoutMS, options.journal);
+            delete options.w;
+            delete options.wtimeoutMS;
+            delete options.journal;
+        }
     }
     else if (!(0, types_1.isString)(uri)) {
         throw (0, types_1.errorMessage)("mongodb", 'Not defined - credentials');
@@ -211,18 +191,19 @@ function setCredential(item) {
             options.socketTimeoutMS ??= socket_timeout;
         }
     }
-    const poolKey = getPoolKey(item);
+    const poolKey = DbPool.asString(item);
     if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
         pool.add(item);
         return;
     }
-    new MongoDBPool(new mongodb.MongoClient(item.uri, options), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
+    const client = new mongodb.MongoClient(item.uri, options);
+    new DbPool(client, poolKey, username && password ? { username, password } : undefined)
+        .add(item)
+        .parent = POOL_STATE;
 }
-exports.setCredential = setCredential;
 async function executeQuery(item, options) {
     return (await executeBatchQuery.call(this, [item], options))[0] || [];
 }
-exports.executeQuery = executeQuery;
 async function executeBatchQuery(batch, options = '', outResult) {
     const length = batch.length;
     if (length === 0) {
@@ -243,7 +224,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         parallel = false;
     }
     else if (parallel === undefined) {
-        parallel = !batch.some(item => item.parallel === false || !!item.update);
+        parallel = !batch.some(item => item.parallel === false);
     }
     if (!parallel) {
         outResult ||= new Array(length);
@@ -254,13 +235,12 @@ async function executeBatchQuery(batch, options = '', outResult) {
     let mongoClient, mongoCredential, mongoCache = 0, onceCredential = connectOnce ? getCacheObject(batch[0]) : undefined;
     const getConnection = async (item, credential) => {
         item.transactionState = 64;
-        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, getPoolKey(connectOnce ? batch[0] : item), ...connectOnce ? [item, batch[0]] : [item]);
+        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(connectOnce ? batch[0] : item), ...connectOnce ? [item, batch[0]] : [item]);
         let client;
         if (pool) {
             try {
-                client = await pool.getConnection();
+                client = await pool.getConnection(credential);
                 pool.connected = true;
-                POOL_ACTIVE.add(credential);
             }
             catch {
                 if (pool.closeable) {
@@ -334,7 +314,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
         if (queryString) {
             const setResult = () => {
-                if (ignoreCache !== 1 && (rows = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue))) {
+                if (ignoreCache !== 1 && (rows = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue))) {
                     ++mongoCache;
                     if (parallel) {
                         tasks[i] = Promise.resolve(rows);
@@ -374,10 +354,13 @@ async function executeBatchQuery(batch, options = '', outResult) {
             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", 'runCommand')));
+                if (item.command) {
+                    await Promise.all((!Array.isArray(item.command) ? [item.command] : item.command).map(async (cmd) => runCommand(instance, cmd)))
+                        .then(items => {
+                        for (const output of items) {
+                            this.addLog(this.statusType.INFO, output, "mongodb", 'runCommand');
+                        }
+                    });
                 }
                 const collection = getCollection(instance);
                 if (update && coercing) {
@@ -402,7 +385,9 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     if (pipeline) {
                         const aggregateOptions = (0, types_1.isPlainObject)(aggregate) ? aggregate.options : undefined;
                         if (coercing) {
-                            pipeline.forEach(doc => (0, types_1.coerceObject)(doc));
+                            for (const doc of pipeline) {
+                                (0, types_1.coerceObject)(doc);
+                            }
                             if (aggregateOptions) {
                                 (0, types_1.coerceObject)(aggregateOptions);
                             }
@@ -457,7 +442,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                     }
                     if (streamRow) {
-                        const processRow = typeof streamRow === 'function' && streamRow;
+                        const processRow = typeof streamRow === 'function' ? streamRow : null;
                         const stream = cursor.stream();
                         let error;
                         rows = [];
@@ -482,7 +467,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             }
                             else {
                                 this.add(item, 4);
-                                resolve(!error ? this.setQueryResult(source, removePoolProperties(mongoCredential || credential), queryString, rows, cacheValue) : rows);
+                                resolve(!error ? this.setQueryResult(source, DbPool.sanitize(mongoCredential || credential), queryString, rows, cacheValue) : rows);
                             }
                         })
                             .on('end', () => stream.destroy());
@@ -496,7 +481,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     if (targetObject) {
                         rows = targetObject(item, rows);
                     }
-                    resolve(this.setQueryResult(source, removePoolProperties(mongoCredential || credential), queryString, rows, cacheValue));
+                    resolve(this.setQueryResult(source, DbPool.sanitize(mongoCredential || credential), queryString, rows, cacheValue));
                 }
                 else {
                     throw (0, types_1.errorMessage)(source, "Missing database query");
@@ -522,17 +507,17 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
-        disconnect: () => clients.forEach(item => {
-            item.close(true);
-        }),
-        parallel
+        parallel,
+        disconnect() {
+            for (const item of clients) {
+                void item.close(true);
+            }
+        }
     }, outResult);
 }
-exports.executeBatchQuery = executeBatchQuery;
 async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
-exports.checkTimeout = checkTimeout;
 function getFilterValue(query, coerce) {
     let value, options;
     if ((0, types_1.isObject)(query) && query.value && query.options) {
@@ -549,7 +534,6 @@ function getFilterValue(query, coerce) {
     }
     return [value, options];
 }
-exports.getFilterValue = getFilterValue;
 function getSortValue(sort, coerce) {
     let value, direction;
     if ((0, types_1.isObject)(sort) && sort.value && sort.direction) {
@@ -563,6 +547,5 @@ function getSortValue(sort, coerce) {
     }
     return [value, direction];
 }
-exports.getSortValue = getSortValue;
 exports.DB_SOURCE_CLIENT = true;
 exports.DB_SOURCE_TYPE = types_1.DB_TYPE.NOSQL | types_1.DB_TYPE.DOCUMENT;

package/client/pool.d.ts

@@ -0,0 +1,9 @@
+import type { DbPoolConstructor } from '@e-mc/types/lib/db';
+
+import type { DbPoolCredential, MongoDBDataSource } from '../types';
+
+import type { MongoClient } from 'mongodb';
+
+declare const MongoDBPool: DbPoolConstructor<MongoDBDataSource, MongoClient, MongoClient, DbPoolCredential>;
+
+export = MongoDBPool;

package/client/pool.js

@@ -0,0 +1,61 @@
+"use strict";
+const util_1 = require("@e-mc/db/util");
+const DbPool = require('@e-mc/db/pool');
+const POOL_ACTIVE = new WeakSet();
+class MongoDBPool extends DbPool {
+    static CACHE_UNUSED = ['maxPoolSize', 'minPoolSize', 'connectTimeoutMS', 'socketTimeoutMS', 'maxConnecting', 'maxIdleTimeMS', 'waitQueueTimeoutMS', 'maxStalenessSeconds', 'localThresholdMS', 'serverSelectionTimeoutMS', 'heartbeatFrequencyMS', 'minHeartbeatFrequencyMS', 'compressors', 'zlibCompressionLevel', 'srvMaxHosts'];
+    static asString(credential) {
+        const { options, uri } = credential;
+        if (uri && options) {
+            return uri + JSON.stringify(options);
+        }
+        return super.asString(credential);
+    }
+    static sanitize(credential) {
+        const target = credential.options;
+        if (!target || !POOL_ACTIVE.has(credential) || credential.uuidKey) {
+            return credential;
+        }
+        const options = super.sanitize(target);
+        return options !== target ? { uri: credential.uri, options } : credential;
+    }
+    async detach(force) {
+        this.remove();
+        if (this.closed) {
+            return;
+        }
+        return this.close(force);
+    }
+    get closeable() {
+        const topology = this.client.topology;
+        return topology ? super.closeable || topology.s.state === 'closing' : true;
+    }
+    async getConnection(credential) {
+        if (credential) {
+            POOL_ACTIVE.add(credential);
+        }
+        return this.client.connect();
+    }
+    async close(force = false) {
+        return this.client.close(force);
+    }
+    isEmpty() {
+        if (this.closed) {
+            return true;
+        }
+        const topology = this.client.topology;
+        if (topology) {
+            const name = Object.getOwnPropertySymbols(topology).find(sym => sym.toString() === 'Symbol(waitQueue)');
+            return (0, util_1.checkEmpty)(name ? topology[name] : topology.s.servers);
+        }
+        return false;
+    }
+    get closed() {
+        const topology = this.client.topology;
+        if (topology && (this.success > 0 || this.failed > 0)) {
+            return topology.isDestroyed();
+        }
+        return this.client.s?.hasBeenClosed === true;
+    }
+}
+module.exports = MongoDBPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/mongodb",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "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.9.6",
-    "@e-mc/request": "^0.9.6",
-    "@e-mc/types": "^0.9.6",
+    "@e-mc/db": "^0.10.0",
+    "@e-mc/request": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
     "mongodb": "^6.8.0"
   }
 }

package/types/index.d.ts

@@ -1,5 +1,6 @@
 import type { DbDataSource } from '@e-mc/types/lib/squared';
 
+import type { IdentifierAction } from '@e-mc/types/lib/core';
 import type { CascadeAction, ServerAuth } from '@e-mc/types/lib/db';
 
 import type { AggregateOptions, CollectionOptions, CommandOperationOptions, DbOptions, Document, Filter, MongoClientOptions, OptionalUnlessRequiredId, RunCommandOptions, Sort, SortDirection, UpdateFilter } from 'mongodb';
@@ -40,4 +41,9 @@ export interface MongoDBClientDBOptions {
 export interface MongoDBFilterValue {
     value?: Filter<Document>;
     options?: CommandOperationOptions;
+}
+
+export interface DbPoolCredential extends IdentifierAction {
+    uri?: string;
+    options?: MongoClientOptions;
 }