devdad-express-utils 1.1.2 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Express Utils
 
-A collection of reusable utilities for Express.js applications, including error handling, async route wrapping, and custom error classes.
+A collection of reusable utilities for Express.js applications, including error handling, async route wrapping, custom error classes, and MongoDB connection management.
 
 ## Installation
 
@@ -83,6 +83,21 @@ app.get('/profile', authMiddleware, (req, res) => {
 });
 ```
 
+### Database Connection
+
+MongoDB connection utility with automatic reconnection and retry logic.
+
+```typescript
+import { connectDB, getDBStatus } from "devdad-express-utils";
+
+// Connect to MongoDB (ensure MONGO_URI is set in environment)
+await connectDB();
+
+// Check connection status
+const status = getDBStatus();
+console.log(status); // { isConnected: true, readyState: 1, host: '...', name: '...' }
+```
+
 ## Error Handling Patterns
 
 ### Using AppError
@@ -190,6 +205,22 @@ Middleware for JWT authentication.
 requireAuth(options: { secret: string, algorithms?: Algorithm[] }) => (req, res, next) => void
 ```
 
+### connectDB
+
+Connects to MongoDB with retry logic and automatic reconnection.
+
+```typescript
+connectDB() => Promise<void>
+```
+
+### getDBStatus
+
+Gets the current MongoDB connection status.
+
+```typescript
+getDBStatus() => { isConnected: boolean; readyState: number; host: string; name: string; }
+```
+
 ## Development
 
 ```bash

package/dist/DatabaseConnection.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Database connection class for MongoDB using Mongoose.
+ * Provides automatic reconnection, retry logic, and connection status monitoring.
+ */
+declare class DatabaseConnection {
+    private retryCount;
+    private isConnected;
+    /**
+     * Creates a new DatabaseConnection instance.
+     * Sets up event listeners for connection events and application termination signals.
+     */
+    constructor();
+    /**
+     * Establishes a connection to MongoDB.
+     * @throws {Error} If MONGO_URI is not defined in environment variables.
+     */
+    connect(): Promise<void>;
+    /**
+     * Handles connection errors by retrying the connection up to MAX_RETRIES times.
+     * Exits the process if all retries fail.
+     */
+    private handleConnectionError;
+    /**
+     * Handles disconnection events by attempting to reconnect if not already connected.
+     */
+    private handleDisconnection;
+    /**
+     * Handles application termination by closing the database connection gracefully.
+     */
+    private handleAppTermination;
+    /**
+     * Gets the current connection status.
+     * @returns An object containing connection status information.
+     */
+    getConnectionStatus(): {
+        isConnected: boolean;
+        readyState: number;
+        host: string;
+        name: string;
+    };
+}
+declare const _default: () => Promise<void>;
+export default _default;
+export declare const getDBStatus: () => {
+    isConnected: boolean;
+    readyState: number;
+    host: string;
+    name: string;
+};
+export { DatabaseConnection };

package/dist/DatabaseConnection.js

@@ -0,0 +1,127 @@
+import mongoose from "mongoose";
+/**
+ * Maximum number of connection retry attempts
+ */
+const MAX_RETRIES = 3;
+/**
+ * Interval between retry attempts in milliseconds
+ */
+const RETRY_INTERVAL = 5000; // 5 seconds
+/**
+ * Database connection class for MongoDB using Mongoose.
+ * Provides automatic reconnection, retry logic, and connection status monitoring.
+ */
+class DatabaseConnection {
+    retryCount;
+    isConnected;
+    /**
+     * Creates a new DatabaseConnection instance.
+     * Sets up event listeners for connection events and application termination signals.
+     */
+    constructor() {
+        this.retryCount = 0;
+        this.isConnected = false;
+        // Configure mongoose settings
+        mongoose.set("strictQuery", true);
+        // Handle connection events
+        mongoose.connection.on("connected", () => {
+            console.log("✅ MongoDB connected successfully");
+            this.isConnected = true;
+        });
+        mongoose.connection.on("error", (err) => {
+            console.error("❌ MongoDB connection error:", err);
+            this.isConnected = false;
+        });
+        mongoose.connection.on("disconnected", () => {
+            console.log("⚠️ MongoDB disconnected");
+            this.isConnected = false;
+            this.handleDisconnection();
+        });
+        // Handle application termination
+        process.on("SIGINT", this.handleAppTermination.bind(this));
+        process.on("SIGTERM", this.handleAppTermination.bind(this));
+    }
+    /**
+     * Establishes a connection to MongoDB.
+     * @throws {Error} If MONGO_URI is not defined in environment variables.
+     */
+    async connect() {
+        try {
+            if (!process.env.MONGO_URI) {
+                throw new Error("MongoDB URI is not defined in environment variables");
+            }
+            const connectionOptions = {
+                maxPoolSize: 10,
+                serverSelectionTimeoutMS: 5000,
+                socketTimeoutMS: 45000,
+                family: 4, // Use IPv4
+            };
+            if (process.env.NODE_ENV === "development") {
+                mongoose.set("debug", true);
+            }
+            await mongoose.connect(process.env.MONGO_URI, connectionOptions);
+            this.retryCount = 0; // Reset retry count on successful connection
+        }
+        catch (error) {
+            console.error("Failed to connect to MongoDB:", error.message);
+            await this.handleConnectionError();
+        }
+    }
+    /**
+     * Handles connection errors by retrying the connection up to MAX_RETRIES times.
+     * Exits the process if all retries fail.
+     */
+    async handleConnectionError() {
+        if (this.retryCount < MAX_RETRIES) {
+            this.retryCount++;
+            console.log(`Retrying connection... Attempt ${this.retryCount} of ${MAX_RETRIES}`);
+            await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
+            return this.connect();
+        }
+        else {
+            console.error(`Failed to connect to MongoDB after ${MAX_RETRIES} attempts`);
+            process.exit(1);
+        }
+    }
+    /**
+     * Handles disconnection events by attempting to reconnect if not already connected.
+     */
+    handleDisconnection() {
+        if (!this.isConnected) {
+            console.log("Attempting to reconnect to MongoDB...");
+            this.connect();
+        }
+    }
+    /**
+     * Handles application termination by closing the database connection gracefully.
+     */
+    async handleAppTermination() {
+        try {
+            await mongoose.connection.close();
+            console.log("MongoDB connection closed through app termination");
+            process.exit(0);
+        }
+        catch (err) {
+            console.error("Error during database disconnection:", err);
+            process.exit(1);
+        }
+    }
+    /**
+     * Gets the current connection status.
+     * @returns An object containing connection status information.
+     */
+    getConnectionStatus() {
+        return {
+            isConnected: this.isConnected,
+            readyState: mongoose.connection.readyState,
+            host: mongoose.connection.host,
+            name: mongoose.connection.name,
+        };
+    }
+}
+// Create a singleton instance
+const dbConnection = new DatabaseConnection();
+// Export the connect function and the instance
+export default dbConnection.connect.bind(dbConnection);
+export const getDBStatus = dbConnection.getConnectionStatus.bind(dbConnection);
+export { DatabaseConnection };

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export { catchAsync } from "./catchAsync.js";
 export { errorHandler } from "./errorHandler.js";
 export { sendSuccess, sendError } from "./responseFormatter.js";
 export { requireAuth } from "./authWrapper.js";
+export { default as connectDB, getDBStatus, DatabaseConnection } from "./DatabaseConnection.js";

package/dist/index.js

@@ -3,3 +3,4 @@ export { catchAsync } from "./catchAsync.js";
 export { errorHandler } from "./errorHandler.js";
 export { sendSuccess, sendError } from "./responseFormatter.js";
 export { requireAuth } from "./authWrapper.js";
+export { default as connectDB, getDBStatus, DatabaseConnection } from "./DatabaseConnection.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devdad-express-utils",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Reusable Express.js utilities for error handling, async wrapping, and more",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,14 +26,18 @@
   },
   "license": "ISC",
   "dependencies": {
+    "@types/mongoose": "^5.11.96",
     "express": "^5.1.0",
-    "jsonwebtoken": "^9.0.2"
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^9.0.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.5",
     "@types/jsonwebtoken": "^9.0.10",
+    "@types/mongodb-memory-server": "^1.8.0",
     "@types/supertest": "^6.0.3",
     "@vitest/ui": "^4.0.14",
+    "mongodb-memory-server": "^10.3.0",
     "supertest": "^7.1.4",
     "typescript": "^5.9.3",
     "vitest": "^4.0.14"