@pi-r/mongodb 0.11.3 → 0.12.1

package/client/index.js

@@ -1,20 +1,28 @@
 "use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
-exports.setCredential = setCredential;
-exports.executeQuery = executeQuery;
-exports.executeBatchQuery = executeBatchQuery;
-exports.checkTimeout = checkTimeout;
-exports.initCollection = initCollection;
-exports.getFilterValue = getFilterValue;
-exports.getSortValue = getSortValue;
-const path = require("node:path");
-const mongodb = require("mongodb");
-const Db = require("@e-mc/db");
-const Request = require("@e-mc/request");
-const types_1 = require("@e-mc/types");
-const util_1 = require("@e-mc/db/util");
-const DbPool = require("@pi-r/mongodb/client/pool");
+
+const path = require('node:path');
+const mongodb = require('mongodb');
+const Db = require('@e-mc/db');
+const Request = require('@e-mc/request');
+const { DB_TYPE, asFunction, coerceObject, errorMessage, isError, isObject, isPlainObject, isString } = require('@e-mc/types');
+const { getBasicAuth, parseConnectionString, parseServerAuth } = require('@e-mc/db/util');
+const DbPool = require('@pi-r/mongodb/client/pool');
 const POOL_STATE = {};
+let SERVER_API;
+if (process.env.MONGODB_SERVER_API) {
+    try {
+        const api = JSON.parse(process.env.MONGODB_SERVER_API);
+        if (api == '1') {
+            SERVER_API = Object.freeze({ version: mongodb.ServerApiVersion.v1 });
+        }
+        else if (isPlainObject(api) && api.version) {
+            SERVER_API = Object.freeze(api);
+        }
+    }
+    catch (err) {
+        Db.writeFail(["Unable to configure client", "mongodb"], err);
+    }
+}
 function getCacheObject(item) {
     const credential = item.credential;
     return { uri: item.uri, options: item.options, uuidKey: credential?.uuidKey };
@@ -22,12 +30,16 @@ function getCacheObject(item) {
 function setCredential(item) {
     const credential = this.getCredential(item);
     const options = item.options ||= {};
+    if (SERVER_API) {
+        options.serverApi ||= SERVER_API;
+    }
     let uri = item.uri;
     if (credential) {
-        let { protocol, server, hostname, port, username, password } = (0, util_1.parseServerAuth)(credential, 27017), { auth, authMechanism = 'DEFAULT', authSource, authMechanismProperties } = credential, authentication = '';
+        const { auth, authMechanism = 'DEFAULT' } = credential;
+        let { protocol, server, hostname, port, username, password } = parseServerAuth(credential, 27017), authSource = credential.authSource, authentication = '';
         if (authMechanism === 'GSSAPI') {
             const principal = auth?.username || username || options.auth?.username;
-            if ((0, types_1.isString)(principal)) {
+            if (isString(principal)) {
                 authentication = encodeURIComponent(principal) + '@';
             }
         }
@@ -36,13 +48,13 @@ function setCredential(item) {
         }
         if (!uri || !Db.isURL(uri)) {
             if (!options.auth) {
-                authentication = (0, util_1.getBasicAuth)(username, password);
+                authentication = getBasicAuth(username, password);
             }
             if (!server && hostname) {
                 server = hostname + ':' + (port || 27017);
             }
             if (!server) {
-                throw (0, types_1.errorMessage)("mongodb", 'Not defined', 'server/hostname');
+                throw errorMessage("mongodb", 'Not defined', 'server/hostname');
             }
             uri = (protocol || 'mongodb:') + '//' + authentication + server;
         }
@@ -57,7 +69,7 @@ function setCredential(item) {
             case 'MONGODB-X509': {
                 for (const attr of ['tlsCertificateKeyFile', 'tlsCAFile', 'tlsCRLFile']) {
                     const value = credential[attr];
-                    if ((0, types_1.isString)(value)) {
+                    if (isString(value)) {
                         if (Db.isPath(value, true)) {
                             const pathname = path.resolve(value);
                             if (this.canRead(pathname, { ownPermissionOnly: true })) {
@@ -114,16 +126,14 @@ function setCredential(item) {
                     uri += '&tls=true';
                 }
                 else {
-                    throw (0, types_1.errorMessage)("mongodb", 'Missing TLS/SSL credentials');
+                    throw errorMessage("mongodb", 'Missing TLS/SSL credentials');
                 }
                 authSource ||= '$external';
                 break;
             }
             case 'GSSAPI':
             case 'MONGODB-AWS': {
-                if ((0, types_1.isObject)(authMechanismProperties)) {
-                    options.authMechanismProperties = authMechanismProperties;
-                }
+                options.authMechanismProperties = credential.authMechanismProperties;
                 authSource ||= '$external';
                 break;
             }
@@ -148,15 +158,15 @@ function setCredential(item) {
         }
     }
     else if (!uri) {
-        throw (0, types_1.errorMessage)("mongodb", "Invalid credentials", 'uri');
+        throw errorMessage("mongodb", "Invalid credentials", 'uri');
     }
     const usePool = item.usePool;
     if (!usePool) {
         return;
     }
     let username, password, pool;
-    if ((0, types_1.isString)(usePool)) {
-        username = options.auth?.username || item.uri && (0, util_1.parseConnectionString)(item.uri)?.username;
+    if (isString(usePool)) {
+        username = options.auth?.username || item.uri && parseConnectionString(item.uri)?.username;
         if (username) {
             [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
             if (pool) {
@@ -219,7 +229,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         return [];
     }
     let parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if ((0, types_1.isPlainObject)(options)) {
+    if (isPlainObject(options)) {
         ({ parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss } = options);
     }
     else {
@@ -239,6 +249,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         outResult ||= new Array(length);
     }
     const caching = this.hasCache("mongodb", sessionKey);
+    const sortKeys = this.settingsOf("mongodb", 'cache', 'sort_keys') === true;
     const tasks = new Array(length);
     const clients = [];
     let mongoClient, mongoCredential, mongoCache = 0, onceCredential = connectOnce ? getCacheObject(batch[0]) : undefined;
@@ -278,15 +289,22 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState &= ~64;
         return client;
     };
+    const applyOptions = (item, out) => {
+        out.signal ||= this.signal;
+        if (typeof item.timeoutMS === 'number') {
+            out.timeoutMS = item.timeoutMS;
+        }
+        return out;
+    };
     if (this.host?.username) {
         this.applyCommand(...batch);
     }
     for (let i = 0; i < length; ++i) {
         const item = batch[i];
-        const { source, name, table, id, aggregate, distinct, sort, cacheObjectKey, ignoreCache } = item;
+        const { source, name, table, id, aggregate, distinct, sort, ignoreCache } = item;
         let { query, update, streamRow, limit = 0 } = item;
         if (!table) {
-            const error = (0, types_1.errorMessage)(source, "Missing database table");
+            const error = errorMessage(source, "Missing database table");
             ++mongoCache;
             if (this.handleFail(error, item, { errorQuery })) {
                 if (!parallel) {
@@ -307,15 +325,15 @@ async function executeBatchQuery(batch, options = '', outResult) {
         const credential = mongoCredential || onceCredential || getCacheObject(item);
         const cacheValue = ignoreCache === undefined ? sessionKey : Array.isArray(ignoreCache) ? { sessionKey, exclusiveOf: ignoreCache } : { sessionKey, renewCache: ignoreCache === 0 };
         const coercing = this.hasCoerce("mongodb", 'options', credential.uuidKey);
-        const targetObject = typeof checkObject === 'string' ? coercing && (0, types_1.asFunction)(checkObject) : checkObject;
+        const targetObject = typeof checkObject === 'string' ? coercing ? asFunction(checkObject) : null : checkObject;
         if (coercing && typeof streamRow === 'string') {
-            streamRow = (0, types_1.asFunction)(streamRow);
+            streamRow = asFunction(streamRow);
         }
-        let queryString = '', rows, pipeline;
-        if (caching && ignoreCache !== true && (!targetObject || typeof cacheObjectKey === 'string') && !streamRow) {
+        let queryString = '', cacheCredential, rows, pipeline;
+        if (caching && ignoreCache !== true && !streamRow) {
             const collection = item.client?.collection;
             const db = item.client?.db;
-            queryString = (name || '') + '_' + table + (sort ? '_' + Db.asString(sort, true) : '') + '_' + (limit > 0 ? limit.toString() : '0') + (db ? Db.asString(db, true) : '') + (collection ? Db.asString(collection, true) : '') + (targetObject ? targetObject.toString() + cacheObjectKey : '');
+            queryString = (name || '') + '_' + table + (item.withFields ? '_' + Db.asString(item.withFields, true) : '') + (sort ? '_' + Db.asString(sort, true) : '') + '_' + (limit > 0 ? limit.toString() : '0') + (db ? Db.asString(db, true) : '') + (collection ? Db.asString(collection, true) : '') + (targetObject && typeof item.cacheObjectKey === 'string' ? targetObject.toString() + item.cacheObjectKey : '');
         }
         if (aggregate) {
             pipeline = Array.isArray(aggregate) ? aggregate : aggregate.pipeline;
@@ -326,7 +344,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
         if (queryString) {
             const setResult = () => {
-                if (ignoreCache !== 1 && (rows = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue))) {
+                if (ignoreCache !== 1 && (rows = this.getQueryResult(source, cacheCredential, queryString, cacheValue))) {
                     ++mongoCache;
                     if (parallel) {
                         tasks[i] = Promise.resolve(rows);
@@ -341,12 +359,16 @@ async function executeBatchQuery(batch, options = '', outResult) {
             };
             if (pipeline || query || distinct) {
                 queryString += Db.asString(aggregate || query || distinct, true);
+                cacheCredential = DbPool.sanitize(mongoCredential || credential, sortKeys);
                 if ((aggregate || distinct || !update) && setResult()) {
                     continue;
                 }
             }
-            else if (!aggregate && setResult()) {
-                continue;
+            else if (!aggregate) {
+                cacheCredential = DbPool.sanitize(mongoCredential || credential, sortKeys);
+                if (setResult()) {
+                    continue;
+                }
             }
             if (!ignoreCache && outCacheMiss) {
                 outCacheMiss.push(source);
@@ -368,13 +390,13 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 const instance = mongoClient || await getConnection(item, credential);
                 const collection = await initCollection.call(this, instance, item);
                 if (update && coercing) {
-                    (0, types_1.coerceObject)(update);
+                    coerceObject(update);
                 }
                 if (Array.isArray(update)) {
                     commandType = this.commandType.INSERT;
                     const insertOptions = item.execute?.insert;
                     if (insertOptions && coercing) {
-                        (0, types_1.coerceObject)(insertOptions);
+                        coerceObject(insertOptions);
                     }
                     if (update.length === 1) {
                         await collection.insertOne(update[0], insertOptions);
@@ -387,16 +409,16 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 let cursor;
                 if (pipeline || query) {
                     if (pipeline) {
-                        const aggregateOptions = (0, types_1.isPlainObject)(aggregate) ? aggregate.options : undefined;
+                        const aggOptions = isPlainObject(aggregate) ? aggregate.options : undefined;
                         if (coercing) {
                             for (const doc of pipeline) {
-                                (0, types_1.coerceObject)(doc);
+                                coerceObject(doc);
                             }
-                            if (aggregateOptions) {
-                                (0, types_1.coerceObject)(aggregateOptions);
+                            if (aggOptions) {
+                                coerceObject(aggOptions);
                             }
                         }
-                        cursor = collection.aggregate(pipeline, aggregateOptions);
+                        cursor = collection.aggregate(pipeline, applyOptions(item, aggOptions || {}));
                         if (sort) {
                             cursor.sort(getSortValue(sort, coercing)[0]);
                         }
@@ -409,6 +431,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         if (sort) {
                             operation.sort = getSortValue(sort, coercing)[0];
                         }
+                        applyOptions(item, operation);
                         if (limit === 1) {
                             let document;
                             if (update) {
@@ -424,25 +447,27 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         else {
                             if (update && item.updateType === 1) {
                                 commandType = this.commandType.UPDATE;
-                                const updateOptions = item.execute?.update;
-                                if (updateOptions && coercing) {
-                                    (0, types_1.coerceObject)(updateOptions);
-                                }
-                                await collection.updateMany(filter, update, updateOptions);
+                                await collection.updateMany(filter, update, item.execute?.update);
                             }
                             cursor = collection.find(filter, operation);
                         }
                     }
                 }
                 else if (distinct) {
-                    const [a, b, c] = Array.isArray(distinct) ? distinct : [distinct];
-                    rows = await (b ? c ? collection.distinct(a, b, c) : collection.distinct(a, b) : collection.distinct(a));
+                    let [a, b, c] = Array.isArray(distinct) ? distinct : [distinct];
+                    if (typeof item.timeoutMS === 'number') {
+                        (c ||= {}).timeoutMS = item.timeoutMS;
+                    }
+                    rows = await (c ? b ? collection.distinct(a, b, c) : collection.distinct(a, c) : b ? collection.distinct(a, b) : collection.distinct(a));
                 }
                 else if (!aggregate) {
-                    cursor = collection.find();
+                    cursor = collection.find({}, applyOptions(item, {}));
                 }
                 if (cursor) {
                     commandType = this.commandType.SELECT;
+                    if (item.withFields) {
+                        cursor.project(item.withFields);
+                    }
                     if (!pipeline) {
                         if (sort) {
                             cursor.sort(...getSortValue(sort, coercing));
@@ -463,7 +488,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                 if (err === false) {
                                     return;
                                 }
-                                if (err instanceof Error) {
+                                if (isError(err)) {
                                     error = err;
                                     return;
                                 }
@@ -477,7 +502,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             }
                             else {
                                 this.add(item, 4);
-                                resolve(!error ? this.setQueryResult(source, DbPool.sanitize(mongoCredential || credential), queryString, rows, cacheValue) : rows);
+                                resolve(!error ? this.setQueryResult(source, cacheCredential, queryString, rows, cacheValue) : rows);
                             }
                         })
                             .on('end', () => stream.destroy());
@@ -491,10 +516,10 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     if (targetObject) {
                         rows = targetObject(item, rows);
                     }
-                    resolve(this.setQueryResult(source, DbPool.sanitize(mongoCredential || credential), queryString, rows, cacheValue));
+                    resolve(this.setQueryResult(source, cacheCredential, queryString, rows, cacheValue));
                 }
                 else {
-                    throw (0, types_1.errorMessage)(source, "Missing database query");
+                    throw errorMessage(source, "Missing database query");
                 }
             }
             catch (err) {
@@ -520,7 +545,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         parallel,
         disconnect() {
             for (const item of clients) {
-                void item.close(true);
+                void item.close();
             }
         }
     }, outResult);
@@ -553,32 +578,39 @@ async function initCollection(target, item) {
 }
 function getFilterValue(query, coerce) {
     let value, options;
-    if ((0, types_1.isObject)(query) && query.value && query.options) {
+    if (isObject(query) && query.value && query.options) {
         ({ value, options } = query);
     }
     else {
         value = query;
     }
     if (coerce) {
-        (0, types_1.coerceObject)(value);
-        if (options) {
-            (0, types_1.coerceObject)(options);
-        }
+        coerceObject(value);
     }
     return [value, options];
 }
 function getSortValue(sort, coerce) {
     let value, direction;
-    if ((0, types_1.isObject)(sort) && sort.value && sort.direction) {
+    if (isObject(sort) && sort.value && sort.direction) {
         ({ value, direction } = sort);
     }
     else {
         value = sort;
     }
     if (coerce) {
-        (0, types_1.coerceObject)(value);
+        coerceObject(value);
     }
     return [value, direction];
 }
-exports.DB_SOURCE_CLIENT = true;
-exports.DB_SOURCE_TYPE = types_1.DB_TYPE.NOSQL | types_1.DB_TYPE.DOCUMENT;
+const DB_SOURCE_CLIENT = true;
+const DB_SOURCE_TYPE = DB_TYPE.NOSQL | DB_TYPE.DOCUMENT;
+
+exports.DB_SOURCE_CLIENT = DB_SOURCE_CLIENT;
+exports.DB_SOURCE_TYPE = DB_SOURCE_TYPE;
+exports.checkTimeout = checkTimeout;
+exports.executeBatchQuery = executeBatchQuery;
+exports.executeQuery = executeQuery;
+exports.getFilterValue = getFilterValue;
+exports.getSortValue = getSortValue;
+exports.initCollection = initCollection;
+exports.setCredential = setCredential;

package/client/pool.js

@@ -1,9 +1,9 @@
 "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', 'timeoutMS', 'compressors', 'zlibCompressionLevel', 'srvMaxHosts', 'mongodbLogPath', 'mongodbLogComponentSeverities', 'mongodbLogMaxDocumentLength'];
+    static CACHE_UNUSED = ['maxPoolSize', 'minPoolSize', 'connectTimeoutMS', 'socketTimeoutMS', 'maxConnecting', 'maxIdleTimeMS', 'waitQueueTimeoutMS', 'maxStalenessSeconds', 'localThresholdMS', 'serverSelectionTimeoutMS', 'heartbeatFrequencyMS', 'minHeartbeatFrequencyMS', 'timeoutMS', 'compressors', 'zlibCompressionLevel', 'srvMaxHosts', 'serverMonitoringMode', 'mongodbLogPath', 'mongodbLogComponentSeverities', 'mongodbLogMaxDocumentLength'];
     static CACHE_IGNORE = ['pkFactory'];
     static asString(credential) {
         const { options, uri } = credential;
@@ -12,7 +12,7 @@ class MongoDBPool extends DbPool {
         }
         return super.asString(credential);
     }
-    static sanitize(credential) {
+    static sanitize(credential, sort) {
         if (!this.canCache(credential)) {
             return;
         }
@@ -20,7 +20,7 @@ class MongoDBPool extends DbPool {
         if (!target || !POOL_ACTIVE.has(credential) || credential.uuidKey) {
             return credential;
         }
-        const options = super.sanitize(target);
+        const options = super.sanitize(target, sort);
         return options !== target ? { uri: credential.uri, options } : credential;
     }
     async detach(force) {
@@ -47,12 +47,7 @@ class MongoDBPool extends DbPool {
         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.waitQueue || topology.s.servers);
-        }
-        return false;
+        return this.client.topology?.waitQueue?.length === 0;
     }
     get closed() {
         const topology = this.client.topology;
@@ -62,4 +57,5 @@ class MongoDBPool extends DbPool {
         return this.client.s?.hasBeenClosed === true;
     }
 }
+
 module.exports = MongoDBPool;

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "@pi-r/mongodb",
-  "version": "0.11.3",
+  "version": "0.12.1",
   "description": "MongoDB client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anpham6/pi-r.git",
@@ -20,9 +17,9 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.13.10",
-    "@e-mc/request": "^0.13.10",
-    "@e-mc/types": "^0.13.10",
-    "mongodb": "^6.21.0"
+    "@e-mc/db": "^0.14.1",
+    "@e-mc/request": "^0.14.1",
+    "@e-mc/types": "^0.14.1",
+    "mongodb": "^7.2.0"
   }
 }

package/types/index.d.ts

@@ -24,7 +24,7 @@ export interface MongoDBAggregate {
     options?: AggregateOptions;
 }
 
-export interface MongoDBClientDBOptions {
+export interface MongoDBClientDBOptions extends TimeoutAction {
     client?: {
         db?: DbOptions;
         collection?: CollectionOptions;
@@ -40,6 +40,7 @@ export interface MongoDBClientDBOptions {
     bulkWrite?: ClientBulkWriteModel[];
     aggregate?: MongoDBAggregate | Document[];
     sort?: Sort | string | MongoDBSortValue;
+    withFields?: Document;
 }
 
 export interface MongoDBFilterValue {
@@ -47,6 +48,10 @@ export interface MongoDBFilterValue {
     options?: CommandOperationOptions;
 }
 
+export interface TimeoutAction {
+    timeoutMS?: number;
+}
+
 export interface DbPoolCredential extends IdentifierAction {
     uri?: string;
     options?: MongoClientOptions;