eip-cloud-services 1.0.17 → 1.1.0

package/CHANGELOG.md

@@ -1,7 +1,36 @@
+
 # Changelog
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.0] - 2023-11-18
+
+### Changed
+- **Redis Module Major Overhaul:**
+  - Transitioned from using the node redis package to the ioredis package.
+  - Updated the `getClient` method to support Redis clusters, including handling of client connections in subscriber mode.
+  - Implemented a dictionary of connected clients for efficient client management in Redis.
+  - Added new functionalities to the Redis module, including handling for various Redis commands and pub/sub features.
+  - Enriched the module with JSDoc comments for better clarity and documentation.
+  - Created a comprehensive README for the Redis module, detailing its features and usage.
+
+### Added
+- **AWS S3 Module Developments:**
+  - Reviewed and discussed functionalities of the AWS S3 module.
+  - Created a README file for the AWS S3 module, detailing usage and configuration.
+- **CDN Module Improvements:**
+  - Analyzed functionalities of the CDN module.
+  - Generated a README for the CDN module, including instructions on usage and examples.
+- **MySQL Module Update:**
+  - Discussed the MySQL module's features and capabilities.
+  - Compiled a README for the MySQL module, outlining key functionalities and configuration.
+- **AWS Lambda Module Revision:**
+  - Explored the AWS Lambda module's functionalities.
+  - Prepared a README for the AWS Lambda module, providing usage examples and details.
+- **Overall Module Documentation:**
+  - Combined individual READMEs into a single comprehensive README file.
+  - Added a summary, installation and import guide, and example configuration to the combined README.
+
 ## [1.0.21] - 2023-06-21
 
 ### Fixed

package/README.md

@@ -0,0 +1,386 @@
+# EIP Cloud Services Module
+
+## Summary
+
+The EIP Cloud Services Module is a comprehensive Node.js package that provides seamless integration with various cloud services, including Redis, AWS S3, CDN, AWS Lambda, and MySQL. This module is designed to simplify the complexities of interacting with these cloud services, offering a range of functionalities from data caching and storage to content delivery and serverless computing.
+
+## Installation and Import
+
+To use this module, first install it in your Node.js project. Then, import the required services as follows:
+
+```javascript
+const { redis, cdn, mysql } = require('eip-cloud-services');
+```
+
+## Config Example
+
+Here is an example configuration for the EIP Cloud Services Module. Replace the placeholder values with your actual configuration details.
+
+```javascript
+const packageJson = require('../package.json');
+
+module.exports = {
+    cdn: {
+        ['cdnName']: { // e.g. "myCdn"
+            ['envName1']: { //e.g. "production"
+                type: 'google',
+                urlMapName: 'YOUR_GCP_URL_MAP_NAME',
+                projectId: 'YOUR_GCP_PROJECT_NAME',
+            },
+            ['envName2']: { // e.g. "staging"
+                type: 'amazon',
+                distributionId: 'YOUR_DISTRIBUTION_ID',
+            }
+        },
+    },
+    redis: { // For regular redis connections
+        port: 'YOUR_REDIS_PORT',
+        host: 'YOUR_REDIS_HOST',
+        prefix: 'YOUR_REDIS_PREFIX',
+    },
+    redis: { // For redis cluster instances
+        prefix: 'YOUR_REDIS_PREFIX',
+        clusterEnabled: true,
+        cluster: [
+            {
+                port: 'YOUR_REDIS_PORT',
+                host: 'YOUR_REDIS_HOST',
+            },
+            {
+                port: 'YOUR_REDIS_PORT_2',
+                host: 'YOUR_REDIS_HOST_2',
+            },
+            ...
+        ]
+    },
+    s3: {
+        Bucket: 'YOUR_S3_BUCKET',
+        logs: "verbose", // "verbose" or "outputs", any other value will not log. verbose will log all activity. outputs will only log when there is a file updated.
+        logsFunction: ( message ) => { ... } // Optional, if nothing is provided console.log will be used.
+    },
+    mysql: {
+        connectionLimit: 10, // Max connections
+        host: 'my-database.domain.com',
+        user: 'user',
+        password: 'password',
+        database: 'my-database', // defaults to undefined
+        multipleStatements: false // defaults to true if not set
+    }
+};
+```
+
+## Table of Contents
+
+1. [Redis Module](#redis-module)
+2. [AWS S3 Module](#aws-s3-module)
+3. [CDN Module](#cdn-module)
+4. [MySQL Module](#mysql-module)
+5. [AWS Lambda Module](#aws-lambda-module)
+
+# AWS Lambda Module
+
+## Overview
+
+This module provides an interface for invoking AWS Lambda functions. It simplifies the process of triggering Lambda functions from your Node.js application, with support for both synchronous and asynchronous invocations.
+
+## Installation
+
+Ensure this module is included in your Node.js project. Import the Lambda component as follows:
+
+```javascript
+const lambda = require('eip-cloud-services/lambda');
+```
+
+## Usage
+
+### Invoking a Lambda Function
+
+You can invoke a Lambda function by specifying the function name and the event payload. The module supports both waiting for the function execution to complete and fire-and-forget invocations.
+
+#### Synchronous Invocation (Wait for Execution to start)
+
+```javascript
+const response = await lambda.invokeLambda('yourFunctionName', { key: 'value' }, true);
+console.log(response);
+```
+
+#### Asynchronous Invocation (Fire-and-Forget)
+
+```javascript
+await lambda.invokeLambda('yourFunctionName', { key: 'value' }, false);
+```
+
+### Parameters
+
+- `functionName`: The name of the Lambda function to invoke.
+- `eventPayload`: The payload to pass to the function. This can be any valid JSON object.
+- `waitForExecution` (optional): Set to `true` to wait for the execution to start and receive a response.
+- `context` (optional): The client context for the function execution.
+- `invocationType` (optional): Defaults to 'Event'. Can be set to 'RequestResponse' for synchronous execution.
+- `logType` (optional): The type of logging for the function.
+
+## Configuration
+
+Configure the module with your AWS credentials and Lambda settings.
+
+## Error Handling
+
+The module includes error handling to manage issues related to Lambda invocation, such as network errors or configuration problems.
+
+## Logging
+
+Logging is provided to track the start and completion of Lambda invocations, aiding in debugging and monitoring.
+
+# MySQL Module
+
+## Overview
+
+This MySQL module provides a simple and efficient interface for interacting with MySQL databases. It includes functionalities to manage database connections, execute queries, and handle connection pooling.
+
+## Installation
+
+Ensure this module is included in your Node.js project. Import the MySQL component as follows:
+
+```javascript
+const mysql = require('eip-cloud-services/mysql');
+```
+
+## Usage
+
+### Executing Queries
+
+You can execute queries using the `query` method. This method automatically handles connections and releases them after query execution.
+
+```javascript
+const results = await mysql.query('SELECT * FROM your_table');
+console.log(results);
+```
+
+### Manually Managing Database Connections
+
+It's not required for you to get connections manually, you can use the methods directly without having to setup connections. Getting a connection should only be used if you need to parse the connection to a third party module for example.
+
+#### Get a Connection Pool
+
+```javascript
+const pool = mysql.getPool();
+```
+
+#### Get a Single Connection
+
+```javascript
+const connection = await mysql.getConnection();
+```
+
+
+### Closing the Connection Pool
+
+To gracefully close all connections in the pool:
+
+```javascript
+await mysql.kill();
+```
+
+## Configuration
+
+Configure your MySQL connection settings (like host, user, password, etc.) in the `config` directory.
+
+## Error Handling
+
+The module is designed to handle errors gracefully, providing clear error messages for database connection issues and query errors.
+
+## Pooling
+
+- The module uses connection pooling for efficient database interaction.
+- The pool is automatically created and managed by the module.
+
+
+# CDN Module
+
+## Overview
+
+This module provides functionalities to manage and interact with Content Delivery Networks (CDNs) like Amazon CloudFront and Google Cloud CDN. It includes features for creating invalidations, thereby ensuring that the latest content is served to end-users.
+
+## Installation
+
+Ensure this module is included in your Node.js project. Import the CDN component as follows:
+
+```javascript
+const cdn = require('eip-cloud-services/cdn');
+```
+
+## Usage
+
+### Create a CDN Invalidation
+
+To invalidate cached content in a CDN, use the `createInvalidation` method. This method supports invalidating content in both Amazon CloudFront and Google Cloud CDN.
+
+#### Invalidate in Amazon CloudFront
+
+```javascript
+await cdn.createInvalidation('amazon', 'path/to/your/file.jpg', 'production');
+```
+
+#### Invalidate in Google Cloud CDN
+
+```javascript
+await cdn.createInvalidation('google', 'path/to/your/file.jpg', 'production');
+```
+
+You can also invalidate multiple paths by passing an array of keys:
+
+```javascript
+await cdn.createInvalidation('amazon', ['file1.jpg', 'file2.jpg'], 'staging');
+```
+
+## Configuration
+
+Configure the module with your CDN settings in the `config` directory. The configuration should include details like project ID, distribution ID, and URL map names for the respective CDNs.
+
+## Error Handling
+
+The module is equipped to handle errors gracefully, including validation of input parameters and handling CDN-specific errors.
+
+## Advanced Features
+
+- Supports both Amazon CloudFront and Google Cloud CDN.
+- Validates the key argument to ensure proper formatting.
+- Constructs invalidation paths based on the provided keys.
+- Initializes Google Auth if Google CDN is used.
+- Sends invalidation commands to the CDN client based on the type of CDN and environment.
+
+
+# AWS S3 Module
+
+## Overview
+
+This module provides an interface for interacting with AWS S3, offering functionalities like object retrieval, storage, deletion, and more. It supports advanced features such as encryption and cache control directives, making it a versatile tool for managing S3 operations efficiently.
+
+## Installation
+
+Ensure this module is included in your Node.js project. Import the S3 component as follows:
+
+```javascript
+const s3 = require('eip-cloud-services/s3');
+```
+
+## Usage
+
+### Check if an Object Exists
+
+```javascript
+const exists = await s3.exists('myObjectKey');
+console.log(exists); // true if exists, false otherwise
+```
+
+### Retrieve an Object
+
+```javascript
+const object = await s3.get('myObjectKey');
+console.log(object);
+```
+
+### Store an Object
+
+```javascript
+await s3.set('myObjectKey', 'myObjectData', { /* options */ });
+```
+
+### Delete an Object
+
+```javascript
+await s3.del('myObjectKey');
+```
+
+### Copy an Object
+
+```javascript
+await s3.copy('sourceObjectKey', 'destinationObjectKey');
+```
+
+### Move an Object
+
+```javascript
+await s3.move('sourceObjectKey', 'destinationObjectKey');
+```
+
+### Managing Cache-Control and Encryption
+
+The module provides detailed control over cache behavior and supports encryption for stored objects, allowing you to optimize performance and security.
+
+## Configuration
+
+Configure the module with your AWS credentials and preferred settings in the `config` directory.
+
+## Error Handling
+
+The module includes comprehensive error handling, ensuring robust interaction with AWS S3 even in complex scenarios.
+
+
+
+# Redis Module
+
+## Overview
+
+This Redis module provides a robust interface for interacting with Redis, supporting both standard Redis operations and advanced features like Redis Clusters. The module is designed to manage multiple Redis client instances efficiently, allowing seamless operation with different Redis configurations.
+
+## Installation
+
+To use this Redis module, first ensure that it is included in your Node.js project. You can import the module as follows:
+
+```javascript
+const redis = require('eip-cloud-services/redis');
+```
+
+## Usage
+
+### Standard Redis Operations
+
+You can perform standard Redis operations like setting, getting, deleting keys, etc. Here are some examples:
+
+#### Set a Key
+
+```javascript
+await redis.set('myKey', 'myValue');
+```
+
+#### Get a Key
+
+```javascript
+const value = await redis.get('myKey');
+console.log(value); // Outputs: myValue
+```
+
+#### Delete a Key
+
+```javascript
+await redis.del('myKey');
+```
+
+### Advanced Operations
+
+#### Using Redis Cluster
+
+If your Redis setup includes a cluster, the module automatically configures the client for cluster operations based on your configuration.
+
+#### Subscribing to a Channel
+
+```javascript
+redis.subscribe('myChannel', (message) => {
+  console.log(`Received: ${message}`);
+});
+```
+
+#### Publishing to a Channel
+
+```javascript
+await redis.publish('myChannel', 'Hello, World!');
+```
+
+### Managing Redis Clients
+
+The module internally manages multiple Redis clients for different purposes (like separate clients for pub/sub). However, this is abstracted away from the standard use of the module.
+
+## Error Handling
+
+The module is designed to gracefully handle Redis errors, including connection issues and cluster errors.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.0.17",
+  "version": "1.1.0",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {
@@ -19,6 +19,7 @@
     "@aws-sdk/client-secrets-manager": "^3.354.0",
     "config": "^3.3.9",
     "google-auth-library": "^8.8.0",
+    "ioredis": "^5.3.2",
     "mysql": "^2.18.1",
     "redis": "^4.6.7"
   }

package/src/mysql.js

@@ -16,7 +16,7 @@ function getPool () {
             user: config.mysql.user,
             password: config.mysql.password,
             database: config.mysql.database || undefined,
-            multipleStatements: true
+            multipleStatements: config.mysql.multipleStatements || true
         } );
     }
     

package/src/redis.js

@@ -1,32 +1,110 @@
-const redis = require ( 'redis' );
+// Replace the redis require with ioredis
+const Redis = require ( 'ioredis' );
 const fs = require ( 'fs' );
 let config = {};
-const configDirPath = `${ process.cwd ()}/config`;
+const configDirPath = `${process.cwd ()}/config`;
 if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirectory () ) {
     config = require ( 'config' ); // require the config directory if it exists
 }
-let redisClient;
 
-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;
     }
 };
 
-exports.getClient = getClient ();
+/**
+ * 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.
@@ -41,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}` );
@@ -73,13 +150,12 @@ exports.scan = async ( cursor, matchPattern = '*', count = 100 ) => {
     try {
         const client = await getClient ();
 
-        const commandArgs = [
-            String ( cursor ),
-            'MATCH', matchPattern.startsWith ( config?.redis?.prefix ) ? matchPattern : config?.redis?.prefix + matchPattern,
-            'COUNT', String ( count ),
-        ];
+        const fullMatchPattern = matchPattern.startsWith ( config?.redis?.prefix ) ? matchPattern : config?.redis?.prefix + matchPattern;
 
-        return await client.sendCommand ( [ 'SCAN', ...commandArgs ] );
+        // 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 );
@@ -101,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 );
@@ -137,9 +212,10 @@ exports.multiGet = async ( keys ) => {
         if ( Array.isArray ( keys ) ) {
             const client = await getClient ();
 
-            const commandArgs = keys.map ( key => key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key );
+            const fullKeys = keys.map ( key => key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key );
 
-            const data = await client.sendCommand ( [ 'MGET', ...commandArgs ] );
+            // Use the mget method directly
+            const data = await client.mget ( ...fullKeys );
 
             return data.map ( val => {
                 try {
@@ -176,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}` );
@@ -209,11 +282,10 @@ 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}` );
@@ -224,11 +296,42 @@ exports.del = async ( key ) => {
     }
 };
 
+/**
+ * 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;
+    }
+};
+
 /**
  * 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.
@@ -240,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}` );
@@ -260,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.
@@ -271,12 +373,11 @@ 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}` );
@@ -290,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.
@@ -300,11 +401,10 @@ 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}` );
@@ -318,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.
@@ -330,21 +430,20 @@ 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 ) {
@@ -357,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.
@@ -369,21 +468,11 @@ 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,
-            ];
+            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.listUnshift expects a string or an array of strings as the values, instead the type provided was: ${typeof 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}` );
@@ -398,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.
@@ -410,21 +499,11 @@ 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,
-            ];
-
-            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}` );
-            }
+            const fullKey = key.startsWith ( config?.redis?.prefix ) ? key : config?.redis?.prefix + key;
+            const valuesArray = Array.isArray ( values ) ? values : [ 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}` );
@@ -438,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.
@@ -451,12 +530,10 @@ 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}` );
@@ -467,12 +544,37 @@ exports.listPop = async ( key, count = 1 ) => {
     }
 };
 
+/**
+ * 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;
+    }
+};
+
 /**
  * Retrieves a range of elements from a list.
  * @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.
@@ -484,13 +586,10 @@ 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}` );
@@ -504,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.
@@ -516,11 +615,10 @@ 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}` );
@@ -535,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.
@@ -546,12 +644,10 @@ 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}` );
@@ -562,9 +658,86 @@ exports.setExpiry = async ( key, seconds = 0 ) => {
     }
 };
 
-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 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` );
 
-    return;
+            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 () ) );
 };