mongodb-ops 0.10.1 → 0.11.1

package/lib/mongodb-ops.js

@@ -1,360 +1,406 @@
-'use strict';
-
-const MongoClient = require('mongodb').MongoClient;
-const ObjectID = require('mongodb').ObjectId;
-
-class MongoDBOps {
-  /**
-   * @class
-   * @classdesc MongoDB operations - Note: writeConcern is not supported in this class
-   * 
-   * @param {string} connString Database connection string
-   */
-  constructor(connString) {
-    if (!connString) { throw new Error("missing-connection-string"); }
-    this.connString = connString;
-  }
-
-  /**
-   * Static method - Get ObjectId instance from string
-   * 
-   * @param {string} id Object ID string
-   * @returns {object} ObjectId instance
-   */
-  static getObjectId(id) { return new ObjectID(id); }
-
-  /**
-   * Instance method - Get ObjectId instance from string
-   * 
-   * @param {string} id Object ID string
-   * @returns {object} ObjectId instance
-   */
-  getObjectId(id) { return new ObjectID(id); }
-
-  /**
-   * Static method - Get DB client - It supports multiple db client with different connection string. Active db client will be reused for better performance
-   * 
-   * @param {string} connString Database connection string
-   * @returns {promise} Promise with db client
-   */
-  static async getDbClient(connString) {
-    if (!connString) { throw new Error("missing-connection-string"); }
-
-    if (!Array.isArray(MongoDBOps.dbClientList)) { MongoDBOps.dbClientList = []; }
-
-    for (let item of MongoDBOps.dbClientList) {
-      if (item.s.url === connString) {
-        if (item.topology.s.state !== "connected") {
-          item = await MongoClient.connect(connString);
-        }
-
-        return Promise.resolve(item);
-      }
-    }
-
-    const newDbClient = await MongoClient.connect(connString);
-    MongoDBOps.dbClientList.push(newDbClient);
-
-    return Promise.resolve(newDbClient);
-  }
-
-  /**
-   * Static method - Close database connection
-   * @returns {promise}
-   */
-  static async closeDBConn() {
-    if (Array.isArray(MongoDBOps.dbClientList)) {
-      for (const item of MongoDBOps.dbClientList) {
-        await item.close();
-      }
-    }
-    return Promise.resolve();
-  }
-
-  /**
-   * Instance method - Close database connection
-   * @returns {promise}
-   */
-  async closeDBConn() {
-    return Promise.resolve(await MongoDBOps.closeDBConn());
-  }
-
-  /**
-   * Static method - Get documents from MongoDB
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.aggregate/}
-   * 
-   * @param {string} collectionName Collection name
-   * @param {object} [queryExp] Query Specifies selection filter using query operators - {@link https://docs.mongodb.com/manual/reference/operator/}
-   * @param {boolean} [isAggregate=false] Set true to use the aggregation
-   * @param {object} [projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
-   * @param {object} [sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
-   * @param {object} [pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
-   * @param {boolean} [isGetCount=false] Set true to get the number of doc count based on the queryExp
-   * @param {string} connString Database connection string
-   * @param {object} [collation] Collation {@link https://www.mongodb.com/docs/manual/reference/collation/#std-label-collation-document-fields}
-   * @param {object} [options] Aggregate options {@link https://www.mongodb.com/docs/manual/reference/method/db.collection.aggregate/}
-   * @returns {promise} Promise with object array
-   */
-  static async getData(collectionName, queryExp, isAggregate = false, projection, sort, pagination, isGetCount = false, connString, collation, options) {   
-    const db = (await MongoDBOps.getDbClient(connString)).db();
-    
-    if (isAggregate) { return Promise.resolve(await db.collection(collectionName).aggregate(queryExp, options).toArray()); }
-
-    queryExp = queryExp || {};
-    if (isGetCount) { return Promise.resolve(await db.collection(collectionName).countDocuments(queryExp)); }
-
-    const { skip, limit } = parsePagination(pagination);
-    if (limit < 1) { return Promise.resolve([]); }
-
-    projection = { projection: projection || {} };
-    
-    let data = db.collection(collectionName).find(queryExp, projection);
-    if (sort) { data = data.sort(sort); }
-    if (pagination) { data = data.skip(skip).limit(limit); }
-    if (collation) { data = data.collation(collation); }
-
-    return Promise.resolve(await data.toArray());
-  }
-
-  /**
-   * Instance method - Get documents from MongoDB
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.aggregate/}
-   * 
-   * @param {string} collectionName Collection name
-   * @param {object} [queryExp] Query Specifies selection filter using query operators - {@link https://docs.mongodb.com/manual/reference/operator/}
-   * @param {boolean} [isAggregate=false] Set true to use the aggregation
-   * @param {object} [projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
-   * @param {object} [sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
-   * @param {object} [pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
-   * @param {boolean} [isGetCount=false] Set true to get the number of doc count based on the queryExp
-   * @param {object} [collation] Collation {@link https://www.mongodb.com/docs/manual/reference/collation/#std-label-collation-document-fields}
-   * @param {object} [options] Aggregate options {@link https://www.mongodb.com/docs/manual/reference/method/db.collection.aggregate/}
-   * @returns {promise} Promise with object array
-   */
-  async getData(collectionName, queryExp, isAggregate, projection, sort, pagination, isGetCount, collation, options) {
-    return Promise.resolve(await MongoDBOps.getData(collectionName, queryExp, isAggregate, projection, sort, pagination, isGetCount, this.connString, collation, options));
-  }
-
-  /**
-   * Static method - Use altas search at MongoDB
-   * {@link https://www.mongodb.com/docs/atlas/atlas-search/}
-   * 
-   * @param {string} connString Database connection string
-   * @param {string} collectionName Collection name
-   * @param {object} search $search object - {@link https://www.mongodb.com/docs/atlas/atlas-search/query-syntax/}
-   * @param {object} [obj]
-   * @param {object} [obj.projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
-   * @param {object} [obj.sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
-   * @param {object} [obj.pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
-   * @param {boolean} [isGetCount=true] Set true to get the number of total matching docs and current page number
-   * @returns {promise} Promise with object or object array
-   */
-  static async search(connString, collectionName, search, { projection, sort, pagination }={}, isGetCount = true) {
-    if ([connString, collectionName, search].includes(undefined)) { return Promise.reject("Connection string, collection name and search cannot be undefined"); }
-
-    const { skip, limit } = parsePagination(pagination);
-    if (limit < 1) { return Promise.resolve([]); }
-
-    const payload = [
-      { $search: search },
-      { $addFields: { score: { $meta: "searchScore" }}},
-    ];
-
-    if (projection) { payload.push({ $project: projection }); }
-    if (sort) { payload.push({ $sort: sort }); }
-
-    const skipLimit = [];
-    if (skip) { skipLimit.push({ $skip: skip }); }
-    if (limit) { skipLimit.push({ $limit: limit }); }
-
-    if (isGetCount) {
-      payload.push({ 
-        $facet: {
-          metadata: [{ $count: "total" }, { $addFields: { page: Math.ceil((skip + 1) / limit) }}],
-          data: skipLimit,
-        }
-      });
-    }
-    else { payload.push(...skipLimit); }
-
-    const result = await MongoDBOps.getData(collectionName, payload, true, undefined, undefined, undefined, undefined, connString);
-
-    return Promise.resolve(isGetCount ? result[0] : result);
-  }
-
-  /**
-   * Instance method - Use altas search at MongoDB
-   * {@link https://www.mongodb.com/docs/atlas/atlas-search/}
-   * 
-   * @param {string} collectionName Collection name
-   * @param {object} search $search object - {@link https://www.mongodb.com/docs/atlas/atlas-search/query-syntax/}
-   * @param {object} [obj]
-   * @param {object} [obj.projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
-   * @param {object} [obj.sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
-   * @param {object} [obj.pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
-   * @param {boolean} [isGetCount=true] Set true to get the number of total matching docs and current page number
-   * @returns {promise} Promise with object or object array
-   */
-  async search(collectionName, search, { projection, sort, pagination }={}, isGetCount = true) {
-    return Promise.resolve(await MongoDBOps.search(this.connString, collectionName, search, { projection, sort, pagination }, isGetCount));
-  }
-
-  /**
-   * Static method - Write document to MongoDB
-   * 
-   * References:
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.insertOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.replaceOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteMany/}
-   * 
-   * @param {string} type Write type - insertOne, replaceOne, updateOne, updateMany, deleteOne, deleteMany
-   * @param {string} collectionName Collection name
-   * @param {object} doc Data document
-   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
-   * @param {string} connString Database connection string 
-   * @returns {promise}
-   */
-  static async writeData(type, collectionName, doc, filter, connString) {
-    try {
-      const db = (await MongoDBOps.getDbClient(connString)).db();
-
-      let result;
-      switch(type) {
-        case "insertOne": result = await db.collection(collectionName).insertOne(doc); break;
-        case "replaceOne": result = await db.collection(collectionName).replaceOne(filter, doc); break;
-        case "updateOne": result = await db.collection(collectionName).updateOne(filter, doc); break;
-        case "updateMany": result = await db.collection(collectionName).updateMany(filter, doc); break;
-        case "deleteOne": result = await db.collection(collectionName).deleteOne(filter); break;
-        case "deleteMany": result = await db.collection(collectionName).deleteMany(filter); break;
-        default: throw new Error("invalid-writeData-type");
-      }
-      return Promise.resolve(result);
-    }
-    catch (err) { return Promise.reject(err.errmsg || err.message || err); }
-  }
-
-  /**
-   * Instance method - Write document to MongoDB
-   * 
-   * References:
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.insertOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.replaceOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteOne/}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteMany/}
-   * 
-   * @param {string} type Write type - insertOne, replaceOne, updateOne, updateMany, deleteOne, deleteMany
-   * @param {string} collectionName Collection name
-   * @param {object} doc Data document
-   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
-   * @returns {promise}
-   */
-  async writeData(type, collectionName, doc, filter) {
-    return Promise.resolve(await MongoDBOps.writeData(type, collectionName, doc, filter, this.connString));
-  }
-
-  /**
-   * Static method - Write document to MongoDB via BulkOps / BulkWrite
-   * 
-   * References:
-   * {@link https://mongodb.github.io/node-mongodb-native/3.6/api/BulkOperationBase.html}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.bulkWrite/}
-   * 
-   * @param {string} type Write type - insertBulk, replaceBulk, updateBulk, allBulk
-   * @param {string} collectionName Collection name 
-   * @param {Array} docs Data documents array
-   * @param {boolean} [ordered=false] Set true to use ordered bulkWrite
-   * @param {string} connString Database connection string
-   * @returns {promise}
-   */
-  static async writeBulkData(type, collectionName, docs, ordered = false, connString) {
-    try {
-      const db = (await MongoDBOps.getDbClient(connString)).db();
-
-      let result;
-      switch(type) {
-        case "insertBulk":
-          for (let i = 0; i < docs.length; ++i) { docs[i] = { insertOne: { "document": docs[i] }}; }
-          break;
-        case "replaceBulk":
-          // doc = {
-          //   "filter": <document>,
-          //   "replacement": <document>,
-          //   "upsert": <boolean>,
-          //   "collation": <document>,
-          //   "hint": <document|string>
-          // }
-          for (let i = 0; i < docs.length; ++i) { docs[i] = { replaceOne: docs[i] }; }
-          break;
-        case "updateBulk":
-          // doc = {
-          //   "filter": <document>,
-          //   "update": <document or pipeline>,
-          //   "upsert": <boolean>,
-          //   "collation": <document>,
-          //   "arrayFilters": [ <filterdocument1>, ... ],
-          //   "hint": <document|string>
-          // }
-          for (let i = 0; i < docs.length; ++i) { docs[i] = { updateOne: docs[i] }; }
-          break;
-        case "deleteBulk":
-          // doc = {
-          //   "filter": <document>,
-          //   "collation": <document>
-          // }
-          for (let i = 0; i < docs.length; ++i) { docs[i] = { deleteOne: docs[i] }; }
-          break;
-        case "allBulk":
-          // allowed bulkWrite operations include insertOne, replaceOne, updateOne, updateMany, deleteOne, deleteMany
-          break;
-        default: throw new Error("invalid-writeBulkData-type");
-      }
-      result = await db.collection(collectionName).bulkWrite(docs, { ordered: ordered });
-      return Promise.resolve(result);
-    }
-    catch (err) { return Promise.reject(err.result || err.errmsg || err.message); }
-  }
-
-  /**
-   * Instance method - Write document to MongoDB via BulkOps / BulkWrite
-   * 
-   * References:
-   * {@link https://mongodb.github.io/node-mongodb-native/3.6/api/BulkOperationBase.html}
-   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.bulkWrite/}
-   * 
-   * @param {string} type Write type - insertBulk, replaceBulk, updateBulk, allBulk
-   * @param {string} collectionName Collection name 
-   * @param {Array} docs Data documents array
-   * @param {boolean} [ordered=false] Set true to use ordered bulkWrite
-   * @returns {promise}
-   */
-  async writeBulkData(type, collectionName, docs, ordered = false) {
-    return Promise.resolve(await MongoDBOps.writeBulkData(type, collectionName, docs, ordered, this.connString));
-  }
-}
-
-module.exports = MongoDBOps;
-
-/**
- * Parse the pagaintion and return skip and limit values
- * 
- * @param {object} obj
- * @param {number} [obj.startIndex] Start index
- * @param {number} [obj.endIndex] Start index
- * @returns {object} Object with skip and limit values
- */
-const parsePagination = ({ startIndex, endIndex }={})=> {
-  startIndex = +startIndex; endIndex = +endIndex;
-  startIndex = startIndex < 1 ? 1 : startIndex;
-
-  return {
-    skip: Number.isInteger(startIndex) ? startIndex - 1 : undefined,
-    limit: Number.isInteger(startIndex) && Number.isInteger(endIndex) ? ((endIndex - startIndex + 1) < 0 ? 0 : endIndex - startIndex + 1) : undefined
-  };
-}
+'use strict';
+
+const MongoClient = require('mongodb').MongoClient;
+const ObjectID = require('mongodb').ObjectId;
+
+class MongoDBOps {
+  /**
+   * @class
+   * @classdesc MongoDB operations - Note: writeConcern is not supported in this class
+   * 
+   * @param {string} connString Database connection string
+   */
+  constructor(connString) {
+    if (!connString) { throw new Error("missing-connection-string"); }
+    this.connString = connString;
+  }
+
+  /**
+   * Static method - Get ObjectId instance from string
+   * 
+   * @param {string} id Object ID string
+   * @returns {object} ObjectId instance
+   */
+  static getObjectId(id) { return new ObjectID(id); }
+
+  /**
+   * Instance method - Get ObjectId instance from string
+   * 
+   * @param {string} id Object ID string
+   * @returns {object} ObjectId instance
+   */
+  getObjectId(id) { return new ObjectID(id); }
+
+  /**
+   * Static method - Get DB client - It supports multiple db client with different connection string. Active db client will be reused for better performance
+   * 
+   * @param {string} connString Database connection string
+   * @returns {promise} Promise with db client
+   */
+  static async getDbClient(connString) {
+    if (!connString) { throw new Error("missing-connection-string"); }
+
+    if (!(MongoDBOps.dbClients instanceof Map)) { MongoDBOps.dbClients = new Map(); }
+
+    let clientPromise = MongoDBOps.dbClients.get(connString);
+    if (!clientPromise) {
+      const options = Object.assign(
+        { serverSelectionTimeoutMS: 8000, retryWrites: true, retryReads: true },
+        MongoDBOps.clientOptions || {}
+      );
+
+      clientPromise = MongoClient.connect(connString, options).catch((err) => {
+        if (MongoDBOps.dbClients.get(connString) === clientPromise) {
+          MongoDBOps.dbClients.delete(connString);
+        }
+        throw err;
+      });
+      MongoDBOps.dbClients.set(connString, clientPromise);
+    }
+
+    return clientPromise;
+  }
+
+  /**
+   * Static method - Close database connection
+   * @returns {promise}
+   */
+  static async closeDBConn() {
+    if (MongoDBOps.dbClients instanceof Map) {
+      const clientPromises = Array.from(MongoDBOps.dbClients.values());
+      MongoDBOps.dbClients.clear();
+
+      for (const clientPromise of clientPromises) {
+        try {
+          const client = await clientPromise;
+          await client.close();
+        } catch {
+          // Failed or already-evicted connection attempts do not need separate cleanup.
+        }
+      }
+    }
+
+    if (Array.isArray(MongoDBOps.dbClientList)) {
+      const legacyClients = MongoDBOps.dbClientList;
+      MongoDBOps.dbClientList = [];
+
+      for (const item of legacyClients) {
+        try {
+          await item.close();
+        } catch {
+          // Ignore stale legacy clients from older mixed-version processes.
+        }
+      }
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Instance method - Close database connection
+   * @returns {promise}
+   */
+  async closeDBConn() {
+    return Promise.resolve(await MongoDBOps.closeDBConn());
+  }
+
+  /**
+   * Static method - Get estimated document count of a collection
+   * 
+   * @param {string} collectionName Collection Name
+   * @param {string} connString Database connection string
+   */
+  static async getCollectionCount(collectionName, connString) {
+    const db = (await MongoDBOps.getDbClient(connString)).db();
+    return Promise.resolve(await db.collection(collectionName).estimatedDocumentCount());
+  }
+
+  /**
+   * Instance method - Get estimated document count of a collection
+   * 
+   * @param {string} collectionName Collection Name
+   * @param {string} connString Database connection string
+   */
+  async getCollectionCount(collectionName) {
+    return Promise.resolve(await MongoDBOps.getData(collectionName, this.connString));
+  }
+
+  /**
+   * Static method - Get documents from MongoDB
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.aggregate/}
+   * 
+   * @param {string} collectionName Collection name
+   * @param {object} [queryExp] Query Specifies selection filter using query operators - {@link https://docs.mongodb.com/manual/reference/operator/}
+   * @param {boolean} [isAggregate=false] Set true to use the aggregation
+   * @param {object} [projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
+   * @param {object} [sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
+   * @param {object} [pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
+   * @param {boolean} [isGetCount=false] Set true to get the number of doc count based on the queryExp
+   * @param {string} connString Database connection string
+   * @param {object} [collation] Collation {@link https://www.mongodb.com/docs/manual/reference/collation/#std-label-collation-document-fields}
+   * @param {object} [options] Aggregate options {@link https://www.mongodb.com/docs/manual/reference/method/db.collection.aggregate/}
+   * @returns {promise} Promise with object array
+   */
+  static async getData(collectionName, queryExp, isAggregate = false, projection, sort, pagination, isGetCount = false, connString, collation, options) {   
+    const db = (await MongoDBOps.getDbClient(connString)).db();
+    
+    if (isAggregate) { return Promise.resolve(await db.collection(collectionName).aggregate(queryExp, options).toArray()); }
+
+    queryExp = queryExp || {};
+    if (isGetCount) { return Promise.resolve(await db.collection(collectionName).countDocuments(queryExp)); }
+
+    const { skip, limit } = parsePagination(pagination);
+    if (limit < 1) { return Promise.resolve([]); }
+
+    projection = { projection: projection || {} };
+    
+    let data = db.collection(collectionName).find(queryExp, projection);
+    if (sort) { data = data.sort(sort); }
+    if (pagination) { data = data.skip(skip).limit(limit); }
+    if (collation) { data = data.collation(collation); }
+
+    return Promise.resolve(await data.toArray());
+  }
+
+  /**
+   * Instance method - Get documents from MongoDB
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.aggregate/}
+   * 
+   * @param {string} collectionName Collection name
+   * @param {object} [queryExp] Query Specifies selection filter using query operators - {@link https://docs.mongodb.com/manual/reference/operator/}
+   * @param {boolean} [isAggregate=false] Set true to use the aggregation
+   * @param {object} [projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
+   * @param {object} [sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
+   * @param {object} [pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
+   * @param {boolean} [isGetCount=false] Set true to get the number of doc count based on the queryExp
+   * @param {object} [collation] Collation {@link https://www.mongodb.com/docs/manual/reference/collation/#std-label-collation-document-fields}
+   * @param {object} [options] Aggregate options {@link https://www.mongodb.com/docs/manual/reference/method/db.collection.aggregate/}
+   * @returns {promise} Promise with object array
+   */
+  async getData(collectionName, queryExp, isAggregate, projection, sort, pagination, isGetCount, collation, options) {
+    return Promise.resolve(await MongoDBOps.getData(collectionName, queryExp, isAggregate, projection, sort, pagination, isGetCount, this.connString, collation, options));
+  }
+
+  /**
+   * Static method - Use altas search at MongoDB
+   * {@link https://www.mongodb.com/docs/atlas/atlas-search/}
+   * 
+   * @param {string} connString Database connection string
+   * @param {string} collectionName Collection name
+   * @param {object} search $search object - {@link https://www.mongodb.com/docs/atlas/atlas-search/query-syntax/}
+   * @param {object} [obj]
+   * @param {object} [obj.projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
+   * @param {object} [obj.sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
+   * @param {object} [obj.pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
+   * @param {boolean} [isGetCount=true] Set true to get the number of total matching docs and current page number
+   * @returns {promise} Promise with object or object array
+   */
+  static async search(connString, collectionName, search, { projection, sort, pagination }={}, isGetCount = true) {
+    if ([connString, collectionName, search].includes(undefined)) { return Promise.reject("Connection string, collection name and search cannot be undefined"); }
+
+    const { skip, limit } = parsePagination(pagination);
+    if (limit < 1) { return Promise.resolve([]); }
+
+    const payload = [
+      { $search: search },
+      { $addFields: { score: { $meta: "searchScore" }}},
+    ];
+
+    if (projection) { payload.push({ $project: projection }); }
+    if (sort) { payload.push({ $sort: sort }); }
+
+    const skipLimit = [];
+    if (skip) { skipLimit.push({ $skip: skip }); }
+    if (limit) { skipLimit.push({ $limit: limit }); }
+
+    if (isGetCount) {
+      payload.push({ 
+        $facet: {
+          metadata: [{ $count: "total" }, { $addFields: { page: Math.ceil((skip + 1) / limit) }}],
+          data: skipLimit,
+        }
+      });
+    }
+    else { payload.push(...skipLimit); }
+
+    const result = await MongoDBOps.getData(collectionName, payload, true, undefined, undefined, undefined, undefined, connString);
+
+    return Promise.resolve(isGetCount ? result[0] : result);
+  }
+
+  /**
+   * Instance method - Use altas search at MongoDB
+   * {@link https://www.mongodb.com/docs/atlas/atlas-search/}
+   * 
+   * @param {string} collectionName Collection name
+   * @param {object} search $search object - {@link https://www.mongodb.com/docs/atlas/atlas-search/query-syntax/}
+   * @param {object} [obj]
+   * @param {object} [obj.projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
+   * @param {object} [obj.sort] Sort {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort}
+   * @param {object} [obj.pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
+   * @param {boolean} [isGetCount=true] Set true to get the number of total matching docs and current page number
+   * @returns {promise} Promise with object or object array
+   */
+  async search(collectionName, search, { projection, sort, pagination }={}, isGetCount = true) {
+    return Promise.resolve(await MongoDBOps.search(this.connString, collectionName, search, { projection, sort, pagination }, isGetCount));
+  }
+
+  /**
+   * Static method - Write document to MongoDB
+   * 
+   * References:
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.insertOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.replaceOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteMany/}
+   * 
+   * @param {string} type Write type - insertOne, replaceOne, updateOne, updateMany, deleteOne, deleteMany
+   * @param {string} collectionName Collection name
+   * @param {object} doc Data document
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
+   * @param {string} connString Database connection string 
+   * @returns {promise}
+   */
+  static async writeData(type, collectionName, doc, filter, connString) {
+    try {
+      const db = (await MongoDBOps.getDbClient(connString)).db();
+
+      let result;
+      switch(type) {
+        case "insertOne": result = await db.collection(collectionName).insertOne(doc); break;
+        case "replaceOne": result = await db.collection(collectionName).replaceOne(filter, doc); break;
+        case "updateOne": result = await db.collection(collectionName).updateOne(filter, doc); break;
+        case "updateMany": result = await db.collection(collectionName).updateMany(filter, doc); break;
+        case "deleteOne": result = await db.collection(collectionName).deleteOne(filter); break;
+        case "deleteMany": result = await db.collection(collectionName).deleteMany(filter); break;
+        default: throw new Error("invalid-writeData-type");
+      }
+      return Promise.resolve(result);
+    }
+    catch (err) { return Promise.reject(err.errmsg || err.message || err); }
+  }
+
+  /**
+   * Instance method - Write document to MongoDB
+   * 
+   * References:
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.insertOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.replaceOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteOne/}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.deleteMany/}
+   * 
+   * @param {string} type Write type - insertOne, replaceOne, updateOne, updateMany, deleteOne, deleteMany
+   * @param {string} collectionName Collection name
+   * @param {object} doc Data document
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
+   * @returns {promise}
+   */
+  async writeData(type, collectionName, doc, filter) {
+    return Promise.resolve(await MongoDBOps.writeData(type, collectionName, doc, filter, this.connString));
+  }
+
+  /**
+   * Static method - Write document to MongoDB via BulkOps / BulkWrite
+   * 
+   * References:
+   * {@link https://mongodb.github.io/node-mongodb-native/3.6/api/BulkOperationBase.html}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.bulkWrite/}
+   * 
+   * @param {string} type Write type - insertBulk, replaceBulk, updateBulk, allBulk
+   * @param {string} collectionName Collection name 
+   * @param {Array} docs Data documents array
+   * @param {boolean} [ordered=false] Set true to use ordered bulkWrite
+   * @param {string} connString Database connection string
+   * @returns {promise}
+   */
+  static async writeBulkData(type, collectionName, docs, ordered = false, connString) {
+    try {
+      const db = (await MongoDBOps.getDbClient(connString)).db();
+
+      let result;
+      switch(type) {
+        case "insertBulk":
+          for (let i = 0; i < docs.length; ++i) { docs[i] = { insertOne: { "document": docs[i] }}; }
+          break;
+        case "replaceBulk":
+          // doc = {
+          //   "filter": <document>,
+          //   "replacement": <document>,
+          //   "upsert": <boolean>,
+          //   "collation": <document>,
+          //   "hint": <document|string>
+          // }
+          for (let i = 0; i < docs.length; ++i) { docs[i] = { replaceOne: docs[i] }; }
+          break;
+        case "updateBulk":
+          // doc = {
+          //   "filter": <document>,
+          //   "update": <document or pipeline>,
+          //   "upsert": <boolean>,
+          //   "collation": <document>,
+          //   "arrayFilters": [ <filterdocument1>, ... ],
+          //   "hint": <document|string>
+          // }
+          for (let i = 0; i < docs.length; ++i) { docs[i] = { updateOne: docs[i] }; }
+          break;
+        case "deleteBulk":
+          // doc = {
+          //   "filter": <document>,
+          //   "collation": <document>
+          // }
+          for (let i = 0; i < docs.length; ++i) { docs[i] = { deleteOne: docs[i] }; }
+          break;
+        case "allBulk":
+          // allowed bulkWrite operations include insertOne, replaceOne, updateOne, updateMany, deleteOne, deleteMany
+          break;
+        default: throw new Error("invalid-writeBulkData-type");
+      }
+      result = await db.collection(collectionName).bulkWrite(docs, { ordered: ordered });
+      return Promise.resolve(result);
+    }
+    catch (err) { return Promise.reject(err.result || err.errmsg || err.message); }
+  }
+
+  /**
+   * Instance method - Write document to MongoDB via BulkOps / BulkWrite
+   * 
+   * References:
+   * {@link https://mongodb.github.io/node-mongodb-native/3.6/api/BulkOperationBase.html}
+   * {@link https://docs.mongodb.com/manual/reference/method/db.collection.bulkWrite/}
+   * 
+   * @param {string} type Write type - insertBulk, replaceBulk, updateBulk, allBulk
+   * @param {string} collectionName Collection name 
+   * @param {Array} docs Data documents array
+   * @param {boolean} [ordered=false] Set true to use ordered bulkWrite
+   * @returns {promise}
+   */
+  async writeBulkData(type, collectionName, docs, ordered = false) {
+    return Promise.resolve(await MongoDBOps.writeBulkData(type, collectionName, docs, ordered, this.connString));
+  }
+}
+
+module.exports = MongoDBOps;
+
+/**
+ * Parse the pagaintion and return skip and limit values
+ * 
+ * @param {object} obj
+ * @param {number} [obj.startIndex] Start index
+ * @param {number} [obj.endIndex] Start index
+ * @returns {object} Object with skip and limit values
+ */
+const parsePagination = ({ startIndex, endIndex }={})=> {
+  startIndex = +startIndex; endIndex = +endIndex;
+  startIndex = startIndex < 1 ? 1 : startIndex;
+
+  return {
+    skip: Number.isInteger(startIndex) ? startIndex - 1 : undefined,
+    limit: Number.isInteger(startIndex) && Number.isInteger(endIndex) ? ((endIndex - startIndex + 1) < 0 ? 0 : endIndex - startIndex + 1) : undefined
+  };
+}

package/package.json

@@ -1,28 +1,29 @@
-{
-  "name": "mongodb-ops",
-  "version": "0.10.1",
-  "description": "Read and write ops for MongoDB",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "dependencies": {
-    "mongodb": "^6.8.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/CompAndSave/mongodb-ops.git"
-  },
-  "keywords": [
-    "mongodb"
-  ],
-  "author": "Andrew Y",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/CompAndSave/mongodb-ops/issues"
-  },
-  "homepage": "https://github.com/CompAndSave/mongodb-ops#readme",
-  "directories": {
-    "lib": "lib"
-  }
-}
+{
+  "name": "mongodb-ops",
+  "version": "0.11.1",
+  "description": "Read and write ops for MongoDB",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --test",
+    "lint": "node --check index.js && node --check lib/mongodb-ops.js && node --check test/mongodb-ops.test.js"
+  },
+  "dependencies": {
+    "mongodb": "^6.8.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CompAndSave/mongodb-ops.git"
+  },
+  "keywords": [
+    "mongodb"
+  ],
+  "author": "Andrew Y",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/CompAndSave/mongodb-ops/issues"
+  },
+  "homepage": "https://github.com/CompAndSave/mongodb-ops#readme",
+  "directories": {
+    "lib": "lib"
+  }
+}

package/readme.md

@@ -1,65 +1,130 @@
-# Read and write ops for MongoDB
-**DB client is at static level - It will keep alive and can be reused**
-
-**Updated - MongoDBToolSet class is added**
-```
-const { MongoDBToolSet } = require('mongodb-ops');
-```
-
-**Sample code to use the class**
-
-```
-const { MongoDBOps } = require('mongodb-ops');
-const connString = "mongodb+srv://YOUR_DB_USERNAME:YOUR_DB_PASSWORD@YOUR_MONGO_ATLAS_URL/YOUR_DBNAME?retryWrites=true&w=majority";
-
-class MongoDBToolSet extends MongoDBOps {
-  constructor(collectionName) {
-    super(connString);
-    this.collectionName = collectionName;
-  }
-
-  static async getDataByID(collectionName, id, projection) {
-    let queryFilter = { _id:id };
-    return Promise.resolve(await MongoDBOps.getData(collectionName, queryFilter, false, projection, undefined, undefined, undefined, connString));
-  }
-
-  async getDataByID(id, projection) { return Promise.resolve(await MongoDBToolSet.getDataByID(this.collectionName, id, projection)); }
-
-  static async getAllData(collectionName, projection, sort, pagination) {
-    let queryFilter = {};
-    return Promise.resolve(await MongoDBOps.getData(collectionName, queryFilter, false, projection, sort, pagination, false, connString));
-  }
-
-  async getAllData(site, projection, sort, pagination) { return Promise.resolve(await MongoDBToolSet.getAllData(this.collectionName, projection, sort, pagination)); }
-
-  static async insertOne(collectionName, doc) { return Promise.resolve(await MongoDBOps.writeData("insertOne", collectionName, doc, undefined, connString)); }
-  async insertOne(doc) { return Promise.resolve(await super.writeData("insertOne", this.collectionName, doc)); }
-  static async insertBulkOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("insertBulk", collectionName, docs, true, connString)); }
-  async insertBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("insertBulk", this.collectionName, docs, true)); }
-  static async insertBulkUnOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("insertBulk", collectionName, docs, false, connString)); }
-  async insertBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("insertBulk", this.collectionName, docs, false)); }
-
-  static async replaceOne(collectionName, doc, filter) { return Promise.resolve(await MongoDBOps.writeData("replaceOne", collectionName, doc, filter, connString)); }
-  async replaceOne(doc, filter) { return Promise.resolve(await super.writeData("replaceOne", this.collectionName, doc, filter)); }
-  static async replaceBulkOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("replaceBulk", collectionName, docs, true, connString)); }
-  async replaceBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("replaceBulk", this.collectionName, docs, true)); }
-  static async replaceBulkUnOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("replaceBulk", collectionName, docs, false, connString)); }
-  async replaceBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("replaceBulk", this.collectionName, docs, false)); }
-
-  static async updateOne(collectionName, doc, filter) { return Promise.resolve(await MongoDBOps.writeData("updateOne", collectionName, doc, filter, connString)); }
-  async updateOne(doc, filter) { return Promise.resolve(await super.writeData("updateOne", this.collectionName, doc, filter)); }
-  static async updateMany(collectionName, doc, filter) { return Promise.resolve(await MongoDBOps.writeData("updateMany", collectionName, doc, filter, connString)); }
-  async updateMany(doc, filter) { return Promise.resolve(await super.writeData("updateMany", this.collectionName, doc, filter)); }
-  static async updateBulkOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("updateBulk", collectionName, docs, true, connString)); }
-  async updateBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("updateBulk", this.collectionName, docs, true)); }
-  static async updateBulkUnOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("updateBulk", collectionName, docs, false, connString)); }
-  async updateBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("updateBulk", this.collectionName, docs, false)); }
-
-  static async allBulkOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("allBulk", collectionName, docs, true, connString)); }
-  async allBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("allBulk", this.collectionName, docs, true)); }
-  static async allBulkUnOrdered(collectionName, docs) { return Promise.resolve(await MongoDBOps.writeBulkData("allBulk", collectionName, docs, false, connString)); }
-  async allBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("allBulk", this.collectionName, docs, false)); }
-}
-
-module.exports = MongoDB;
-```
+# mongodb-ops
+
+Lightweight read/write helpers for MongoDB with a **shared, self-managing client**. The MongoDB client is cached at the class (process) level per connection string and reused across calls — you connect once and let the driver handle pooling, topology monitoring, and failover recovery.
+
+> `writeConcern` is not configurable through this library.
+
+## Install
+
+```bash
+npm install mongodb-ops
+```
+
+Requires Node.js 16+ and bundles the official `mongodb` driver (v6).
+
+## Exports
+
+```js
+const { MongoDBOps, MongoDBToolSet } = require('mongodb-ops');
+```
+
+- **`MongoDBOps`** — low-level static/instance operations (`getData`, `search`, `writeData`, `writeBulkData`, `getCollectionCount`, `getDbClient`, `closeDBConn`, `getObjectId`).
+- **`MongoDBToolSet`** — a higher-level, collection-scoped convenience class that extends `MongoDBOps` (get / insert / update / replace / delete + bulk variants).
+
+## Quick start
+
+### Collection-scoped (`MongoDBToolSet`)
+
+```js
+const { MongoDBToolSet } = require('mongodb-ops');
+
+const connString = "mongodb+srv://USER:PASS@your-cluster.mongodb.net/your-db?retryWrites=true&w=majority";
+
+// Instance style — bind a collection + connection once
+const orders = new MongoDBToolSet('orders', connString);
+
+await orders.insertOne({ number: 'PO-1001', status: 'open' });
+const open = await orders.getDataByFilter({ status: 'open' }, { number: 1 }, { number: -1 });
+await orders.updateOne({ $set: { status: 'closed' } }, { number: 'PO-1001' });
+```
+
+Every method also has a **static** form that takes the collection name and connection string explicitly — handy when wrapping it in your own model class:
+
+```js
+class Order extends MongoDBToolSet {
+  static collectionName = 'orders';
+  static connString = connString;
+
+  static getById(id) {
+    return MongoDBToolSet.getDataByID(this.collectionName, id, undefined, this.connString);
+  }
+}
+```
+
+### Low-level (`MongoDBOps`)
+
+```js
+const { MongoDBOps } = require('mongodb-ops');
+
+const rows = await MongoDBOps.getData(
+  'orders',
+  { status: 'open' },              // query
+  false,                           // isAggregate
+  { number: 1 },                   // projection
+  { number: -1 },                  // sort
+  { startIndex: 1, endIndex: 20 }, // pagination (1-based, inclusive)
+  false,                           // isGetCount
+  connString
+);
+```
+
+## Connection management
+
+`getDbClient(connString)` maintains **one cached `MongoClient` per connection string** for the life of the process (kept in an internal `Map`; concurrent first-connects are de-duplicated). All operations reuse it, so there is no per-call connect overhead — and the driver's topology monitoring transparently rediscovers a new primary after a replica-set failover.
+
+Clients are created with safe, failover-friendly defaults:
+
+```js
+{ serverSelectionTimeoutMS: 8000, retryWrites: true, retryReads: true }
+```
+
+**Override or extend** the driver options process-wide, before the first connection is made — your values are merged over the defaults:
+
+```js
+const { MongoDBOps } = require('mongodb-ops');
+MongoDBOps.clientOptions = { maxPoolSize: 20 };
+```
+
+**Close** every cached connection (e.g. in a CLI or test teardown; long-running servers/Lambdas normally leave them open for reuse):
+
+```js
+await MongoDBOps.closeDBConn();
+```
+
+## API
+
+### `MongoDBToolSet`
+
+Constructor: `new MongoDBToolSet(collectionName, connString)`. Instance methods use the bound collection/connection; each has a matching static method that takes them as arguments.
+
+| Read | Write | Bulk |
+|---|---|---|
+| `getDataByID` | `insertOne` | `insertBulkOrdered` / `insertBulkUnOrdered` |
+| `getDataByFilter` | `replaceOne` | `replaceBulkOrdered` / `replaceBulkUnOrdered` |
+| `getDataByAggregate` | `updateOne` / `updateMany` | `updateBulkOrdered` / `updateBulkUnOrdered` |
+| `getDataCount` | `deleteOne` / `deleteMany` | `deleteBulkOrdered` / `deleteBulkUnOrdered` |
+| `list` (rows + optional total) | | `allBulkOrdered` / `allBulkUnOrdered` |
+| `getAllData` | | |
+
+### `MongoDBOps`
+
+`getData`, `search`, `writeData(type, …)`, `writeBulkData(type, …, ordered)`, `getCollectionCount`, `getObjectId`, `getDbClient`, `closeDBConn`.
+
+## Changelog
+
+### 0.11.1
+- **Hardened connection caching.** The client cache is now keyed by connection string in a `Map` (previously matched against MongoDB driver internals), making client reuse reliable across driver versions.
+- **De-duplicated concurrent cold-start connects** by caching the connect promise; a failed connect is evicted so the next call retries instead of caching a rejected promise.
+- **Safer driver defaults:** `serverSelectionTimeoutMS: 8000`, `retryWrites: true`, `retryReads: true` — reads now recover automatically across a replica-set failover/election.
+- **New `MongoDBOps.clientOptions`** hook to override/extend the driver options process-wide.
+- `closeDBConn()` now drains the client `Map` (and any legacy cache).
+
+### 0.11.0
+- Added estimated collection count (`getCollectionCount`).
+
+### Earlier
+- `search`, collation, and aggregate options. See the git history for details.
+
+## License
+
+ISC

package/test/mongodb-ops.test.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const mongodb = require('mongodb');
+
+const originalConnect = mongodb.MongoClient.connect;
+
+function freshMongoDBOps(connectImpl) {
+  delete require.cache[require.resolve('../lib/mongodb-ops')];
+  mongodb.MongoClient.connect = connectImpl;
+
+  const MongoDBOps = require('../lib/mongodb-ops');
+  MongoDBOps.dbClients = undefined;
+  MongoDBOps.dbClientList = undefined;
+  MongoDBOps.clientOptions = undefined;
+
+  return MongoDBOps;
+}
+
+function createClient(name) {
+  const closeCalls = [];
+  return {
+    name,
+    closeCalls,
+    db() { return {}; },
+    async close() { closeCalls.push(name); }
+  };
+}
+
+test.afterEach(() => {
+  mongodb.MongoClient.connect = originalConnect;
+  delete require.cache[require.resolve('../lib/mongodb-ops')];
+});
+
+test('reuses one client for repeated calls with the same connection string', async () => {
+  const calls = [];
+  const client = createClient('same');
+  const MongoDBOps = freshMongoDBOps(async (connString, options) => {
+    calls.push({ connString, options });
+    return client;
+  });
+
+  const first = await MongoDBOps.getDbClient('mongodb://example-a');
+  const second = await MongoDBOps.getDbClient('mongodb://example-a');
+
+  assert.equal(first, client);
+  assert.equal(second, client);
+  assert.equal(first, second);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].options.serverSelectionTimeoutMS, 8000);
+  assert.equal(calls[0].options.retryWrites, true);
+  assert.equal(calls[0].options.retryReads, true);
+});
+
+test('uses separate clients for different connection strings', async () => {
+  const calls = [];
+  const MongoDBOps = freshMongoDBOps(async (connString, options) => {
+    calls.push({ connString, options });
+    return createClient(connString);
+  });
+
+  const first = await MongoDBOps.getDbClient('mongodb://example-a');
+  const second = await MongoDBOps.getDbClient('mongodb://example-b');
+
+  assert.notEqual(first, second);
+  assert.deepEqual(calls.map((call) => call.connString), ['mongodb://example-a', 'mongodb://example-b']);
+});
+
+test('dedupes concurrent cold-start connection attempts', async () => {
+  const calls = [];
+  const client = createClient('concurrent');
+  let releaseConnect;
+  const connectStarted = new Promise((resolve) => {
+    releaseConnect = resolve;
+  });
+  const MongoDBOps = freshMongoDBOps(async (connString, options) => {
+    calls.push({ connString, options });
+    await connectStarted;
+    return client;
+  });
+
+  const pending = Array.from({ length: 5 }, () => MongoDBOps.getDbClient('mongodb://example-a'));
+  assert.equal(calls.length, 1);
+
+  releaseConnect();
+  const clients = await Promise.all(pending);
+
+  assert.equal(calls.length, 1);
+  assert.equal(new Set(clients).size, 1);
+  assert.equal(clients[0], client);
+});
+
+test('evicts failed connection promises so a later call reconnects', async () => {
+  let attempts = 0;
+  const client = createClient('retry');
+  const MongoDBOps = freshMongoDBOps(async () => {
+    attempts += 1;
+    if (attempts === 1) { throw new Error('connect failed'); }
+    return client;
+  });
+
+  await assert.rejects(MongoDBOps.getDbClient('mongodb://example-a'), /connect failed/);
+  const recovered = await MongoDBOps.getDbClient('mongodb://example-a');
+
+  assert.equal(recovered, client);
+  assert.equal(attempts, 2);
+});
+
+test('closeDBConn closes cached clients, clears the map, and reconnects next time', async () => {
+  const calls = [];
+  const clients = [];
+  const MongoDBOps = freshMongoDBOps(async (connString, options) => {
+    calls.push({ connString, options });
+    const client = createClient(connString);
+    clients.push(client);
+    return client;
+  });
+
+  await MongoDBOps.getDbClient('mongodb://example-a');
+  await MongoDBOps.getDbClient('mongodb://example-b');
+  await MongoDBOps.closeDBConn();
+
+  assert.equal(clients[0].closeCalls.length, 1);
+  assert.equal(clients[1].closeCalls.length, 1);
+  assert.equal(MongoDBOps.dbClients.size, 0);
+
+  await MongoDBOps.getDbClient('mongodb://example-a');
+  assert.equal(calls.length, 3);
+});
+
+test('closeDBConn also drains legacy dbClientList clients', async () => {
+  const MongoDBOps = freshMongoDBOps(async () => createClient('unused'));
+  const legacyClient = createClient('legacy');
+  MongoDBOps.dbClientList = [legacyClient];
+
+  await MongoDBOps.closeDBConn();
+
+  assert.equal(legacyClient.closeCalls.length, 1);
+  assert.deepEqual(MongoDBOps.dbClientList, []);
+});
+
+test('passes safe MongoDB driver options and permits consumer overrides', async () => {
+  const calls = [];
+  const client = createClient('options');
+  const MongoDBOps = freshMongoDBOps(async (connString, options) => {
+    calls.push({ connString, options });
+    return client;
+  });
+  MongoDBOps.clientOptions = { serverSelectionTimeoutMS: 5000, maxPoolSize: 10 };
+
+  await MongoDBOps.getDbClient('mongodb://example-a');
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].options.serverSelectionTimeoutMS, 5000);
+  assert.equal(calls[0].options.retryWrites, true);
+  assert.equal(calls[0].options.retryReads, true);
+  assert.equal(calls[0].options.maxPoolSize, 10);
+});
+