eip-cloud-services 1.2.4 → 1.2.6

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.6",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {

package/src/redis.js

@@ -8,12 +8,71 @@ 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;
     return value.startsWith(prefix) ? value : `${prefix}${value}`;
 };
 
+const toPlainObject = ( value ) => {
+    if ( value && typeof value === 'object' && !Array.isArray ( value ) ) {
+        return value;
+    }
+    return {};
+};
+
+const getRedisOptionsForClient = ( clientId, { cluster = false } = {} ) => {
+    const baseOptions = toPlainObject ( config?.redis?.options );
+    const perClientOptions = toPlainObject ( config?.redis?.clientOptionsById?.[ clientId ] );
+    const mergedOptions = { ...baseOptions, ...perClientOptions };
+
+    // Preserve existing cluster behaviour (TLS by default) unless explicitly overridden.
+    if ( cluster && !Object.prototype.hasOwnProperty.call ( mergedOptions, 'tls' ) ) {
+        mergedOptions.tls = {};
+    }
+
+    return mergedOptions;
+};
+
 /**
  * Creates or retrieves a Redis client instance based on a given client identifier.
  * If the client does not exist, it creates a new one, either connecting to a Redis Cluster
@@ -32,6 +91,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;
 
@@ -40,10 +113,11 @@ const getClient = async ( clientId = 'main' ) => {
                     host: node.host,
                     port: node.port
                 } ) );
+                const redisOptions = getRedisOptionsForClient ( clientId, { cluster: true } );
 
                 redisClient = new Redis.Cluster ( clusterNodes, {
                     dnsLookup: (address, callback) => callback(null, address),
-                    redisOptions: config?.redis?.options || {tls: {} }
+                    redisOptions
                 } );
 
                 // Await until the cluster is ready
@@ -52,22 +126,23 @@ 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 ) ) {
                 throw new Error ( 'Redis Cluster is enabled but there were no cluster nodes defined in config.redis.cluster' );
             }
             else {
+                const redisOptions = getRedisOptionsForClient ( clientId );
                 redisClient = new Redis ( {
                     host: config?.redis?.host,
-                    port: config?.redis?.port
+                    port: config?.redis?.port,
+                    ...redisOptions
                 } );
 
                 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 +152,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 +171,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 +825,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 +850,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 +880,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 +943,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;
 };