@justair/justair-library 4.4.0 → 4.4.2-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "4.4.0",
+  "version": "4.4.2-alpha",
   "description": "JustAir Internal Library",
   "main": "src/index.js", 
   "type": "module",

package/src/config/db.js

@@ -1,39 +1,115 @@
 import mongoose from "mongoose";
 
 class Database {
-  static instance = null;
+  static instances = new Map(); // Store multiple instances by connection key
+
   constructor({ CONNECTION_URL, database }) {
     this.CONNECTION_URL = CONNECTION_URL;
     this.database = database;
+    this.connectionKey = `${CONNECTION_URL}:${database}`;
+    this.isConnected = false;
   }
 
   async connect() {
-    if (mongoose.connection.readyState === 1) {
-      await mongoose.disconnect();
+    // Check if we're already connected to this specific database
+    if (this.isConnected && mongoose.connection.readyState === 1) {
+      // Verify we're connected to the right database
+      if (mongoose.connection.db.databaseName === this.database) {
+        console.log(`Already connected to database: ${this.database}`);
+        return;
+      }
     }
+
     try {
+      // Only disconnect if we're connected to a different database
+      if (mongoose.connection.readyState === 1) {
+        const currentDb = mongoose.connection.db.databaseName;
+        if (currentDb !== this.database) {
+          console.log(
+            `Switching from database: ${currentDb} to: ${this.database}`
+          );
+          await mongoose.disconnect();
+        } else {
+          // Already connected to the correct database
+          this.isConnected = true;
+          return;
+        }
+      }
+
       await mongoose.connect(this.CONNECTION_URL, {
         authSource: "admin",
         ssl: true,
         dbName: this.database,
       });
-      console.log("Database connection successful");
+
+      this.isConnected = true;
+      console.log(`Database connection successful: ${this.database}`);
+    } catch (err) {
+      this.isConnected = false;
+      console.error(`Database connection error for ${this.database}: ${err}`);
+      throw err;
+    }
+  }
+
+  async disconnect() {
+    try {
+      if (mongoose.connection.readyState === 1) {
+        await mongoose.disconnect();
+        this.isConnected = false;
+        console.log(`Disconnected from database: ${this.database}`);
+      }
     } catch (err) {
-      console.error("Database connection error " + err);
+      console.error(`Error disconnecting from database: ${err}`);
       throw err;
     }
   }
 
   static async getInstance(config) {
-    if (
-      !Database.instance ||
-      Database.instance.CONNECTION_URL !== config.CONNECTION_URL ||
-      Database.instance.database !== config.database
-    ) {
-      Database.instance = new Database(config);
-      await Database.instance.connect();
+    const connectionKey = `${config.CONNECTION_URL}:${config.database}`;
+
+    // Check if we have an instance for this connection
+    if (Database.instances.has(connectionKey)) {
+      const instance = Database.instances.get(connectionKey);
+
+      // Ensure the connection is still valid
+      if (!instance.isConnected || mongoose.connection.readyState !== 1) {
+        await instance.connect();
+      }
+
+      return instance;
+    }
+
+    // Create new instance
+    const instance = new Database(config);
+    await instance.connect();
+    Database.instances.set(connectionKey, instance);
+
+    return instance;
+  }
+
+  static getCurrentDatabase() {
+    if (mongoose.connection.readyState === 1) {
+      return mongoose.connection.db.databaseName;
+    }
+    return null;
+  }
+
+  static async closeAllConnections() {
+    try {
+      if (mongoose.connection.readyState === 1) {
+        await mongoose.disconnect();
+      }
+
+      // Mark all instances as disconnected
+      for (const instance of Database.instances.values()) {
+        instance.isConnected = false;
+      }
+
+      console.log("All database connections closed");
+    } catch (err) {
+      console.error("Error closing database connections:", err);
+      throw err;
     }
-    return Database.instance;
   }
 }
 

package/src/models/dataCompleteness.js

@@ -2,8 +2,8 @@ import mongoose from "mongoose";
 
 const dataCompletenessSchema = mongoose.Schema(
   {
-    monitorId: { type: ObjectId, ref: "Monitors" },
-    supplierId: { type: ObjectId, ref: "MonitorSuppliers" },
+    monitorId: { type: mongoose.Types.ObjectId, ref: "Monitors" },
+    supplierId: { type: mongoose.Types.ObjectId, ref: "MonitorSuppliers" },
     parameter: String,
     count: Number,
     threshold: Number,