mongoplusplus 1.0.0

package/README.md

@@ -0,0 +1,170 @@
+# Mongoplus
+
+## Overview
+
+`mongoplus` is a Node.js package designed to facilitate load balancing of read and write operations across multiple MongoDB databases. It simplifies database connection management, schema definition, model building, and CRUD operations execution.
+
+## Installation
+
+Install Mongoplus via npm:
+
+```bash
+npm install mongoplus
+```
+
+importing
+```node
+const mongoplus = require('mongoplus');
+```
+##Initialing
+```node
+const dbname = 'testforUP';
+
+const mongoURI1 = `mongodb+srv://xxxxx:xxxxxx@cluster0.xxxxx.mongodb.net/${dbname}?retryWrites=true&w=majority`;
+const mongoURI2 = `readonly:mongodb+srv://xxxxxxx:xxxxxx@cluster0.xxxxxx.mongodb.net/${dbname}?retryWrites=true&w=majority`;
+const mongodb = new mongoplus([mongoURI1, mongoURI2]);
+
+```
+##connecting database
+this is the top level thing in your main page (in this test code, under mongodb variable declaration  )
+```node
+(async () => {
+  await mongodb.connectToAll();
+})();
+```
+##Schema defining 
+it is very  similar to Mongoose schema definition.but only one mandatory field must be there in the schema which will act as a db identifier for that document
+```node
+const likeSH = mongodb.Schema({
+  user_id: { type: mongoose.Schema.Types.ObjectId, required: true, ref: "users" },
+  postId: { type: mongoose.Schema.Types.ObjectId, required: true  },
+  dbIndex: { type: Number, required: true },
+
+  like_time: { type: Date, default: Date.now }
+}
+)
+```
+### model building
+```node
+const likes = mongodb.buildModel("likes", likeSH)
+```
+
+
+##### Note that `dbIndex` is used to indicate which MongoDB server it belongs to.
+###### it is a must otherwise it will throw an error.
+```node
+     throw new Error(`[!]Error :  < dbIndex > must be present in your schema like dbIndex:{
+            type: Number,
+            required: true
+          } `)
+```
+
+
+### usage methods
+```node 
+findInAllDatabase(filter, chain = {})
+```
+Usage: Finds documents matching the filter in all MongoDB databases.
+
+```node 
+const result = await likes.findInAllDatabase({ name: 'John' }, { limit: 10, skip: 0 });
+Returns: An array of documents matching the filter from all databases.
+```
+```node
+writeInAllDatabase(data)
+
+Usage: Writes data to all MongoDB databases.
+
+const result = await likes.writeInAllDatabase({ name: 'John', age: 30 });
+Returns: An array of written documents from all databases.
+```
+```node
+UpdateOneInAllDatabase(filter, update)
+Usage: Updates a single document matching the filter in all MongoDB databases.
+const updatedDocument = await likes.UpdateOneInAllDatabase({ name: 'John' }, { age: 35 });
+Returns: The updated document.
+```
+```node 
+UpdateByIdInAllDatabase(id, update)
+Usage: Updates a document by ID in all MongoDB databases.
+const updatedDocument = await likes.UpdateByIdInAllDatabase('123456', { age: 35 });
+Returns: The updated document.
+```
+```node 
+findByIdInAllDatabaseAndDelete(id)
+Usage: Finds a document by ID in all MongoDB databases and deletes it.
+const deletedDocument = await likes.findByIdInAllDatabaseAndDelete('123456');
+Returns: The deleted document.
+```
+
+```node 
+findOneInAllDatabaseAndDelete(filter)
+Usage: Finds a single document matching the filter in all MongoDB databases and deletes it.
+const deletedDocument = await likes.findOneInAllDatabaseAndDelete({ name: 'John' });
+Returns: The deleted document.
+```
+```node 
+write(data)
+Usage: Writes data to a MongoDB database.
+const result = await likes.write({ name: 'John', age: 30 });
+Returns: The written document.
+```
+
+```node 
+findOne(dbIndex, filter, chain = {})
+Usage: Finds a single document matching the filter in a specific MongoDB database.
+const document = await likes.findOne(0, { name: 'John' }, { limit: 1 });
+Returns: The found document.
+```
+```node
+find(dbIndex, filter, chain = {})
+Usage: Finds documents matching the filter in a specific MongoDB database.
+const documents = await likes.find(0, { age: { $gt: 18 } }, { limit: 10 });
+Returns: An array of found documents.
+```
+
+```node 
+findById(dbIndex, id, chain = {})
+Usage: Finds a document by ID in a specific MongoDB database.
+const document = await likes.findById(0, '123456');
+Returns: The found document.
+```
+```node
+findByIdAndUpdate(dbIndex, id, update)
+Usage: Finds a document by ID in a specific MongoDB database and updates it.
+const updatedDocument = await likes.findByIdAndUpdate(0, '123456', { age: 35 });
+Returns: The updated document.
+```
+```node
+findByIdAndDelete(dbIndex, id)
+Usage: Finds a document by ID in a specific MongoDB database and deletes it.
+const deletedDocument = await likes.findByIdAndDelete(0, '123456');
+Returns: The deleted document.
+```
+```node
+findOneAndUpdate(dbIndex, filter, update)
+Usage: Finds a single document matching the filter in a specific MongoDB database and updates it.
+
+const updatedDocument = await likes.findOneAndUpdate(0, { name: 'John' }, { age: 35 });
+Returns: The updated document.
+```
+```node
+aggregate(dbIndex, filter)
+Usage: Aggregates documents in a specific MongoDB database based on the filter.
+const aggregationResult = await likes.aggregate(0, [{ $group: { _id: '$name', total: { $sum: '$age' } } }]);
+Returns: The aggregation result.
+```
+```node
+watch(dbIndex)
+Usage: Starts watching for changes in a specific MongoDB database.
+const watcher = await likes.watch(0);
+Returns: A watcher object for the database.
+```
+
+> now most of the functionality is as same as mongoose  so you can use them directly like indexing a schema 
+```node
+likeSH.index({ user_id: 1, postId: 1 }, { unique: true });
+```
+# Contributing
+there are many things that are not ported. feel free to contribute!
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change. Please make sure to update.and also 

package/mongoplus.js

@@ -0,0 +1,354 @@
+const mongoose = require('mongoose');
+class Mongoplus {
+    constructor(mongoURI) {
+
+        this.mongoURI = mongoURI;
+        this.allConnections = [];
+        this.currentIndex = 0;
+        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
+    Schema(schema) {
+        return mongoose.Schema(schema)
+    }
+    addIndex(schema,indextype){
+return schema.index(indextype)
+    }
+    getNextMongoURI() {
+        const uri = this.mongoURI[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % this.mongoURI.length;
+        return uri;
+    }
+
+    connectToAll() {
+        for (let i = 0; i < this.mongoURI.length; i++) {
+          
+            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:')){
+              
+                Mongoplus.readonlydbs.push(con)
+            }
+        }
+
+        return this.allConnections;
+    }
+
+    buildModel(name, schema) {
+        if (!Object.keys(schema.obj).includes("dbIndex")) {
+            throw new Error(`[!]Error :  < dbIndex > must be present in your schema like dbIndex:{
+            type: Number,
+            required: true
+          } `)
+        }
+        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`)
+        }
+        const allConnections = this.allConnections;
+        const model = [];
+        //console.groupCollapsed("====>",Mongoplus.readonlydbs);
+        for (let i = 0; i < allConnections.length; i++) {
+            const mongooseConnection = allConnections[i];
+            var currentm=mongooseConnection.model(name, schema)
+            model.push(currentm);
+            //console.count(Mongoplus.readonlydbs[i]);
+            if(Mongoplus.readonlydbs.includes(allConnections[i])){
+                
+                Mongoplus.readonlymodels.push(currentm)
+            }
+        }
+        console.log("REadonly ",Mongoplus.readonlymodels)
+        return new MongoModel(model,schema,Mongoplus.readonlymodels);
+    }
+}
+
+class MongoModel {
+    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
+     
+
+    }
+    static currentIndex = 0
+    //===================
+
+    async findInAllDatabase(filter, chain = {}) {
+        const dynamicComputationPromises = [];
+        this.model.forEach((modelRef) => {
+            dynamicComputationPromises.push({ fn: modelRef.find.bind(modelRef), params: [filter], chain: chain });
+        });
+        return await this.runLargeComputations(dynamicComputationPromises);
+    }
+    async aggregateInAllDatabase(filter, chain = {}) {
+        const dynamicComputationPromises = [];
+        this.model.forEach((modelRef) => {
+            dynamicComputationPromises.push({ fn: modelRef.aggregate.bind(modelRef), params: [filter], chain: chain });
+        });
+        return await this.runLargeComputations(dynamicComputationPromises);
+    }
+    //==================
+    async writeInAllDatabase(data) {
+        data["dbIndex"] = -1
+        const dynamicComputationPromises = [];
+        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());
+         
+            
+        }
+      
+        return [].concat(dynamicComputationPromises);
+
+    }
+    //==================
+    async UpdateOneInAllDatabase(filter, update) {
+       
+        const dynamicComputationPromises = [];
+        this.model.forEach((modelRef) => {
+
+            dynamicComputationPromises.push({ fn: modelRef.findOneAndUpdate.bind(modelRef), params: [filter, update, { new: true }], chain: {} });
+        });
+        return await this.runLargeComputations(dynamicComputationPromises);
+
+    }
+    //==================
+    async UpdateByIdInAllDatabase(id, update) {
+       
+        const dynamicComputationPromises = [];
+        this.model.forEach((modelRef) => {
+
+            dynamicComputationPromises.push({ fn: modelRef.findByIdAndUpdate.bind(modelRef), params: [id, update, { new: true }], chain: {} });
+        });
+        return await this.runLargeComputations(dynamicComputationPromises);
+
+    }
+    async findByIdInAllDatabaseAndDelete(id) {
+       
+        const dynamicComputationPromises = [];
+        this.model.forEach((modelRef) => {
+
+            dynamicComputationPromises.push({ fn: modelRef.findByIdAndDelete.bind(modelRef), params: [id], chain: {} });
+        });
+        return await this.runLargeComputations(dynamicComputationPromises);
+
+    }
+    async findOneInAllDatabaseAndDelete(filter) {
+       
+        const dynamicComputationPromises = [];
+        this.model.forEach((modelRef) => {
+
+            dynamicComputationPromises.push({ fn: modelRef.findOneAndDelete.bind(modelRef), params: [filter], chain: {} });
+        });
+        return await this.runLargeComputations(dynamicComputationPromises);
+
+    }
+    //=======================
+    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");
+      
+    }
+   
+     
+        try {
+
+            let dataToWrite = new currentModel(data)
+            return await dataToWrite.save()
+        } catch (error) {
+            throw error
+        }
+
+    }
+    //==================
+
+    async findOne(dbIndex, filter, chain = {}) {
+        var currentModel = this.model[dbIndex]
+        var chain = pair.chain;
+        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) {
+            return currentModel.findOne(filter).skip(chain.skip).limit(chain.limit)
+        }
+        else if (chain.skip) {
+            return currentModel.findOne(filter).skip(chain.skip)
+        }
+
+        else if (chain.limit) {
+            return currentModel.findOne(filter).limit(chain.limit)
+        } else {
+            return currentModel.findOne(filter);
+        }
+
+
+    }
+
+    //===============
+
+    async find(dbIndex, filter, chain = {}) {
+        var currentModel = this.model[dbIndex]
+        var chain = pair.chain;
+        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)
+        }
+
+        else if (chain.limit) {
+            return currentModel.find(filter).limit(chain.limit)
+        } else {
+            return currentModel.find(filter);
+        }
+
+
+    }
+    //=======================
+    async findById(dbIndex, filter, chain = {}) {
+        var currentModel = this.model[dbIndex]
+        var chain = pair.chain;
+        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);
+        }
+
+
+    }
+
+    //==========================
+    async findById(dbIndex, filter, chain = {}) {
+        var currentModel = this.model[dbIndex]
+        var chain = pair.chain;
+        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);
+        }
+
+
+    }
+    //====================
+    async findByIdAndUpdate(dbIndex, id, update) {
+        var currentModel = this.model[dbIndex]
+        return currentModel.findByIdAndUpdate(id, update, { new: true });
+    }
+    //===============
+    async findByIdAndDelete(dbIndex, id, update) {
+        var currentModel = this.model[dbIndex]
+        return currentModel.findByIdAndRemove(id, update, { new: true });
+    }
+    //===========
+    async findOneAndUpdate(dbIndex, filter, update) {
+        var currentModel = this.model[dbIndex]
+        return currentModel.findOneAndUpdate(filter, update, { new: true });
+    }
+    //=============
+    async aggregate(dbIndex, filter, update) {
+        var currentModel = this.model[dbIndex]
+        return currentModel.aggregate(filter);
+    }
+    //===========
+    async watch(dbIndex) {
+        return this.model[dbIndex].watch()
+    }
+//================
+
+
+
+
+
+    getNextModel() {
+        const currentModel = this.model[this.currentIndex];
+        var writen = this.currentIndex
+        this.currentIndex = (this.currentIndex + 1) % this.model.length;
+        return [currentModel, writen];
+    }
+    async runLargeComputations(computationPairs) {
+        try {
+            const startTime = performance.now();
+
+            // Execute all computation functions concurrently using Promise.all
+            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)
+                    }
+                    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);
+                    }
+                })
+
+
+
+
+            );
+
+            const endTime = performance.now();
+            const totalTime = endTime - startTime;
+
+            // Process the results as needed
+            // const sum = results.reduce((acc, result) => acc + result, 0);
+
+            return { results: [].concat(...results), totalTime };
+        } catch (error) {
+            console.error('Error:', error);
+            throw error; // Rethrow the error if needed
+        }
+    }
+}
+
+module.exports = Mongoplus;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "mongoplusplus",
+  "version": "1.0.0",
+  "description": "A mongoose extanded  library for building complex data models.in a multi tanannt architecture ",
+  "main": "mongoplus.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "somen das(somen6562@gmail.com)",
+  "license": "ISC",
+  "dependencies": {
+    "mongoose": "^6.3.5",
+    "mongoose-sequence": "^5.3.1"
+  }
+}