@heliyos/heliyos-api-core 1.0.15 → 1.0.17

package/dist/mongoose.js

@@ -36,114 +36,147 @@ __exportStar(require("mongoose"), exports);
 let cachedConnection;
 let cachedReplicaConnection;
 const connectionOptions = {
-    // Connection timeouts
+    // Timeouts
     serverSelectionTimeoutMS: 60000,
     connectTimeoutMS: 60000,
     socketTimeoutMS: 360000,
-    // Connection pool
-    maxPoolSize: 50,
-    minPoolSize: 5,
-    // Reliability settings
+    // Connection pool settings
+    maxPoolSize: 10,
+    minPoolSize: 1,
+    // Heartbeat monitoring
+    heartbeatFrequencyMS: 10000,
+    // Modern reliability settings
     retryWrites: true,
     retryReads: true,
-    // Performance settings
-    heartbeatFrequencyMS: 10000,
-    // Monitoring
-    monitorCommands: true,
+    // Required for newer MongoDB versions
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
 };
-const MAX_RETRY_ATTEMPTS = 5;
-const INITIAL_RETRY_DELAY = 1000; // 1 second
+const MAX_RETRY_ATTEMPTS = 10; // Increased from 5
+const INITIAL_RETRY_DELAY = 2000; // Increased from 1000
 const connectWithRetry = (mongoUrl, attempt = 1) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         logger_1.logger.info(`Attempting to connect to MongoDB (attempt ${attempt}/${MAX_RETRY_ATTEMPTS})`);
+        // Create connection with event handlers
         const connection = mongoose_1.default.createConnection(mongoUrl, connectionOptions);
-        // Wait for connection to be ready
-        yield new Promise((resolve, reject) => {
-            connection.once("connected", () => resolve());
-            connection.once("error", (err) => reject(err));
+        // Set up event handlers before attempting connection
+        connection.on("error", (err) => {
+            logger_1.logger.error("MongoDB connection error:", err);
+            // Attempt reconnection after delay
+            setTimeout(() => {
+                if (connection.readyState !== mongoose_1.default.ConnectionStates.connected) {
+                    logger_1.logger.info("Attempting to reconnect after error...");
+                    connection.openUri(mongoUrl, connectionOptions);
+                }
+            }, 5000);
+        });
+        connection.on("disconnected", () => {
+            logger_1.logger.warn("MongoDB disconnected, attempting to reconnect...");
         });
+        connection.on("reconnected", () => {
+            logger_1.logger.info("MongoDB reconnected successfully");
+        });
+        // Wait for initial connection with timeout
+        yield Promise.race([
+            new Promise((resolve, reject) => {
+                connection.once("connected", () => resolve());
+                connection.once("error", (err) => reject(err));
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Connection timeout")), connectionOptions.connectTimeoutMS)),
+        ]);
         return connection;
     }
     catch (error) {
         if (attempt >= MAX_RETRY_ATTEMPTS) {
-            logger_1.logger.error("Max retry attempts reached. Failed to connect to MongoDB");
+            logger_1.logger.error("Max retry attempts reached. Failed to connect to MongoDB:", error);
             return null;
         }
         const delay = INITIAL_RETRY_DELAY * Math.pow(2, attempt - 1);
-        logger_1.logger.warn(`Connection attempt ${attempt} failed. Retrying in ${delay}ms...`);
+        logger_1.logger.warn(`Connection attempt ${attempt} failed. Retrying in ${delay}ms... Error: ${error.message}`);
         yield new Promise((resolve) => setTimeout(resolve, delay));
         return connectWithRetry(mongoUrl, attempt + 1);
     }
 });
 const mongooseConnected = () => __awaiter(void 0, void 0, void 0, function* () {
-    if (cachedConnection) {
-        // Use type assertion to check connection state
-        if (cachedConnection.readyState ===
-            mongoose_1.default.ConnectionStates.connected) {
-            logger_1.logger.info("Using cached MongoDB Connection");
-            return cachedConnection;
-        }
-        // Try to reconnect using existing connection
-        try {
-            yield cachedConnection.openUri(process.env.MONGO_DATABASE_URL, connectionOptions);
+    try {
+        if (cachedConnection) {
+            // Use type assertion to check connection state
             if (cachedConnection.readyState ===
                 mongoose_1.default.ConnectionStates.connected) {
-                logger_1.logger.info("Successfully reconnected using cached connection");
+                logger_1.logger.info("Using cached MongoDB Connection");
                 return cachedConnection;
             }
+            // Try to reconnect using existing connection
+            try {
+                yield cachedConnection.openUri(process.env.MONGO_DATABASE_URL, connectionOptions);
+                if (cachedConnection.readyState ===
+                    mongoose_1.default.ConnectionStates.connected) {
+                    logger_1.logger.info("Successfully reconnected using cached connection");
+                    return cachedConnection;
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn("Failed to reconnect using cached connection, will create new one");
+            }
         }
-        catch (error) {
-            logger_1.logger.warn("Failed to reconnect using cached connection, will create new one");
+        let mongoUrl;
+        const nodeEnv = process.env.NODE_ENV;
+        if (nodeEnv === "local") {
+            mongoUrl = process.env.MONGO_DATABASE_URL || "";
+            // Add logging to debug URL
         }
+        else if (["development", "production"].includes(nodeEnv)) {
+            const secrets = yield (0, ssm_1.getSecretsManagerSecret)(process.env.ENV_SECRET_NAME);
+            mongoUrl = secrets.MONGO_DATABASE_URL;
+        }
+        else {
+            logger_1.logger.error(`Invalid NODE_ENV: ${nodeEnv}`);
+            return null;
+        }
+        if (nodeEnv === "development") {
+            logger_1.logger.info(`Connecting to MongoDB URL: ${mongoUrl === null || mongoUrl === void 0 ? void 0 : mongoUrl.replace(/\/\/[^@]*@/, "//****:****@")}`);
+        }
+        if (!mongoUrl) {
+            logger_1.logger.error("MONGO_DATABASE_URL not set");
+            return null;
+        }
+        logger_1.logger.info("Creating new MongoDB Connection");
+        const connection = yield connectWithRetry(mongoUrl).catch((error) => {
+            logger_1.logger.error("Failed to connect to MongoDB:", error);
+            return null;
+        });
+        if (!connection) {
+            logger_1.logger.error("Failed to establish MongoDB connection after retries");
+            return null;
+        }
+        // Enhanced error handling
+        connection.on("error", (err) => {
+            logger_1.logger.error("MongoDB connection error:", err);
+            // Attempt to reconnect after a delay
+            setTimeout(() => {
+                if (connection.readyState !== mongoose_1.default.ConnectionStates.connected) {
+                    logger_1.logger.info("Attempting to reconnect...");
+                    connection.openUri(mongoUrl, connectionOptions);
+                }
+            }, 5000);
+        });
+        // Add connection monitoring
+        connection.on("disconnected", () => {
+            logger_1.logger.warn("MongoDB disconnected. Attempting to reconnect...");
+        });
+        connection.on("reconnected", () => {
+            logger_1.logger.info("MongoDB reconnected successfully");
+        });
+        connection.on("connected", () => {
+            logger_1.logger.info("MongoDB connected successfully");
+        });
+        cachedConnection = connection;
+        return connection;
     }
-    let mongoUrl;
-    const nodeEnv = process.env.NODE_ENV;
-    if (nodeEnv === "local" || nodeEnv === "development") {
-        mongoUrl = process.env.MONGO_DATABASE_URL;
-        // Add logging to debug URL
-        logger_1.logger.info(`Connecting to MongoDB URL: ${mongoUrl.replace(/\/\/[^@]*@/, "//****:****@")}`);
-    }
-    else if (["development", "production"].includes(nodeEnv)) {
-        const secrets = yield (0, ssm_1.getSecretsManagerSecret)(process.env.ENV_SECRET_NAME);
-        mongoUrl = secrets.MONGO_DATABASE_URL;
-    }
-    else {
-        logger_1.logger.error(`Invalid NODE_ENV: ${nodeEnv}`);
-        return null;
-    }
-    if (!mongoUrl) {
-        logger_1.logger.error("MONGO_DATABASE_URL not set");
-        return null;
-    }
-    logger_1.logger.info("Creating new MongoDB Connection");
-    const connection = yield connectWithRetry(mongoUrl);
-    if (!connection) {
-        logger_1.logger.error("Failed to establish MongoDB connection after retries");
+    catch (error) {
+        logger_1.logger.error("Unexpected error in mongooseConnected:", error);
         return null;
     }
-    // Enhanced error handling
-    connection.on("error", (err) => {
-        logger_1.logger.error("MongoDB connection error:", err);
-        // Attempt to reconnect after a delay
-        setTimeout(() => {
-            if (connection.readyState !== mongoose_1.default.ConnectionStates.connected) {
-                logger_1.logger.info("Attempting to reconnect...");
-                connection.openUri(mongoUrl, connectionOptions);
-            }
-        }, 5000);
-    });
-    // Add connection monitoring
-    connection.on("disconnected", () => {
-        logger_1.logger.warn("MongoDB disconnected. Attempting to reconnect...");
-    });
-    connection.on("reconnected", () => {
-        logger_1.logger.info("MongoDB reconnected successfully");
-    });
-    connection.on("connected", () => {
-        logger_1.logger.info("MongoDB connected successfully");
-    });
-    cachedConnection = connection;
-    return connection;
 });
 const replicaMongooseConnected = () => __awaiter(void 0, void 0, void 0, function* () {
     if (cachedReplicaConnection) {
@@ -307,10 +340,11 @@ const closeConnections = () => __awaiter(void 0, void 0, void 0, function* () {
     }
 });
 exports.closeConnections = closeConnections;
-// Add this new utility function
+// Update the startConnectionMonitoring function to be more resilient
 const startConnectionMonitoring = (checkInterval = 30000) => {
     let isReconnecting = false;
-    setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
+    let monitoringInterval;
+    const monitor = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             if (isReconnecting)
                 return;
@@ -336,7 +370,34 @@ const startConnectionMonitoring = (checkInterval = 30000) => {
             isReconnecting = false;
             logger_1.logger.error("Connection monitoring error:", error);
         }
-    }), checkInterval);
+    });
+    // Wrap the interval in a try-catch
+    try {
+        monitoringInterval = setInterval(monitor, checkInterval);
+    }
+    catch (error) {
+        logger_1.logger.error("Failed to start connection monitoring:", error);
+    }
+    // Return cleanup function
+    return () => {
+        try {
+            if (monitoringInterval) {
+                clearInterval(monitoringInterval);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error("Error cleaning up monitoring interval:", error);
+        }
+    };
 };
 // Call this when your application starts
 startConnectionMonitoring();
+// Add process-level error handling
+process.on("unhandledRejection", (reason, promise) => {
+    logger_1.logger.error("Unhandled Rejection at:", promise, "reason:", reason);
+    // Don't exit the process, just log the error
+});
+process.on("uncaughtException", (error) => {
+    logger_1.logger.error("Uncaught Exception:", error);
+    // Don't exit the process, just log the error
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heliyos/heliyos-api-core",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Heliyos's core api functions and middlewares. Its a private package hosted on npm.",
   "main": "./dist/index.js",
   "scripts": {