@heliyos/heliyos-api-core 1.0.13 → 1.0.15

package/dist/mongoose.d.ts

@@ -1,4 +1,4 @@
-import mongoose, { Connection, Model, Schema, FilterQuery, UpdateQuery } from "mongoose";
+import mongoose, { Model, Schema, FilterQuery, UpdateQuery } from "mongoose";
 export * from "mongoose";
 export interface Pagination<T> {
     data: T[];
@@ -16,7 +16,7 @@ declare module "mongoose" {
 }
 export declare const mongooseConnection: Promise<mongoose.Connection>;
 export declare const mongooseReplicaConnection: Promise<mongoose.Connection>;
-export declare const createModel: <T extends mongoose.Document<unknown, any, any>>(name: string, schema: Schema, connection?: Connection | Promise<Connection>) => mongoose.Model<T, {}, {}, {}, mongoose.IfAny<T, any, mongoose.Document<unknown, {}, T> & mongoose.Default__v<mongoose.Require_id<T>>>, any> | Promise<mongoose.Model<T, {}, {}, {}, mongoose.IfAny<T, any, mongoose.Document<unknown, {}, T> & mongoose.Default__v<mongoose.Require_id<T>>>, any>>;
+export declare const createModel: <T extends mongoose.Document<unknown, any, any>>(name: string, schema: Schema) => mongoose.Model<T, {}, {}, {}, mongoose.IfAny<T, any, mongoose.Document<unknown, {}, T> & mongoose.Default__v<mongoose.Require_id<T>>>, any>;
 export declare const createBulkOperations: <T>(operations: {
     updateOne?: {
         filter: mongoose.FilterQuery<T>;

package/dist/mongoose.js

@@ -10,18 +10,6 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
@@ -34,9 +22,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.closeConnections = exports.checkDatabaseHealth = exports.upsertDocument = exports.safeDelete = exports.withTransaction = exports.ensureIndexes = exports.createBulkOperations = exports.createModel = exports.mongooseReplicaConnection = exports.mongooseConnection = void 0;
-const mongoose_1 = __importStar(require("mongoose"));
+const mongoose_1 = __importDefault(require("mongoose"));
 const ssm_1 = require("./ssm");
 const logger_1 = require("./logger");
 // Export commonly used mongoose types
@@ -45,36 +36,111 @@ __exportStar(require("mongoose"), exports);
 let cachedConnection;
 let cachedReplicaConnection;
 const connectionOptions = {
-    serverSelectionTimeoutMS: 5000,
-    socketTimeoutMS: 45000,
+    // Connection timeouts
+    serverSelectionTimeoutMS: 60000,
+    connectTimeoutMS: 60000,
+    socketTimeoutMS: 360000,
+    // Connection pool
+    maxPoolSize: 50,
+    minPoolSize: 5,
+    // Reliability settings
     retryWrites: true,
+    retryReads: true,
+    // Performance settings
+    heartbeatFrequencyMS: 10000,
+    // Monitoring
+    monitorCommands: true,
 };
+const MAX_RETRY_ATTEMPTS = 5;
+const INITIAL_RETRY_DELAY = 1000; // 1 second
+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})`);
+        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));
+        });
+        return connection;
+    }
+    catch (error) {
+        if (attempt >= MAX_RETRY_ATTEMPTS) {
+            logger_1.logger.error("Max retry attempts reached. Failed to connect to MongoDB");
+            return null;
+        }
+        const delay = INITIAL_RETRY_DELAY * Math.pow(2, attempt - 1);
+        logger_1.logger.warn(`Connection attempt ${attempt} failed. Retrying in ${delay}ms...`);
+        yield new Promise((resolve) => setTimeout(resolve, delay));
+        return connectWithRetry(mongoUrl, attempt + 1);
+    }
+});
 const mongooseConnected = () => __awaiter(void 0, void 0, void 0, function* () {
     if (cachedConnection) {
-        logger_1.logger.info("Cached MongoDB Connection");
-        return 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);
+            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");
+        }
     }
     let mongoUrl;
     const nodeEnv = process.env.NODE_ENV;
-    if (nodeEnv === "local") {
+    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.info(`Failed to get mongoose configuration for env:${nodeEnv}`);
+        logger_1.logger.error(`Invalid NODE_ENV: ${nodeEnv}`);
         return null;
     }
     if (!mongoUrl) {
-        logger_1.logger.info("MONGO_DATABASE_URL not set");
+        logger_1.logger.error("MONGO_DATABASE_URL not set");
         return null;
     }
-    logger_1.logger.info("New MongoDB Connection");
-    const connection = mongoose_1.default.createConnection(mongoUrl, connectionOptions);
+    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");
+        return null;
+    }
+    // Enhanced error handling
     connection.on("error", (err) => {
-        console.error("MongoDB connection 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;
@@ -102,7 +168,11 @@ const replicaMongooseConnected = () => __awaiter(void 0, void 0, void 0, functio
         return null;
     }
     logger_1.logger.info("New MongoDB Replica Connection");
-    const connection = mongoose_1.default.createConnection(replicaUrl, connectionOptions);
+    const connection = yield connectWithRetry(replicaUrl);
+    if (!connection) {
+        logger_1.logger.error("Failed to establish MongoDB replica connection after retries");
+        return null;
+    }
     connection.on("error", (err) => {
         console.error("MongoDB replica connection error:", err);
     });
@@ -127,34 +197,31 @@ mongoose_1.default.Query.prototype.paginate = function (page = 1, limit = 10) {
 exports.mongooseConnection = mongooseConnected();
 exports.mongooseReplicaConnection = replicaMongooseConnected();
 // Helper for creating typed models
-const createModel = (name, schema, connection = exports.mongooseConnection) => {
-    // Add debug logging
+const createModel = (name, schema) => {
     logger_1.logger.info(`Creating model ${name}`);
-    // If we already have a cached connection, use it synchronously
-    if (connection instanceof mongoose_1.Connection) {
-        try {
-            logger_1.logger.info(`Using existing connection for model ${name}`);
-            return connection.model(name, schema);
-        }
-        catch (error) {
-            logger_1.logger.info(`Error creating model ${name}:`, error);
-            return null;
+    try {
+        // If no cached connection exists, create one
+        if (!cachedConnection) {
+            logger_1.logger.info(`No cached connection found, establishing new connection for model ${name}`);
+            let mongoUrl = process.env.MONGO_DATABASE_URL;
+            if (!mongoUrl) {
+                logger_1.logger.error("MONGO_DATABASE_URL not set");
+                return null;
+            }
+            cachedConnection = mongoose_1.default.createConnection(mongoUrl, connectionOptions);
+            cachedConnection.on("error", (err) => {
+                console.error("MongoDB connection error:", err);
+            });
+            logger_1.logger.info(`New connection established for model ${name}`);
         }
+        // Use the cached connection
+        logger_1.logger.info(`Creating model ${name} with connection`);
+        return cachedConnection.model(name, schema);
     }
-    // Otherwise, handle it asynchronously
-    return Promise.resolve(connection)
-        .then((conn) => {
-        if (!conn) {
-            logger_1.logger.info(`Database connection not established for model: ${name}`);
-            return null;
-        }
-        logger_1.logger.info(`Creating model ${name} with async connection`);
-        return conn.model(name, schema);
-    })
-        .catch((error) => {
-        logger_1.logger.info(`Error creating model ${name}:`, error);
+    catch (error) {
+        logger_1.logger.error(`Error creating model ${name}:`, error);
         return null;
-    });
+    }
 };
 exports.createModel = createModel;
 // Helper for bulk operations with better typing
@@ -212,8 +279,8 @@ exports.upsertDocument = upsertDocument;
 const checkDatabaseHealth = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const [primary, replica] = yield Promise.all([
-            exports.mongooseConnection.then((conn) => conn.readyState === 1),
-            exports.mongooseReplicaConnection.then((conn) => { var _a; return (_a = (conn === null || conn === void 0 ? void 0 : conn.readyState) === 1) !== null && _a !== void 0 ? _a : false; }),
+            exports.mongooseConnection.then((conn) => conn.readyState === mongoose_1.default.ConnectionStates.connected),
+            exports.mongooseReplicaConnection.then((conn) => { var _a; return (_a = (conn === null || conn === void 0 ? void 0 : conn.readyState) === mongoose_1.default.ConnectionStates.connected) !== null && _a !== void 0 ? _a : false; }),
         ]);
         return { primary, replica };
     }
@@ -240,3 +307,36 @@ const closeConnections = () => __awaiter(void 0, void 0, void 0, function* () {
     }
 });
 exports.closeConnections = closeConnections;
+// Add this new utility function
+const startConnectionMonitoring = (checkInterval = 30000) => {
+    let isReconnecting = false;
+    setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (isReconnecting)
+                return;
+            const conn = yield exports.mongooseConnection;
+            if (!conn ||
+                conn.readyState !== mongoose_1.default.ConnectionStates.connected) {
+                isReconnecting = true;
+                logger_1.logger.warn("Database connection is not healthy");
+                try {
+                    if (cachedConnection) {
+                        yield cachedConnection.openUri(process.env.MONGO_DATABASE_URL, connectionOptions);
+                    }
+                }
+                catch (reconnectError) {
+                    logger_1.logger.error("Failed to reconnect:", reconnectError);
+                }
+                finally {
+                    isReconnecting = false;
+                }
+            }
+        }
+        catch (error) {
+            isReconnecting = false;
+            logger_1.logger.error("Connection monitoring error:", error);
+        }
+    }), checkInterval);
+};
+// Call this when your application starts
+startConnectionMonitoring();

package/package.json

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