@duvdu-v1/duvdu 1.1.275 → 1.1.277

package/build/middlewares/pull.connection.d.ts

@@ -1,2 +1,2 @@
-declare const bullRedis: import("ioredis/built/Redis").default;
+declare const bullRedis: Promise<import("ioredis/built/Redis").default>;
 export { bullRedis };

package/build/middlewares/redis-connection.d.ts

@@ -1,6 +1,6 @@
 import RedisStore from 'connect-redis';
 import Redis from 'ioredis';
-export declare const getRedisClient: () => Redis;
+export declare const getRedisClient: () => Promise<Redis>;
 export declare const redisConnection: () => Promise<Redis>;
 export declare const sessionStore: () => Promise<RedisStore>;
 export declare const cleanupRedis: () => Promise<void>;

package/build/middlewares/redis-connection.js

@@ -17,11 +17,11 @@ const connect_redis_1 = __importDefault(require("connect-redis"));
 const ioredis_1 = __importDefault(require("ioredis"));
 const data_base_connections_1 = require("../errors/data-base-connections");
 // Create a Redis cluster or connection pool
-const MAX_CLIENTS = 5; // Limited to 5 connections to stay well below the 30 connection limit
+const MAX_CLIENTS = 1; // Single connection per service to minimize total connections
 let connectionPool = [];
 let currentConnectionIndex = 0;
-let totalConnectionsRequested = 0;
 let activeConnections = 0;
+let isInitializing = false;
 // Cache the RedisStore instance
 let redisStoreInstance = null;
 // Parse Redis connection details
@@ -30,13 +30,13 @@ const getRedisConfig = () => {
     const host = process.env.REDIS_HOST || 'redis-11177.c9.us-east-1-2.ec2.redns.redis-cloud.com';
     const port = parseInt(process.env.REDIS_PORT || '11177', 10);
     const password = process.env.REDIS_PASS || 'xgThFOa24hvwyVtsiNhIJiAxfhvJCLBU';
-    console.log(`[REDIS] Connecting to Redis at ${host}:${port}`);
     return {
         host,
         port,
         password,
         maxRetriesPerRequest: null,
         enableReadyCheck: false,
+        lazyConnect: true, // Don't connect immediately
         retryStrategy: (times) => {
             if (times > 3)
                 return null;
@@ -52,7 +52,6 @@ const getClientInfo = (client) => __awaiter(void 0, void 0, void 0, function* ()
         return connectedClients ? parseInt(connectedClients[1], 10) : 0;
     }
     catch (error) {
-        console.error('[REDIS] Error getting client info:', error);
         return 0;
     }
 });
@@ -60,23 +59,22 @@ const getClientInfo = (client) => __awaiter(void 0, void 0, void 0, function* ()
 const startMonitoring = () => {
     const monitorInterval = 60000; // 1 minute
     setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (connectionPool.length > 0) {
+        if (connectionPool.length > 0 && activeConnections > 0) {
             try {
-                const client = connectionPool[0]; // Use first client for monitoring
-                const clientCount = yield getClientInfo(client);
-                console.log(`[REDIS] Server stats - Connected clients: ${clientCount}, Pool size: ${connectionPool.length}, Active tracked connections: ${activeConnections}`);
+                const clientCount = yield getClientInfo(connectionPool[0]);
+                console.log(`[REDIS] Stats: Connected clients: ${clientCount}, Pool size: ${connectionPool.length}, Active: ${activeConnections}`);
             }
             catch (error) {
-                console.error('[REDIS] Error monitoring Redis:', error);
+                // Silent error
             }
         }
     }), monitorInterval);
 };
 // Initialize the connection pool
-const initializePool = () => {
-    if (connectionPool.length === 0) {
+const initializePool = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (connectionPool.length === 0 && !isInitializing) {
+        isInitializing = true;
         const config = getRedisConfig();
-        console.log(`[REDIS] Initializing connection pool with ${MAX_CLIENTS} clients to ${config.host}:${config.port}`);
         for (let i = 0; i < MAX_CLIENTS; i++) {
             const client = new ioredis_1.default(config);
             client.setMaxListeners(1000);
@@ -85,43 +83,41 @@ const initializePool = () => {
                 activeConnections++;
                 console.log(`[REDIS] Client #${i + 1} connected successfully (Active: ${activeConnections})`);
             });
-            client.on('error', (err) => {
-                console.error(`[REDIS] Client #${i + 1} connection error:`, err);
+            client.on('error', () => {
+                // Silent error
             });
             client.on('close', () => {
                 activeConnections = Math.max(0, activeConnections - 1);
-                console.log(`[REDIS] Client #${i + 1} connection closed (Active: ${activeConnections})`);
             });
             connectionPool.push(client);
         }
         // Start monitoring
         startMonitoring();
+        isInitializing = false;
     }
-};
+});
 // Get a client from the pool using round-robin
-const getRedisClient = () => {
+const getRedisClient = () => __awaiter(void 0, void 0, void 0, function* () {
     if (connectionPool.length === 0) {
-        initializePool();
+        yield initializePool();
     }
-    totalConnectionsRequested++;
-    // Round-robin selection
+    // Round-robin selection (though with MAX_CLIENTS=1, this just returns the single client)
     const client = connectionPool[currentConnectionIndex];
     currentConnectionIndex = (currentConnectionIndex + 1) % connectionPool.length;
-    if (totalConnectionsRequested % 100 === 0) {
-        console.log(`[REDIS] Total connection requests: ${totalConnectionsRequested}, Current pool size: ${connectionPool.length}, Active connections: ${activeConnections}`);
+    // Ensure the client is connected
+    if (client.status !== 'ready' && client.status !== 'connecting') {
+        yield client.connect();
     }
     return client;
-};
+});
 exports.getRedisClient = getRedisClient;
 const redisConnection = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const client = (0, exports.getRedisClient)();
-        console.log('[REDIS] Connection provided from pool');
+        const client = yield (0, exports.getRedisClient)();
         return client;
     }
     catch (error) {
         const config = getRedisConfig();
-        console.error(`[REDIS] Cannot connect to Redis: ${config.host}:${config.port}`, error);
         throw new data_base_connections_1.DatabaseConnectionError(`Cannot connect to Redis: ${config.host}:${config.port}`);
     }
 });
@@ -131,26 +127,22 @@ const sessionStore = () => __awaiter(void 0, void 0, void 0, function* () {
     if (redisStoreInstance) {
         return redisStoreInstance;
     }
-    const client = (0, exports.getRedisClient)();
-    console.log('[REDIS] Created session store with pooled connection');
+    const client = yield (0, exports.getRedisClient)();
     redisStoreInstance = new connect_redis_1.default({ client });
     return redisStoreInstance;
 });
 exports.sessionStore = sessionStore;
 const cleanupRedis = () => __awaiter(void 0, void 0, void 0, function* () {
     if (connectionPool.length > 0) {
-        console.log('[REDIS] Closing all Redis connections in the pool');
         for (let i = 0; i < connectionPool.length; i++) {
             const client = connectionPool[i];
             yield client.quit();
-            console.log(`[REDIS] Client #${i + 1} quit successfully`);
         }
         connectionPool = [];
         currentConnectionIndex = 0;
         activeConnections = 0;
         // Reset the store instance
         redisStoreInstance = null;
-        console.log('[REDIS] Connection pool cleared');
     }
 });
 exports.cleanupRedis = cleanupRedis;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duvdu-v1/duvdu",
-  "version": "1.1.275",
+  "version": "1.1.277",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [