eip-cloud-services 1.2.4 → 1.2.5

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.2.5] - 2026-03-02
+
+### Fixed
+- Hardened Redis error handling to avoid throwing from client error events, reducing process instability during transient disconnects.
+- Reworked pub/sub client usage to use shared publisher/subscriber clients instead of per-channel client fan-out.
+- Improved subscription lifecycle management by tracking channel handlers and unsubscribing only when no handlers remain.
+- Improved Redis client cleanup and stale-client recovery behavior.
+
 ## [1.1.0] - 2023-11-18
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {

package/src/redis.js

@@ -8,6 +8,45 @@ if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirector
 }
 
 const clients = {};
+const subscriptionHandlers = new Map ();
+let mainSubListenerAttached = false;
+const lastConnectionErrorByClient = new Map ();
+const CONNECTION_ERROR_LOG_WINDOW_MS = 30000;
+
+const logConnectionError = ( clientId, error ) => {
+    const now = Date.now ();
+    const last = lastConnectionErrorByClient.get ( clientId ) || 0;
+    if ( now - last < CONNECTION_ERROR_LOG_WINDOW_MS ) {
+        return;
+    }
+    lastConnectionErrorByClient.set ( clientId, now );
+    console.error ( '\x1b[33mREDIS CONNECTION FAILED: Redis connection failed. If you\'re running locally, is a redis server actually active? Also, check your connection configuration.\x1b[0m', {
+        clientId,
+        error: error?.message || error
+    } );
+};
+
+const attachMainSubscriberListener = ( client ) => {
+    if ( mainSubListenerAttached ) {
+        return;
+    }
+    client.on ( 'message', ( receivedChannel, message ) => {
+        const handlers = subscriptionHandlers.get ( receivedChannel );
+        if ( !handlers || handlers.size === 0 ) {
+            return;
+        }
+        handlers.forEach ( handler => {
+            try {
+                handler ( message );
+            }
+            catch ( error ) {
+                console.error ( 'REDIS LIB ERROR [subscribe handler]', error );
+            }
+        } );
+    } );
+    mainSubListenerAttached = true;
+};
+
 const applyPrefix = (value) => {
     const prefix = config?.redis?.prefix;
     if (!prefix || typeof value !== 'string') return value;
@@ -32,6 +71,20 @@ const applyPrefix = (value) => {
  */
 const getClient = async ( clientId = 'main' ) => {
     try {
+        if ( clients[ clientId ] ) {
+            const status = clients[ clientId ].status;
+            if ( status === 'end' || status === 'close' ) {
+                try {
+                    clients[ clientId ].disconnect ();
+                }
+                catch ( _err ) {}
+                delete clients[ clientId ];
+                if ( clientId === 'main_sub' ) {
+                    mainSubListenerAttached = false;
+                }
+            }
+        }
+
         if ( !clients[ clientId ] ) {
             let redisClient;
 
@@ -52,8 +105,8 @@ const getClient = async ( clientId = 'main' ) => {
                     redisClient.once ( 'error', reject );
                 } );
 
-                redisClient.on ( 'node error', err => {
-                    console.error ( 'Redis cluster node error', err );
+                redisClient.on ( 'node error', error => {
+                    logConnectionError ( clientId, error );
                 } );
             }
             else if ( config?.redis?.clusterEnabled && ( !Array.isArray ( config.redis.cluster ) || config.redis.cluster.length === 0 ) ) {
@@ -66,8 +119,7 @@ const getClient = async ( clientId = 'main' ) => {
                 } );
 
                 redisClient.on ( 'error', error => {
-                    console.error ( '\x1b[33mREDIS CONNECTION FAILED: Redis connection failed. If you\'re running locally, is a redis server actually active? Also, check your connection configuration.\x1b[0m' );
-                    throw error;
+                    logConnectionError ( clientId, error );
                 } );
 
                 await new Promise ( ( resolve, reject ) => {
@@ -77,6 +129,14 @@ const getClient = async ( clientId = 'main' ) => {
             }
 
             clients[ clientId ] = redisClient;
+
+            if ( clientId === 'main_sub' ) {
+                attachMainSubscriberListener ( redisClient );
+                const channels = [ ...subscriptionHandlers.keys () ];
+                if ( channels.length > 0 ) {
+                    await redisClient.subscribe ( ...channels );
+                }
+            }
         }
 
         return clients[ clientId ];
@@ -88,8 +148,19 @@ const getClient = async ( clientId = 'main' ) => {
 
 const deleteClient = async ( clientId ) => {
     if ( clients[ clientId ] ){
-        await clients[ clientId ].quit ();
+        try {
+            await clients[ clientId ].quit ();
+        }
+        catch ( _err ) {
+            try {
+                clients[ clientId ].disconnect ();
+            }
+            catch ( __err ) {}
+        }
         delete clients[ clientId ];
+        if ( clientId === 'main_sub' ) {
+            mainSubListenerAttached = false;
+        }
     }
 };
 
@@ -731,7 +802,7 @@ exports.publish = async ( channel, message ) => {
     try {
         if ( typeof channel === 'string' && typeof message === 'string' ) {
             const fullChannel = applyPrefix ( channel );
-            const client = await getClient ( `${fullChannel}_pub` );
+            const client = await exports.getPubClient ();
 
             return client.publish ( fullChannel, message );
         }
@@ -756,16 +827,21 @@ exports.subscribe = async ( channel, messageHandler ) => {
     try {
         if ( typeof channel === 'string' && typeof messageHandler === 'function' ) {
             const fullChannel = applyPrefix ( channel );
-            const client = await getClient ( `${fullChannel}_sub` );
+            const client = await exports.getSubClient ();
+            attachMainSubscriberListener ( client );
 
-            client.on ( 'message', ( receivedChannel, message ) => {
-                if ( receivedChannel === fullChannel ) {
-                    messageHandler ( message );
+            if ( !subscriptionHandlers.has ( fullChannel ) ) {
+                subscriptionHandlers.set ( fullChannel, new Set () );
+                try {
+                    await client.subscribe ( fullChannel );
                 }
-            } );
+                catch ( error ) {
+                    subscriptionHandlers.delete ( fullChannel );
+                    throw error;
+                }
+            }
+            subscriptionHandlers.get ( fullChannel ).add ( messageHandler );
 
-            await client.subscribe ( fullChannel );
-        
             return;
         }
         else {
@@ -781,21 +857,32 @@ exports.subscribe = async ( channel, messageHandler ) => {
 /**
  * Unsubscribes from a channel.
  * @param {string} channel - The channel to unsubscribe from.
+ * @param {Function} [messageHandler] - Optional specific handler to unsubscribe.
  * @returns {Promise<void>} - A promise that resolves when the unsubscribe is complete.
  *
  * @description This method unsubscribes from the specified channel in Redis for incoming messages. 
  */
-exports.unsubscribe = async ( channel ) => {
+exports.unsubscribe = async ( channel, messageHandler ) => {
     try {
         if ( typeof channel === 'string' ) {
             const fullChannel = applyPrefix ( channel );
-            const client = await getClient ( `${fullChannel}_sub` );
-
-            client.removeAllListeners ( 'message' );
+            const handlers = subscriptionHandlers.get ( fullChannel );
+            if ( !handlers ) {
+                return;
+            }
 
-            await client.unsubscribe ( fullChannel );
-            await deleteClient ( `${fullChannel}_sub` );
+            if ( typeof messageHandler === 'function' ) {
+                handlers.delete ( messageHandler );
+            }
+            else {
+                handlers.clear ();
+            }
 
+            if ( handlers.size === 0 ) {
+                subscriptionHandlers.delete ( fullChannel );
+                const client = await exports.getSubClient ();
+                await client.unsubscribe ( fullChannel );
+            }
             return;
         }
         else {
@@ -833,5 +920,20 @@ exports.info = async () => {
  * @description This method closes the Redis connection using the 'quit' command, ensuring a graceful shutdown of the connection.
  */
 exports.kill = async () => {
-    await Promise.all ( Object.values ( clients ).map ( client => client.quit () ) );
+    await Promise.all (
+        Object.entries ( clients ).map ( async ( [ clientId, client ] ) => {
+            try {
+                await client.quit ();
+            }
+            catch ( _err ) {
+                try {
+                    client.disconnect ();
+                }
+                catch ( __err ) {}
+            }
+            delete clients[ clientId ];
+        } )
+    );
+    subscriptionHandlers.clear ();
+    mainSubListenerAttached = false;
 };