mongodb-ops 0.4.2 → 0.8.0

package/lib/mongodb-ops.js

@@ -33,35 +33,40 @@ class MongoDBOps {
   getObjectId(id) { return new ObjectID(id); }
 
   /**
-   * Static method - Open database connection
+   * 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
    * @param {number} [poolSize] Database client pool size
-   * @returns {promise}
+   * @returns {promise} Promise with db client
    */
-  static async openDBConn(connString, poolSize = DEFAULT_POOLSIZE) {
-    // dbClient will be at static level for reusability
-    //
-    if (MongoDBOps.dbClient && MongoDBOps.dbClient.topology.s.state === "connected") { return Promise.resolve(); }
+  static async getDbClient(connString, poolSize = DEFAULT_POOLSIZE) {
     if (!connString) { throw new Error("missing-connection-string"); }
 
-    MongoDBOps.dbClient = await MongoClient.connect(connString, { 
+    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, { 
+            poolSize: poolSize !== DEFAULT_POOLSIZE ? poolSize : MongoDBOps.poolSize || DEFAULT_POOLSIZE,
+            useNewUrlParser: true, 
+            useUnifiedTopology: true,
+          });
+        }
+
+        return Promise.resolve(item);
+      }
+    }
+
+    const newDbClient = await MongoClient.connect(connString, { 
       poolSize: poolSize !== DEFAULT_POOLSIZE ? poolSize : MongoDBOps.poolSize || DEFAULT_POOLSIZE,
       useNewUrlParser: true, 
       useUnifiedTopology: true,
     });
 
-    return Promise.resolve();
-  }
+    MongoDBOps.dbClientList.push(newDbClient);
 
-  /**
-   * Instance method - Open database connection
-   * 
-   * @param {number} [poolSize] Database client pool size
-   * @returns {promise}
-   */
-  async openDBConn(poolSize = DEFAULT_POOLSIZE) {
-    return Promise.resolve(await MongoDBOps.openDBConn(this.connString, poolSize));
+    return Promise.resolve(newDbClient);
   }
 
   /**
@@ -69,7 +74,11 @@ class MongoDBOps {
    * @returns {promise}
    */
   static async closeDBConn() {
-    if (MongoDBOps.dbClient) { await MongoDBOps.dbClient.close(); }
+    if (Array.isArray(MongoDBOps.dbClientList)) {
+      for (const item of MongoDBOps.dbClientList) {
+        await item.close();
+      }
+    }
     return Promise.resolve();
   }
 
@@ -78,8 +87,7 @@ class MongoDBOps {
    * @returns {promise}
    */
   async closeDBConn() {
-    if (MongoDBOps.dbClient) { await MongoDBOps.dbClient.close(); }
-    return Promise.resolve();
+    return Promise.resolve(await MongoDBOps.closeDBConn());
   }
 
   /**
@@ -97,10 +105,10 @@ class MongoDBOps {
    * @param {string} connString Database connection string
    * @returns {promise} Promise with object array
    */
-  static async getData(collectionName, queryExp, isAggregate = false, projection, sort, pagination, isGetCount = false, connString) {
-    if (!MongoDBOps.dbClient || (MongoDBOps.dbClient && MongoDBOps.dbClient.topology.s.state !== "connected")) { await MongoDBOps.openDBConn(connString); }   // reopen the db connection if it is not connected
-    let docs, db = MongoDBOps.dbClient.db();  // Create a new Db instance sharing the current socket connections
+  static async getData(collectionName, queryExp, isAggregate = false, projection, sort, pagination, isGetCount = false, connString) {   
+    const db = (await MongoDBOps.getDbClient(connString)).db();
 
+    let docs;
     if (isAggregate) { docs = await db.collection(collectionName).aggregate(queryExp).toArray(); }
     else {
       queryExp = queryExp || {};
@@ -162,11 +170,10 @@ class MongoDBOps {
    * @returns {promise}
    */
   static async writeData(type, collectionName, doc, filter, connString) {
-    if (!MongoDBOps.dbClient || (MongoDBOps.dbClient && MongoDBOps.dbClient.topology.s.state !== "connected")) { await MongoDBOps.openDBConn(connString); }   // reopen the db connection if it is not connected
-
     try {
-      let result, db = MongoDBOps.dbClient.db();  // Create a new Db instance sharing the current socket connections
+      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;
@@ -217,11 +224,10 @@ class MongoDBOps {
    * @returns {promise}
    */
   static async writeBulkData(type, collectionName, docs, ordered = false, connString) {
-    if (!MongoDBOps.dbClient || (MongoDBOps.dbClient && MongoDBOps.dbClient.topology.s.state !== "connected")) { await MongoDBOps.openDBConn(connString); }   // reopen the db connection if it is not connected
-
     try {
-      let result, db = MongoDBOps.dbClient.db();  // Create a new Db instance sharing the current socket connections
+      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] }}; }

package/lib/mongodb-tool-set.js

@@ -38,6 +38,54 @@ class MongoDBToolSet extends MongoDBOps {
    */
   async getDataByID(id, projection) { return Promise.resolve(await MongoDBToolSet.getDataByID(this.collectionName, id, projection, this.connString)); }
 
+  /**
+   * Static method - Get data by filter
+   * 
+   * @param {string} collectionName Collection name 
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
+   * @param {object} [projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
+   * @param {object} [sort] Sort filter {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort} 
+   * @param {object} [pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
+   * @param {string} connString Database connection string 
+   * @returns {promise} Promise with object array
+   */
+  static async getDataByFilter(collectionName, filter, projection, sort, pagination, connString) {
+    return Promise.resolve(await MongoDBOps.getData(collectionName, filter, false, projection, sort, pagination, undefined, connString));
+  }
+
+  /**
+   * Instance method - Get data by filter
+   * 
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
+   * @param {object} [projection] Projection {@link https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection}
+   * @param {object} [sort] Sort filter {@link https://docs.mongodb.com/manual/reference/method/cursor.sort/#cursor.sort} 
+   * @param {object} [pagination] Pagination `E.g., { startIndex: 11, endIndex: 20 }`
+   * @returns {promise} Promise with object array
+   */
+  async getDataByFilter(filter, projection, sort, pagination,) { return Promise.resolve(await MongoDBToolSet.getDataByFilter(this.collectionName, filter, projection, sort, pagination, this.connString)); }
+
+  /**
+   * Static method - Get data count by query
+   * 
+   * @param {string} collectionName Collection name
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter} 
+   * @param {string} connString Database connection string
+   * @returns {promise} Promise with data count
+   */
+  static async getDataCount(collectionName, filter, connString) {
+    return Promise.resolve(await MongoDBOps.getData(collectionName, filter, false, undefined, undefined, undefined, true, connString));
+  }
+
+  /**
+   * Instance method - Get data count by query
+   * 
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter} 
+   * @returns {promise} Promise with data count
+   */
+  async getDataCount(filter) {
+    return Promise.resolve(await MongoDBToolSet.getDataCount(this.collectionName, filter, this.connString));
+  }
+
   /**
    * Static method - Get all data
    * 
@@ -78,7 +126,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {object} doc Data document
    * @returns {promise}
    */
-  async insertOne(doc) { return Promise.resolve(await super.writeData("insertOne", this.collectionName, doc, this.connString)); }
+  async insertOne(doc) { return Promise.resolve(await MongoDBToolSet.insertOne(this.collectionName, doc, this.connString)); }
 
   /**
    * Static method - Insert multiple documents to database in ordered way
@@ -96,7 +144,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs Data document array
    * @returns {promise}
    */
-  async insertBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("insertBulk", this.collectionName, docs, true, this.connString)); }
+  async insertBulkOrdered(docs) { return Promise.resolve(await MongoDBToolSet.insertBulkOrdered(this.collectionName, docs, this.connString)); }
 
   /**
    * Static method - Insert multiple documents to database in unordered way
@@ -114,7 +162,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs Data document array
    * @returns {promise}
    */
-  async insertBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("insertBulk", this.collectionName, docs, false, this.connString)); }
+  async insertBulkUnOrdered(docs) { return Promise.resolve(await MongoDBToolSet.insertBulkUnOrdered(this.collectionName, docs, this.connString)); }
 
   /**
    * Static method - Replace one document to database
@@ -134,7 +182,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
    * @returns {promise}
    */
-  async replaceOne(doc, filter) { return Promise.resolve(await super.writeData("replaceOne", this.collectionName, doc, filter, this.connString)); }
+  async replaceOne(doc, filter) { return Promise.resolve(await MongoDBToolSet.replaceOne(this.collectionName, doc, filter, this.connString)); }
 
   /**
    * Static method - Replace multiple documents to database in ordered way
@@ -152,7 +200,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs ReplaceOne object array
    * @returns {promise}
    */
-  async replaceBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("replaceBulk", this.collectionName, docs, true, this.connString)); }
+  async replaceBulkOrdered(docs) { return Promise.resolve(await MongoDBToolSet.replaceBulkOrdered(this.collectionName, docs, this.connString)); }
 
   /**
    * Static method - Replace multiple documents to database in unordered way
@@ -170,7 +218,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs ReplaceOne object array
    * @returns {promise}
    */
-  async replaceBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("replaceBulk", this.collectionName, docs, false, this.connString)); }
+  async replaceBulkUnOrdered(docs) { return Promise.resolve(await MongoDBToolSet.replaceBulkUnOrdered(this.collectionName, docs, this.connString)); }
 
   /**
    * Static method - Update one document to database
@@ -190,7 +238,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter} 
    * @returns {promise}
    */
-  async updateOne(doc, filter) { return Promise.resolve(await super.writeData("updateOne", this.collectionName, doc, filter, this.connString)); }
+  async updateOne(doc, filter) { return Promise.resolve(await MongoDBToolSet.updateOne(this.collectionName, doc, filter, this.connString)); }
 
   /**
    * Static method - Update many documents to database
@@ -210,7 +258,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter} 
    * @returns {promise}
    */
-  async updateMany(doc, filter) { return Promise.resolve(await super.writeData("updateMany", this.collectionName, doc, filter, this.connString)); }
+  async updateMany(doc, filter) { return Promise.resolve(await MongoDBToolSet.updateMany(this.collectionName, doc, filter, this.connString)); }
 
   /**
    * Static method - Update multiple documents to database in ordered way
@@ -228,7 +276,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs UpdateOne object array 
    * @returns {promise}
    */
-  async updateBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("updateBulk", this.collectionName, docs, true, this.connString)); }
+  async updateBulkOrdered(docs) { return Promise.resolve(await MongoDBToolSet.updateBulkOrdered(this.collectionName, docs, this.connString)); }
   
   /**
    * Static method - Update multiple documents to database in unordered way
@@ -246,7 +294,79 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs UpdateOne object array
    * @returns {promise}
    */
-  async updateBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("updateBulk", this.collectionName, docs, false, this.connString)); }
+  async updateBulkUnOrdered(docs) { return Promise.resolve(await MongoDBToolSet.updateBulkUnOrdered(this.collectionName, docs, this.connString)); }
+
+  /**
+   * Static method - Delete one document at database
+   * 
+   * @param {string} collectionName Collection name
+   * @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 deleteOne(collectionName, filter, connString) { return Promise.resolve(await MongoDBOps.writeData("deleteOne", collectionName, undefined, filter, connString)); }
+
+  /**
+   * Instance method - Delete one document at database
+   * 
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
+   * @returns {promise}
+   */
+  async deleteOne(filter) { return Promise.resolve(await MongoDBToolSet.deleteOne(this.collectionName, filter, this.connString)); }
+
+  /**
+   * Static method - Delete many document at database
+   * 
+   * @param {string} collectionName Collection name
+   * @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 deleteMany(collectionName, filter, connString) { return Promise.resolve(await MongoDBOps.writeData("deleteMany", collectionName, undefined, filter, connString)); }
+
+  /**
+   * Instance method - Delete many document at database
+   * 
+   * @param {object} filter Query filter {@link https://docs.mongodb.com/manual/core/document/#document-query-filter}
+   * @returns {promise}
+   */
+  async deleteMany(filter) { return Promise.resolve(await MongoDBToolSet.deleteMany(this.collectionName, filter, this.connString)); }
+
+  /**
+   * Static method - Delete multiple documents to database in ordered way
+   * 
+   * @param {string} collectionName Collection name
+   * @param {Array} docs DeleteOne object array 
+   * @param {string} connString Database connection string 
+   * @returns {promise}
+   */
+  static async deleteBulkOrdered(collectionName, docs, connString) { return Promise.resolve(await MongoDBOps.writeBulkData("deleteBulk", collectionName, docs, true, connString)); }
+  
+   /**
+    * Instance method - Delete multiple documents to database in ordered way
+    * 
+    * @param {Array} docs DeleteOne object array 
+    * @returns {promise}
+    */
+  async deleteBulkOrdered(docs) { return Promise.resolve(await MongoDBToolSet.deleteBulkOrdered(this.collectionName, docs, this.connString)); }
+   
+   /**
+    * Static method - Delete multiple documents to database in unordered way
+    * 
+    * @param {string} collectionName Collection name
+    * @param {Array} docs DeleteOne object array
+    * @param {string} connString Database connection string
+    * @returns {promise}
+    */
+  static async deleteBulkUnOrdered(collectionName, docs, connString) { return Promise.resolve(await MongoDBOps.writeBulkData("deleteBulk", collectionName, docs, false, connString)); }
+   
+   /**
+    * Instance method - Delete multiple documents to database in unordered way
+    * 
+    * @param {Array} docs DeleteOne object array
+    * @returns {promise}
+    */
+  async deleteBulkUnOrdered(docs) { return Promise.resolve(await MongoDBToolSet.deleteBulkUnOrdered(this.collectionName, docs, this.connString)); }
 
   /**
    * Static method - BulkWrite operations to database in ordered way
@@ -264,7 +384,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs BulkWrite object array
    * @returns {promise}
    */
-  async allBulkOrdered(docs) { return Promise.resolve(await super.writeBulkData("allBulk", this.collectionName, docs, true, this.connString)); }
+  async allBulkOrdered(docs) { return Promise.resolve(await MongoDBToolSet.allBulkOrdered(this.collectionName, docs, this.connString)); }
   
   /**
    * Static method - BulkWrite operations to database in unordered way
@@ -282,7 +402,7 @@ class MongoDBToolSet extends MongoDBOps {
    * @param {Array} docs BulkWrite object array
    * @returns {promise}
    */
-  async allBulkUnOrdered(docs) { return Promise.resolve(await super.writeBulkData("allBulk", this.collectionName, docs, false, this.connString)); }
+  async allBulkUnOrdered(docs) { return Promise.resolve(await MongoDBToolSet.allBulkUnOrdered(this.collectionName, docs, this.connString)); }
 }
 
 module.exports = MongoDBToolSet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-ops",
-  "version": "0.4.2",
+  "version": "0.8.0",
   "description": "Read and write ops for MongoDB",
   "main": "index.js",
   "scripts": {