mongoplusplus 1.0.2 → 1.0.4

package/mongoplus.js

@@ -5,18 +5,18 @@ class Mongoplus {
         this.mongoURI = mongoURI;
         this.allConnections = [];
         this.currentIndex = 0;
-        if(this.mongoURI.filter((uri)=>uri.startsWith("readonly")).length==this.mongoURI.length){
+        if (this.mongoURI.filter((uri) => uri.startsWith("readonly")).length == this.mongoURI.length) {
             throw new Error('Some of your URIs must be writable. If it is a mistake remove the `readonly:` flag from your urls')
         }
-        
+
     }
-    static readonlydbs=[]
-    static readonlymodels=[] // Define currentIndex to keep track of the current URI
+    static readonlydbs = []
+    static readonlymodels = [] // Define currentIndex to keep track of the current URI
     Schema(schema) {
         return mongoose.Schema(schema)
     }
-    addIndex(schema,indextype){
-return schema.index(indextype)
+    addIndex(schema, indextype) {
+        return schema.index(indextype)
     }
     getNextMongoURI() {
         const uri = this.mongoURI[this.currentIndex];
@@ -26,16 +26,16 @@ return schema.index(indextype)
 
     connectToAll() {
         for (let i = 0; i < this.mongoURI.length; i++) {
-          
-            const uri = this.mongoURI[i].replaceAll("readonly:",'');
+
+            const uri = this.mongoURI[i].replaceAll("readonly:", '');
             const con = mongoose.createConnection(uri, {
                 useNewUrlParser: true,
                 useUnifiedTopology: true,
             });
 
             this.allConnections.push(con);
-            if(this.mongoURI[i].startsWith('readonly:')){
-              
+            if (this.mongoURI[i].startsWith('readonly:')) {
+
                 Mongoplus.readonlydbs.push(con)
             }
         }
@@ -50,7 +50,7 @@ return schema.index(indextype)
             required: true
           } `)
         }
-        if(this.allConnections.length<=0){
+        if (this.allConnections.length <= 0) {
             throw new Error(`[!]Error :  All connections should be made first use the code 
             (async () => {await mongodb.connectToAll();})(); to init connections here mongodb is the class init variable`)
         }
@@ -59,28 +59,28 @@ return schema.index(indextype)
         //console.groupCollapsed("====>",Mongoplus.readonlydbs);
         for (let i = 0; i < allConnections.length; i++) {
             const mongooseConnection = allConnections[i];
-            var currentm=mongooseConnection.model(name, schema)
+            var currentm = mongooseConnection.model(name, schema)
             model.push(currentm);
             //console.count(Mongoplus.readonlydbs[i]);
-            if(Mongoplus.readonlydbs.includes(allConnections[i])){
-                
+            if (Mongoplus.readonlydbs.includes(allConnections[i])) {
+
                 Mongoplus.readonlymodels.push(currentm)
             }
         }
-        console.log("REadonly ",Mongoplus.readonlymodels)
-        return new MongoModel(model,schema,Mongoplus.readonlymodels);
+        console.log("REadonly ", Mongoplus.readonlymodels)
+        return new MongoModel(model, schema, Mongoplus.readonlymodels);
     }
 }
 
 class MongoModel {
-    constructor(model,s,readonlydbs) {
+    constructor(model, s, readonlydbs) {
         if (!Array.isArray(model)) {
             throw new Error('Model should be an array');
         }
         this.model = model;
-        this.readonlydbs=readonlydbs
-        this.s=s
-     
+        this.readonlydbs = readonlydbs
+        this.s = s
+
 
     }
     static currentIndex = 0
@@ -104,24 +104,24 @@ class MongoModel {
     async writeInAllDatabase(data) {
         data["dbIndex"] = -1
         const dynamicComputationPromises = [];
-        modellist=this.model
+        modellist = this.model
         //this.readonlydbs.forEach((i)=>{modellist.splice(i,1,null)})
-        
+
         for (let i = 0; i < this.model.length; i++) {
-          if(Mongoplus.readonlymodels.includes(this.model[i])) continue;
-                var x=new this.model[i](data)
-                
-                dynamicComputationPromises.push(await x.save());
-         
-            
+            if (Mongoplus.readonlymodels.includes(this.model[i])) continue;
+            var x = new this.model[i](data)
+
+            dynamicComputationPromises.push(await x.save());
+
+
         }
-      
+
         return [].concat(dynamicComputationPromises);
 
     }
     //==================
     async UpdateOneInAllDatabase(filter, update) {
-       
+
         const dynamicComputationPromises = [];
         this.model.forEach((modelRef) => {
 
@@ -132,7 +132,7 @@ class MongoModel {
     }
     //==================
     async UpdateByIdInAllDatabase(id, update) {
-       
+
         const dynamicComputationPromises = [];
         this.model.forEach((modelRef) => {
 
@@ -142,7 +142,7 @@ class MongoModel {
 
     }
     async findByIdInAllDatabaseAndDelete(id) {
-       
+
         const dynamicComputationPromises = [];
         this.model.forEach((modelRef) => {
 
@@ -152,7 +152,7 @@ class MongoModel {
 
     }
     async findOneInAllDatabaseAndDelete(filter) {
-       
+
         const dynamicComputationPromises = [];
         this.model.forEach((modelRef) => {
 
@@ -163,18 +163,18 @@ class MongoModel {
     }
     //=======================
     async write(data) {
-       
-   
-            const currentModel = this.model[MongoModel.currentIndex];
-            data["dbIndex"] = MongoModel.currentIndex;
-            MongoModel.currentIndex = (MongoModel.currentIndex + 1) % this.model.length;
-    if(Mongoplus.readonlymodels.includes(currentModel)){
-        this.write(data)
-        //("This model is readonly");
-      
-    }
-   
-     
+
+
+        const currentModel = this.model[MongoModel.currentIndex];
+        data["dbIndex"] = MongoModel.currentIndex;
+        MongoModel.currentIndex = (MongoModel.currentIndex + 1) % this.model.length;
+        if (Mongoplus.readonlymodels.includes(currentModel)) {
+            this.write(data)
+            //("This model is readonly");
+
+        }
+
+
         try {
 
             let dataToWrite = new currentModel(data)
@@ -188,7 +188,7 @@ class MongoModel {
 
     async findOne(dbIndex, filter, chain = {}) {
         var currentModel = this.model[dbIndex]
-       
+
         if (chain.skip && chain.limit && chain.sort) {
             currentModel.findOne(filter).skip(chain.skip).limit(chain.limit).sort(chain.sort)
         } else if (chain.skip && chain.limit) {
@@ -211,67 +211,39 @@ class MongoModel {
 
     async find(dbIndex, filter, chain = {}) {
         var currentModel = this.model[dbIndex]
-       
-        if (chain.skip && chain.limit && chain.sort) {
-            currentModel.find(filter).skip(chain.skip).limit(chain.limit).sort(chain.sort)
-        } else if (chain.skip && chain.limit) {
-            return currentModel.find(filter).skip(chain.skip).limit(chain.limit)
-        }
-        else if (chain.skip) {
-            return currentModel.find(filter).skip(chain.skip)
-        }
+        // Start with the base query
+        let query = currentModel.find(filter);
 
-        else if (chain.limit) {
-            return currentModel.find(filter).limit(chain.limit)
-        } else {
-            return currentModel.find(filter);
+        // Dynamically apply chain options if they exist
+        for (const [key, value] of Object.entries(chain)) {
+            if (query[key]) {
+                query = query[key](value);
+            }
         }
 
+        return query;
+
+
 
     }
     //=======================
     async findById(dbIndex, filter, chain = {}) {
-        var currentModel = this.model[dbIndex]
-       
-        if (chain.skip && chain.limit && chain.sort) {
-            currentModel.findById(filter).skip(chain.skip).limit(chain.limit).sort(chain.sort)
-        } else if (chain.skip && chain.limit) {
-            return currentModel.findById(filter).skip(chain.skip).limit(chain.limit)
-        }
-        else if (chain.skip) {
-            return currentModel.findById(filter).skip(chain.skip)
-        }
-
-        else if (chain.limit) {
-            return currentModel.findById(filter).limit(chain.limit)
-        } else {
-            return currentModel.findById(filter);
-        }
+        const currentModel = this.model[dbIndex];
 
+        // Start with the base query
+        let query = currentModel.findById(filter);
 
-    }
-
-    //==========================
-    async findById(dbIndex, filter, chain = {}) {
-        var currentModel = this.model[dbIndex]
-        
-        if (chain.skip && chain.limit && chain.sort) {
-            currentModel.findById(filter).skip(chain.skip).limit(chain.limit).sort(chain.sort)
-        } else if (chain.skip && chain.limit) {
-            return currentModel.findById(filter).skip(chain.skip).limit(chain.limit)
-        }
-        else if (chain.skip) {
-            return currentModel.findById(filter).skip(chain.skip)
+        // Dynamically apply chain options if they exist
+        for (const [key, value] of Object.entries(chain)) {
+            if (query[key]) {
+                query = query[key](value);
+            }
         }
 
-        else if (chain.limit) {
-            return currentModel.findById(filter).limit(chain.limit)
-        } else {
-            return currentModel.findById(filter);
-        }
+        return query;
+    }
 
 
-    }
     //====================
     async findByIdAndUpdate(dbIndex, id, update) {
         var currentModel = this.model[dbIndex]
@@ -296,7 +268,7 @@ class MongoModel {
     async watch(dbIndex) {
         return this.model[dbIndex].watch()
     }
-//================
+    //================
 
 
 
@@ -316,25 +288,19 @@ class MongoModel {
             const results = await Promise.all(
                 computationPairs.map(async pair => {
                     var chain = pair.chain;
-                    if (chain.skip && chain.limit && chain.sort) {
-                        pair.fn(...pair.params).skip(chain.skip).limit(chain.limit).sort(chain.sort)
-                    } else if (chain.skip && chain.limit) {
-                        return pair.fn(...pair.params).skip(chain.skip).limit(chain.limit)
+                    var query = pair.fn(...pair.params);
+                    // Start with the base query
+
+                    // Dynamically apply chain options if they exist
+                    for (const [key, value] of Object.entries(chain)) {
+                        if (query[key]) {
+                            query = query[key](value);
+                        }
                     }
-                    else if (chain.skip) {
-                        return pair.fn(...pair.params).skip(chain.skip)
-                    }
-
-                    else if (chain.limit) {
-                        return pair.fn(...pair.params).limit(chain.limit)
-                    } else {
-                        return pair.fn(...pair.params);
-                    }
-                })
-
-
 
+                    return query;
 
+                })
             );
 
             const endTime = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongoplusplus",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "load balancing of read and write operations across multiple MongoDB servers ",
   "main": "mongoplus.js",
   "scripts": {