eip-cloud-services 1.0.21 → 1.1.0

package/src/redis.js

@@ -1,26 +1,111 @@
-const redis = require ( 'redis' );
-const config = require ( 'config' );
-let redisClient;
+// Replace the redis require with ioredis
+const Redis = require ( 'ioredis' );
+const fs = require ( 'fs' );
+let config = {};
+const configDirPath = `${process.cwd ()}/config`;
+if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirectory () ) {
+    config = require ( 'config' ); // require the config directory if it exists
+}
 
-const getClient = async () => {
+const clients = {};
+
+/**
+ * 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
+ * or a single Redis instance based on the configuration.
+ *
+ * @param {string} [clientId='main'] - The identifier for the Redis client. Defaults to 'main'.
+ *                                      This identifier is used to manage multiple Redis client instances.
+ * @returns {Promise<Redis | Redis.Cluster>} A promise that resolves with the Redis client instance.
+ * @throws {Error} Throws an error if the Redis connection or configuration fails.
+ *
+ * @description
+ * This function manages a pool of Redis clients, identified by unique clientIds.
+ * It supports connecting to both standard Redis and Redis Cluster configurations.
+ * For a Redis Cluster, it expects an array of node details in the configuration.
+ * The function handles connection readiness and errors for both cluster and standard modes.
+ */
+const getClient = async ( clientId = 'main' ) => {
     try {
-        if ( !redisClient ) {
-            redisClient = redis.createClient ( { url: `${config.redis.host}:${config.redis.port}` } );
-            await redisClient.connect ();
-            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;
-            }, { once: true } );
+        if ( !clients[ clientId ] ) {
+            let redisClient;
+
+            if ( config?.redis?.clusterEnabled && Array.isArray ( config.redis.cluster ) && config.redis.cluster.length > 0 ) {
+                const clusterNodes = config.redis.cluster.map ( node => ( {
+                    host: node.host,
+                    port: node.port
+                } ) );
+
+                redisClient = new Redis.Cluster ( clusterNodes );
+
+                // Await until the cluster is ready
+                await new Promise ( ( resolve, reject ) => {
+                    redisClient.once ( 'ready', resolve );
+                    redisClient.once ( 'error', reject );
+                } );
+
+                redisClient.on ( 'node error', err => {
+                    console.error ( 'Redis cluster node error', err );
+                } );
+            }
+            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 {
+                redisClient = new Redis ( {
+                    host: config?.redis?.host,
+                    port: config?.redis?.port
+                } );
+
+                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;
+                } );
+
+                await new Promise ( ( resolve, reject ) => {
+                    redisClient.once ( 'ready', resolve );
+                    redisClient.once ( 'error', reject );
+                } );
+            }
+
+            clients[ clientId ] = redisClient;
         }
 
-        return redisClient;
+        return clients[ clientId ];
     }
-    catch ( error ){
-        throw new Error ( 'Redis connection failed. If running locally is redis actually running? Also check your connection configuration.' );
+    catch ( error ) {
+        throw error;
     }
 };
 
+/**
+ * Retrieves a Redis client based on the provided identifier.
+ * This function is primarily used internally within the module.
+ * For standard operations, the module's functionality should be used directly.
+ * 
+ * @param {string} [clientId='main'] - The identifier for the Redis client. Defaults to 'main'.
+ * @returns {Promise<Redis>} - A promise that resolves with the Redis client.
+ */
+exports.getClient = getClient;
+
+/**
+ * Retrieves a dedicated Redis client for subscription operations.
+ * This is a specialized client intended for internal use by the module,
+ * specifically for managing subscriptions to Redis channels.
+ * 
+ * @returns {Promise<Redis>} - A promise that resolves with the Redis subscription client.
+ */
+exports.getSubClient = () => getClient ( 'main_sub' );
+
+/**
+ * Retrieves a dedicated Redis client for publishing operations.
+ * This client is used internally by the module for publishing messages to Redis channels.
+ * It's not intended for direct use; instead, use the module's publish functionality.
+ * 
+ * @returns {Promise<Redis>} - A promise that resolves with the Redis publishing client.
+ */
+exports.getPubClient = () => getClient ( 'main_pub' );
+
 /**
  * Retrieves all keys matching a pattern.
  * @param {string} pattern - The pattern to match.
@@ -34,11 +119,10 @@ exports.keys = async ( pattern ) => {
         if ( typeof pattern === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                pattern.startsWith ( config.redis.prefix ) ? pattern : config.redis.prefix + pattern,
-            ];
+            const fullPattern = pattern.startsWith ( config?.redis?.prefix ) ? pattern : config?.redis?.prefix + pattern;
 
-            return await client.sendCommand ( [ 'KEYS', ...commandArgs ] );
+            // Use the keys method directly instead of sendCommand
+            return await client.keys ( fullPattern );
         }
 
         throw new Error ( `redis.keys expects a string pattern, instead the type provided was: ${typeof pattern}` );
@@ -49,6 +133,36 @@ exports.keys = async ( pattern ) => {
     }
 };
 
+/**
+ * Iteratively scans through keys in the Redis database.
+ * @param {number} cursor - The cursor to start scanning from. Use 0 to start a new scan.
+ * @param {string} [matchPattern='*'] - The pattern to match keys against. Defaults to '*' to match all keys.
+ * @param {number} [count=100] - The number of keys to return per call. Defaults to 100.
+ * @returns {Promise<Array>} - A promise that resolves with an array containing the next cursor and an array of keys.
+ *
+ * @description
+ * This method uses the SCAN command to iteratively scan through the keys in the Redis database.
+ * It allows for efficient scanning of large datasets without the risk of blocking the server for a long time.
+ * The method returns a promise that resolves with an array, where the first element is the next cursor to be used
+ * for subsequent calls, and the second element is an array of keys that matched the pattern.
+ */
+exports.scan = async ( cursor, matchPattern = '*', count = 100 ) => {
+    try {
+        const client = await getClient ();
+
+        const fullMatchPattern = matchPattern.startsWith ( config?.redis?.prefix ) ? matchPattern : config?.redis?.prefix + matchPattern;
+
+        // Directly use the scan method provided by ioredis
+        const result = await client.scan ( cursor, 'MATCH', fullMatchPattern, 'COUNT', count );
+
+        return result;
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [scan]', error );
+        throw error;
+    }
+};
+
 /**
  * Retrieves the value of a key.
  * @param {string} key - The key to retrieve.
@@ -63,11 +177,10 @@ exports.get = async ( key ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            const data = await client.sendCommand ( [ 'GET', ...commandArgs ] );
+            // Use the get method directly
+            const data = await client.get ( fullKey );
 
             try {
                 return JSON.parse ( data );
@@ -80,7 +193,44 @@ exports.get = async ( key ) => {
         throw new Error ( `redis.get expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [get]', error.stack );
+        console.log ( 'REDIS LIB ERROR [get]', error );
+        throw error;
+    }
+};
+
+/**
+ * Retrieves the values of multiple keys.
+ * @param {string[]} keys - The keys to retrieve.
+ * @returns {Promise} - A promise that resolves with the values of the keys.
+ *
+ * @description This method retrieves the values associated with the specified keys from Redis.
+ * If the value is a JSON string, it will be parsed and returned as a JavaScript object.
+ * If the value is not a valid JSON string, it will be returned as a string.
+ */
+exports.multiGet = async ( keys ) => {
+    try {
+        if ( Array.isArray ( keys ) ) {
+            const client = await getClient ();
+
+            const fullKeys = keys.map ( key => key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key );
+
+            // Use the mget method directly
+            const data = await client.mget ( ...fullKeys );
+
+            return data.map ( val => {
+                try {
+                    return JSON.parse ( val );
+                }
+                catch {
+                    return val;
+                }
+            } );
+        }
+
+        throw new Error ( `redis.multiGet expects an array of keys, instead the type provided was: ${typeof keys}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [multiGet]', error );
         throw error;
     }
 };
@@ -102,15 +252,12 @@ exports.set = async ( key, value, ex, px ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-                value,
-            ];
-
-            if ( ex ) commandArgs.push ( 'EX', String ( ex ) );
-            if ( px ) commandArgs.push ( 'PX', String ( px ) );
+            // Automatically convert objects or arrays to JSON strings
+            const serializedValue = ( typeof value === 'object' && value !== null ) ? JSON.stringify ( value ) : value;
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'SET', ...commandArgs ] );
+            // Use the set method directly with optional EX and PX parameters
+            return await client.set ( fullKey, serializedValue, ...( ex ? [ 'EX', ex ] : [] ), ...( px ? [ 'PX', px ] : [] ) );
         }
 
         throw new Error ( `redis.set expects a string key, instead the type provided was: ${typeof key}` );
@@ -135,17 +282,47 @@ exports.del = async ( key ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'DEL', ...commandArgs ] );
+            // Use the del method directly
+            return await client.del ( fullKey );
         }
 
         throw new Error ( `redis.del expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [del]', error.stack );
+        console.log ( 'REDIS LIB ERROR [del]', error );
+        throw error;
+    }
+};
+
+/**
+ * Deletes multiple keys.
+ * @param {string[]} keys - The keys to delete.
+ * @returns {Promise<number>} - A promise that resolves with the count of keys deleted.
+ *
+ * @description
+ * This method deletes the specified keys from Redis.
+ * If a key does not exist, it is silently ignored. The function returns the count of keys actually deleted.
+ * If an array is empty or none of the keys exist, the function returns 0.
+ * Note: It's more efficient to delete multiple keys in one call than to use individual delete calls for each key.
+ */
+exports.multiDel = async ( keys ) => {
+    try {
+        if ( Array.isArray ( keys ) && keys.every ( key => typeof key === 'string' ) ) {
+            const client = await getClient ();
+
+            // Prepend the Redis prefix to each key if necessary
+            const fullKeys = keys.map ( key => key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key );
+
+            // Use the del method with multiple keys
+            return await client.del ( ...fullKeys );
+        }
+
+        throw new Error ( `redis.multiDel expects an array of string keys, instead the type provided was: ${typeof keys}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [multiDel]', error );
         throw error;
     }
 };
@@ -154,7 +331,7 @@ exports.del = async ( key ) => {
  * Adds one or more members to a set.
  * @param {string} key - The key of the set.
  * @param {string|string[]} members - The member(s) to add to the set.
- * @returns {Promise} - A promise that resolves with the result of the SADD command.
+ * @returns {Promise<number>} - A promise that resolves with the number of members that were added to the set.
  *
  * @description This method adds one or more members to the specified set in Redis.
  * If the set does not exist, it will be created.
@@ -166,12 +343,11 @@ exports.setAdd = async ( key, members ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-                ...( Array.isArray ( members ) ? members : [ members ] ),
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+            const membersArray = Array.isArray ( members ) ? members : [ members ];
 
-            return await client.sendCommand ( [ 'SADD', ...commandArgs ] );
+            // Use the sadd method directly
+            return await client.sadd ( fullKey, ...membersArray );
         }
 
         throw new Error ( `redis.setAdd expects a string key, instead the type provided was: ${typeof key}` );
@@ -186,7 +362,7 @@ exports.setAdd = async ( key, members ) => {
  * Removes one or more members from a set.
  * @param {string} key - The key of the set.
  * @param {string|string[]} members - The member(s) to remove from the set.
- * @returns {Promise} - A promise that resolves with the result of the SREM command.
+ * @returns {Promise<number>} - A promise that resolves with the number of members that were removed from the set.
  *
  * @description This method removes one or more members from the specified set in Redis.
  * If the set does not exist or if any member does not exist in the set, it will be ignored.
@@ -197,18 +373,17 @@ exports.setRemove = async ( key, members ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-                ...( Array.isArray ( members ) ? members : [ members ] ),
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+            const membersArray = Array.isArray ( members ) ? members : [ members ];
 
-            return await client.sendCommand ( [ 'SREM', ...commandArgs ] );
+            // Use the srem method directly
+            return await client.srem ( fullKey, ...membersArray );
         }
 
         throw new Error ( `redis.setRemove expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [setRemove]', error.stack );
+        console.log ( 'REDIS LIB ERROR [setRemove]', error );
         throw error;
     }
 };
@@ -216,7 +391,7 @@ exports.setRemove = async ( key, members ) => {
 /**
  * Retrieves all members of a set.
  * @param {string} key - The key of the set.
- * @returns {Promise} - A promise that resolves with the result of the SMEMBERS command.
+ * @returns {Promise<string[]>} - A promise that resolves with an array of members of the set.
  *
  * @description This method retrieves all members of the specified set in Redis.
  * If the set does not exist, it will return an empty array.
@@ -226,17 +401,16 @@ exports.setMembers = async ( key ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'SMEMBERS', ...commandArgs ] );
+            // Use the smembers method directly
+            return await client.smembers ( fullKey );
         }
 
         throw new Error ( `redis.setMembers expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [setMembers]', error.stack );
+        console.log ( 'REDIS LIB ERROR [setMembers]', error );
         throw error;
     }
 };
@@ -244,7 +418,7 @@ exports.setMembers = async ( key ) => {
 /**
  * Removes and returns a random member from a set.
  * @param {string} key - The key of the set.
- * @returns {Promise} - A promise that resolves with the removed member, or null if the set is empty.
+ * @returns {Promise<string|null>} - A promise that resolves with the removed member, or null if the set is empty.
  *
  * @description
  * This function removes and returns a random member from a set identified by the provided key.
@@ -256,25 +430,24 @@ exports.setPop = async ( key ) => {
     try {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
-  
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
-  
-            const member = await client.sendCommand ( [ 'SPOP', ...commandArgs ] );
-        
+
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+
+            // Use the spop method directly
+            const member = await client.spop ( fullKey );
+
             // If the member is null or an empty string, return null
             if ( member === null || member === '' ) {
                 return null;
             }
-  
+
             return member;
         }
-  
+
         throw new Error ( `redis.setPop expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [setPop]', error.stack );
+        console.log ( 'REDIS LIB ERROR [setPop]', error );
         throw error;
     }
 };
@@ -283,7 +456,7 @@ exports.setPop = async ( key ) => {
  * Prepends multiple values to the head of a list.
  * @param {string} key - The key of the list.
  * @param {string|string[]} values - The values to prepend to the list.
- * @returns {Promise} - A promise that resolves with the result of the LPUSH command.
+ * @returns {Promise<number>} - A promise that resolves with the length of the list after the prepend operation.
  *
  * @description This method prepends one or more values to the head of the specified list in Redis.
  * If the list does not exist, it will be created.
@@ -295,27 +468,17 @@ exports.listUnshift = async ( key, values ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
-
-            if ( typeof values === 'string' ) {
-                commandArgs.push ( values );
-            }
-            else if ( Array.isArray ( values ) ) {
-                commandArgs.push ( ...values );
-            }
-            else {
-                throw new Error ( `redis.listUnshift expects a string or an array of strings as the values, instead the type provided was: ${typeof values}` );
-            }
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+            const valuesArray = Array.isArray ( values ) ? values : [ values ];
 
-            return await client.sendCommand ( [ 'LPUSH', ...commandArgs ] );
+            // Use the lpush method directly
+            return await client.lpush ( fullKey, ...valuesArray );
         }
 
         throw new Error ( `redis.listUnshift expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [listUnshift]', error.stack );
+        console.log ( 'REDIS LIB ERROR [listUnshift]', error );
         throw error;
     }
 };
@@ -324,7 +487,7 @@ exports.listUnshift = async ( key, values ) => {
  * Pushes values to the tail of a list.
  * @param {string} key - The key of the list.
  * @param {string|string[]} values - The value(s) to push to the list.
- * @returns {Promise} - A promise that resolves with the result of the RPUSH command.
+ * @returns {Promise<number>} - A promise that resolves with the length of the list after the push operation.
  *
  * @description This method pushes one or more values to the tail of the specified list in Redis.
  * If the list does not exist, it will be created.
@@ -336,27 +499,17 @@ exports.listPush = async ( key, values ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+            const valuesArray = Array.isArray ( values ) ? values : [ values ];
 
-            if ( typeof values === 'string' ) {
-                commandArgs.push ( values );
-            }
-            else if ( Array.isArray ( values ) ) {
-                commandArgs.push ( ...values );
-            }
-            else {
-                throw new Error ( `redis.listPush expects a string or an array of strings as the values, instead the type provided was: ${typeof values}` );
-            }
-
-            return await client.sendCommand ( [ 'RPUSH', ...commandArgs ] );
+            // Use the rpush method directly
+            return await client.rpush ( fullKey, ...valuesArray );
         }
 
         throw new Error ( `redis.listPush expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [listPush]', error.stack );
+        console.log ( 'REDIS LIB ERROR [listPush]', error );
         throw error;
     }
 };
@@ -364,8 +517,8 @@ exports.listPush = async ( key, values ) => {
 /**
  * Removes and returns the first element of a list.
  * @param {string} key - The key of the list.
- * @param {number} count - The number of items to remove (default: 0).
- * @returns {Promise} - A promise that resolves with the result of the LPOP command.
+ * @param {number} count - The number of items to remove (default: 1).
+ * @returns {Promise<string|string[]>} - A promise that resolves with the removed element(s).
  *
  * @description This method removes and returns the first element(s) from the specified list in Redis.
  * If the list is empty or does not exist, it will return null.
@@ -377,18 +530,41 @@ exports.listPop = async ( key, count = 1 ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-                String ( count ),
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'LPOP', ...commandArgs ] );
+            // Use the lpop method directly with the count parameter
+            return await client.lpop ( fullKey, count );
         }
 
         throw new Error ( `redis.listPop expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [listPop]', error.stack );
+        console.log ( 'REDIS LIB ERROR [listPop]', error );
+        throw error;
+    }
+};
+
+/**
+ * Removes and returns the last element of a list.
+ * @param {string} key - The key of the list.
+ * @returns {Promise<string|null>} - A promise that resolves with the removed element, or null if the list is empty.
+ *
+ * @description This method removes and returns the last element from the specified list in Redis.
+ */
+exports.listPopEnd = async ( key ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+
+            return await client.rpop ( fullKey );
+        }
+
+        throw new Error ( 'redis.listPopEnd expects a string key' );
+    }
+    catch ( error ) {
+        console.error ( 'REDIS LIB ERROR [listPopEnd]', error );
         throw error;
     }
 };
@@ -398,7 +574,7 @@ exports.listPop = async ( key, count = 1 ) => {
  * @param {string} key - The key of the list.
  * @param {number} start - The starting index (default: 0).
  * @param {number} end - The ending index (default: -1).
- * @returns {Promise} - A promise that resolves with the result of the LRANGE command.
+ * @returns {Promise<string[]>} - A promise that resolves with an array of elements from the specified range.
  *
  * @description This method retrieves a range of elements from the specified list in Redis.
  * The range is specified by the start and end indices.
@@ -410,19 +586,16 @@ exports.listRange = async ( key, start = 0, end = -1 ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-                String ( start ),
-                String ( end ),
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'LRANGE', ...commandArgs ] );
+            // Use the lrange method directly
+            return await client.lrange ( fullKey, start, end );
         }
 
         throw new Error ( `redis.listRange expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [listRange]', error.stack );
+        console.log ( 'REDIS LIB ERROR [listRange]', error );
         throw error;
     }
 };
@@ -430,7 +603,7 @@ exports.listRange = async ( key, start = 0, end = -1 ) => {
 /**
  * Retrieves the expiration time of a key in seconds.
  * @param {string} key - The key to get the expiration time of.
- * @returns {Promise} - A promise that resolves with the result of the TTL command.
+ * @returns {Promise<number>} - A promise that resolves with the number of seconds remaining until the key expires, or -1 if the key does not have an expiration.
  *
  * @description This method retrieves the expiration time (in seconds) of the specified key in Redis.
  * If the key does not exist or does not have an expiration set, it will return -1.
@@ -442,17 +615,16 @@ exports.getExpiryInSeconds = async ( key ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'TTL', ...commandArgs ] );
+            // Use the ttl method directly
+            return await client.ttl ( fullKey );
         }
 
         throw new Error ( `redis.getExpiryInSeconds expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [getExpiryInSeconds]', error.stack );
+        console.log ( 'REDIS LIB ERROR [getExpiryInSeconds]', error );
         throw error;
     }
 };
@@ -461,7 +633,7 @@ exports.getExpiryInSeconds = async ( key ) => {
  * Sets the expiration time for a key in seconds.
  * @param {string} key - The key to set the expiration time for.
  * @param {number} seconds - The expiration time in seconds (default: 0).
- * @returns {Promise} - A promise that resolves with the result of the EXPIRE command.
+ * @returns {Promise<number>} - A promise that resolves with 1 if the expiration time was set successfully, or 0 if the key does not exist.
  *
  * @description This method sets the expiration time (in seconds) for the specified key in Redis.
  * If the key does not exist, it will return 0 indicating no expiration was set.
@@ -472,25 +644,100 @@ exports.setExpiry = async ( key, seconds = 0 ) => {
         if ( typeof key === 'string' ) {
             const client = await getClient ();
 
-            const commandArgs = [
-                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
-                String ( seconds ),
-            ];
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
 
-            return await client.sendCommand ( [ 'EXPIRE', ...commandArgs ] );
+            // Use the expire method directly
+            return await client.expire ( fullKey, seconds );
         }
 
         throw new Error ( `redis.setExpiry expects a string key, instead the type provided was: ${typeof key}` );
     }
     catch ( error ) {
-        console.log ( 'REDIS LIB ERROR [setExpiry]', error.stack );
+        console.log ( 'REDIS LIB ERROR [setExpiry]', error );
         throw error;
     }
 };
 
-exports.kill = async () => {
-    const client = await getClient ();
-    client.quit ();
+/**
+ * Publishes a message to a channel.
+ * @param {string} channel - The channel to publish the message to.
+ * @param {string} message - The message to publish.
+ * @returns {Promise<number>} - A promise that resolves with the number of subscribers that received the message.
+ *
+ * @description This method publishes a message to the specified channel in Redis.
+ */
+exports.publish = async ( channel, message ) => {
+    try {
+        if ( typeof channel === 'string' && typeof message === 'string' ) {
+            const client = await getClient ( `${channel}_pub` );
 
-    return;
+            return client.publish ( channel, message );
+        }
+
+        throw new Error ( 'redis.publish expects string types for both channel and message' );
+    }
+    catch ( error ) {
+        console.error ( 'REDIS LIB ERROR [publish]', error );
+        throw error;
+    }
+};
+
+/**
+ * Subscribes to a channel to listen for messages.
+ * @param {string} channel - The channel to subscribe to.
+ * @param {Function} messageHandler - The callback function to handle messages.
+ * @returns {Promise<void>} - A promise that resolves when the subscription is set up.
+ *
+ * @description This method subscribes to the specified channel in Redis and sets up a handler for incoming messages.
+ */
+exports.subscribe = async ( channel, messageHandler ) => {
+    try {
+        if ( typeof channel === 'string' && typeof messageHandler === 'function' ) {
+            const client = await getClient ( `${channel}_sub` );
+
+            client.on ( 'message', ( receivedChannel, message ) => {
+                if ( receivedChannel === channel ) {
+                    messageHandler ( message );
+                }
+            } );
+            await client.subscribe ( channel );
+        
+            return;
+        }
+        else {
+            throw new Error ( 'redis.subscribe expects a string channel and a callback function' );
+        }
+    }
+    catch ( error ) {
+        console.error ( 'REDIS LIB ERROR [subscribe]', error );
+        throw error;
+    }
+};
+
+/**
+ * Retrieves information and statistics about the Redis server.
+ * @returns {Promise<string>} - A promise that resolves with server information.
+ *
+ * @description This method returns information and various statistics about the Redis server.
+ */
+exports.info = async () => {
+    try {
+        const client = await getClient ();
+
+        return await client.info ();
+    }
+    catch ( error ) {
+        console.error ( 'REDIS LIB ERROR [info]', error );
+        throw error;
+    }
+};
+
+/**
+ * Gracefully closes the Redis connection.
+ * @returns {Promise<void>} - A promise that resolves once the connection is closed.
+ *
+ * @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 () ) );
 };