@ti-engine/core 1.1.5 → 1.1.9

package/integrations/gcloud-integration.js

@@ -1,12 +1,13 @@
 /*
  * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
- * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * Copyright © 2021-2025 Boris Kostadinov <kostadinov.boris@gmail.com>
  * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
 const config = require( "#config" );
+const tools = require( "#tools" );
 
 /**
  * Used to verify if the GCloud integration is enabled.
@@ -16,7 +17,7 @@ const config = require( "#config" );
  * @public
  */
 module.exports.isEnabled = () => {
-    return process.env.TI_GCLOUD_ENABLED === true;
+    return tools.toBool( process.env.TI_GCLOUD_ENABLED );
 };
 
 /**

package/integrations/redis-integration.js

@@ -1,6 +1,6 @@
 /*
  * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
- * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * Copyright © 2021-2025 Boris Kostadinov <kostadinov.boris@gmail.com>
  * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
@@ -20,27 +20,27 @@ const _ = require( "lodash" );
  * @enum {string}
  */
 let cacheCommandsEnum = tools.enum( {
-    ADD_TO_SET: [ "sadd", "add to set", "https://redis.io/commands/sadd" ],
-    DELETE_VALUE: [ "del", "delete value", "https://redis.io/commands/del" ],
-    EXPIRE: [ "expire", "expire", "https://redis.io/commands/expire" ],
-    GET_ALL_FROM_SET: [ "smembers", "get all set members", "https://redis.io/commands/smembers" ],
-    GET_VALUE: [ "get", "get value", "https://redis.io/commands/get" ],
-    HASH_GET: [ "hget", "hash get", "https://redis.io/commands/hget" ],
-    HASH_GET_ALL: [ "hgetall", "hash get all", "https://redis.io/commands/hgetall" ],
-    HASH_REMOVE: [ "hdel", "hash remove", "https://redis.io/commands/hdel" ],
-    HASH_SET: [ "hset", "", "https://redis.io/commands/hset" ],
-    HASH_SET_MANY: [ "hmset", "", "https://redis.io/commands/hmset" ],
-    IS_SET_MEMBER: [ "sismember", "", "https://redis.io/commands/sismember" ],
-    JSON_ARRAY_APPEND: [ "json.arrappend", "", "https://redis.io/commands/json.arrappend" ],
-    JSON_GET: [ "json.get", "", "https://redis.io/commands/json.get" ],
-    JSON_SET: [ "json.set", "", "https://redis.io/commands/json.set" ],
-    KEYS: [ "keys", "", "https://redis.io/commands/keys" ],
-    LIST_PUSH: [ "lpush", "list push", "https://redis.io/commands/lpush" ],
-    LIST_POP_TAIL_BLOCKING: [ "brpop", "list pop tail blocking", "https://redis.io/commands/brpop" ],
-    LIST_POP_TAIL_PUSH_HEAD_BLOCKING: [ "brpoplpush", "list pop tail push head blocking", "https://redis.io/commands/brpoplpush" ],
-    LIST_REMOVE: [ "lrem", "list remove", "https://redis.io/commands/lrem" ],
-    SET_VALUE: [ "set", "set value", "https://redis.io/commands/set" ],
-    UNION_OF_SETS: [ "sunion", "union of sets", "https://redis.io/commands/sunion" ]
+    ADD_TO_SET: [ "sadd", "add to set", "https://redis.io/docs/latest/commands/sadd/" ],
+    DELETE_VALUE: [ "del", "delete value", "https://redis.io/docs/latest/commands/del/" ],
+    EXPIRE: [ "expire", "expire", "https://redis.io/docs/latest/commands/expire/" ],
+    GET_ALL_FROM_SET: [ "smembers", "get all set members", "https://redis.io/docs/latest/commands/smembers/" ],
+    GET_VALUE: [ "get", "get value", "https://redis.io/docs/latest/commands/get/" ],
+    HASH_GET: [ "hget", "hash get", "https://redis.io/docs/latest/commands/hget/" ],
+    HASH_GET_ALL: [ "hgetall", "hash get all", "https://redis.io/docs/latest/commands/hgetall/" ],
+    HASH_REMOVE: [ "hdel", "hash remove", "https://redis.io/docs/latest/commands/hdel/" ],
+    HASH_SET: [ "hset", "", "https://redis.io/docs/latest/commands/hset/" ],
+    HASH_SET_MANY: [ "hmset", "(deprecated) use HSET with multiple fields", "https://redis.io/docs/latest/commands/hmset/" ],
+    IS_SET_MEMBER: [ "sismember", "", "https://redis.io/docs/latest/commands/sismember/" ],
+    JSON_ARRAY_APPEND: [ "json.arrappend", "", "https://redis.io/docs/latest/commands/json.arrappend/" ],
+    JSON_GET: [ "json.get", "", "https://redis.io/docs/latest/commands/json.get/" ],
+    JSON_SET: [ "json.set", "", "https://redis.io/docs/latest/commands/json.set/" ],
+    KEYS: [ "keys", "(warning: O(N), use SCAN where possible)", "https://redis.io/docs/latest/commands/keys/" ],
+    LIST_PUSH: [ "lpush", "list push", "https://redis.io/docs/latest/commands/lpush/" ],
+    LIST_POP_TAIL_BLOCKING: [ "brpop", "list pop tail blocking", "https://redis.io/docs/latest/commands/brpop/" ],
+    LIST_POP_TAIL_PUSH_HEAD_BLOCKING: [ "brpoplpush", "list pop tail push head blocking", "https://redis.io/docs/latest/commands/brpoplpush/" ],
+    LIST_REMOVE: [ "lrem", "list remove", "https://redis.io/docs/latest/commands/lrem/" ],
+    SET_VALUE: [ "set", "set value", "https://redis.io/docs/latest/commands/set/" ],
+    UNION_OF_SETS: [ "sunion", "union of sets", "https://redis.io/docs/latest/commands/sunion/" ]
 } );
 
 /**
@@ -66,6 +66,9 @@ module.exports.cacheOverrideMode = cacheOverrideModeEnum;
 
 /**
  * Used to create a Redis Cache client.
+ * <br/>
+ * NOTE: This client is set to automatically resend all pending commands on connection recovery with no limit on the retry attempts.
+ * This is done to avoid losing any pending commands in case of a connection failure. For a different behavior, use custom implementation.
  *
  * @class RedisClient
  * @public
@@ -79,101 +82,15 @@ class RedisClient {
     #serverInfo = {};
     #serverFeatures = {};
     #connectionObservers = [];
+    #messageHandlersByChannel = new Map();
 
     /**
      * @constructor
      * @param {string} identifier
-     * @param {string} host
-     * @param {number} port
-     * @param {string} authKey
-     * @param {string} user
-     * @param {number} defaultDB
-     * @param {boolean} autoRetryUnfulfilled
-     * @param {number} maxRetries
+     * @returns {RedisClient}
      */
-    constructor( identifier, host, port, authKey, user, defaultDB, autoRetryUnfulfilled, maxRetries ) {
+    constructor( identifier ) {
         this.#clientIdentifier = identifier || "redis-client-" + tools.getUUID();
-
-        let retryStrategy = ( attempt ) => {
-            let result = Math.min( attempt * 50, this.#retryMaxInterval );
-
-            if ( this.#retryMaxAttempts != null && attempt > this.#retryMaxAttempts ) {
-                logger.log( "In Redis retry strategy: reached max attempts for command retry. Aborting...", logger.logSeverity.WARNING, { attempts: attempt } );
-                result = exceptions.raise( exceptions.exceptionCode.E_COM_RETRY_ATTEMPTS_EXCEEDED );
-            }
-
-            return result;
-        };
-
-        let reconnectOnError = ( error ) => {
-            logger.log( `In Redis reconnect on error strategy: ${ error.message }`, logger.logSeverity.ERROR, error );
-            return !!error.message.includes( "READONLY" );
-        };
-
-        let options = {
-            port: port,
-            host: host,
-            username: user,
-            password: authKey,
-            db: defaultDB,
-            autoResendUnfulfilledCommands: autoRetryUnfulfilled,
-            maxRetriesPerRequest: maxRetries,
-            retryStrategy: retryStrategy,
-            reconnectOnError: reconnectOnError
-        };
-
-        /** @type Redis */
-        this.#redisClient = new Redis( options );
-
-        this.#redisClient.on( "ready", () => {
-            logger.log( `Connection to Redis server ${ host }:${ port } (re)established by client '${ this.identifier }' and is ready to be used.`, logger.logSeverity.INFO );
-
-            // notify all connection observers about this event:
-            _.forEach( this.#connectionObservers, ( connectionObservers ) => {
-                connectionObservers.onConnectionRecovered( this.#clientIdentifier );
-            } );
-
-            // fetch the server information and store it:
-            this.#redisClient.info().then( ( result ) => {
-                this.#serverInfo = {};
-                if ( _.isString( result ) ) {
-                    let rawData = _.split( result, "\r\n" );
-                    _.forEach( rawData, ( entry ) => {
-                        let details = _.split( entry, ":" );
-                        if ( !_.startsWith( details[ 0 ], "#" ) && details[ 0 ] !== "" && details[ 0 ] ) {
-                            if ( _.isNaN( _.toNumber( details[ 1 ] ) ) ) {
-                                this.#serverInfo[ details[ 0 ] ] = details[ 1 ];
-                            } else {
-                                this.#serverInfo[ details[ 0 ] ] = _.toNumber( details[ 1 ] );
-                            }
-                        }
-                    } );
-                }
-                return this.#redisClient.module( "LIST" );
-            } ).then( ( result ) => {
-                this.#serverFeatures = {};
-                if ( _.isArray( result ) ) {
-                    _.forEach( result, ( entry ) => {
-                        this.#serverFeatures[ entry[ 1 ] ] = entry[ 3 ];
-                    } );
-                }
-            } ).catch( ( error ) => {
-                logger.log( `Failed to fetch server information by client '${ this.identifier }'!`, logger.logSeverity.WARNING, error );
-            } );
-        } );
-        this.#redisClient.on( "error", ( error ) => {
-            logger.log( `Error received in Redis client '${ this.identifier }'.`, logger.logSeverity.ERROR, error );
-
-            // notify all connection observers about this event:
-            _.forEach( this.#connectionObservers, ( connectionObservers ) => {
-                connectionObservers.onConnectionDisrupted( this.#clientIdentifier );
-            } );
-        } );
-        this.#redisClient.on( "reconnecting", ( info ) => {
-            if ( info.attempt > 1 ) {
-                logger.log( `Client '${ this.identifier }' reconnecting to Redis server after ${ info.delay } ms. This is attempt ${ info.attempt }.`, logger.logSeverity.DEBUG );
-            }
-        } );
     }
 
     /* Public interface */
@@ -182,7 +99,7 @@ class RedisClient {
      * Used to return the Redis client identifier.
      *
      * @property
-     * @return {string}
+     * @returns {string}
      * @public
      */
     get identifier() {
@@ -193,7 +110,7 @@ class RedisClient {
      * Used to return the Redis server version.
      *
      * @property
-     * @return {number}
+     * @returns {number}
      * @public
      */
     get serverVersion() {
@@ -208,7 +125,94 @@ class RedisClient {
      * @public
      */
     get isJSONSupported() {
-        return !_.isNil( this.#serverFeatures[ "ReJSON" ] );
+        // Detect RedisJSON module variants (e.g., ReJSON, ReJSON2):
+        return !_.isNil( this.#serverFeatures[ "ReJSON" ] ) || !_.isNil( this.#serverFeatures[ "ReJSON2" ] );
+    }
+
+    /**
+     * Used to initialize the Redis client.
+     *
+     * @method
+     * @param {string} host
+     * @param {number} port
+     * @param {string} authKey
+     * @param {string} user
+     * @param {number} defaultDB
+     * @param {number} [retryMaxIntervalMs=1000] Optional max backoff interval.
+     * @param {number|undefined} [retryMaxAttempts=undefined] Optional max (re)connection attempts before abort.
+     * @public
+     */
+    initialize( host, port, authKey, user, defaultDB, retryMaxIntervalMs = 1000, retryMaxAttempts = undefined ) {
+        return new Promise( ( resolve, reject ) => {
+            if ( this.#redisClient ) {
+                resolve();
+            } else {
+                try {
+                    this.#retryMaxInterval = retryMaxIntervalMs;
+                    this.#retryMaxAttempts = retryMaxAttempts;
+
+                    let retryStrategy = ( attempt ) => {
+                        let result = Math.min( attempt * 50, this.#retryMaxInterval );
+
+                        if ( this.#retryMaxAttempts != null && attempt > this.#retryMaxAttempts ) {
+                            logger.log( "In Redis retry strategy: reached max attempts for command retry. Aborting...", logger.logSeverity.WARNING, { attempts: attempt } );
+                            result = exceptions.raise( exceptions.exceptionCode.E_COM_RETRY_ATTEMPTS_EXCEEDED );
+                        }
+
+                        return result;
+                    };
+
+                    let reconnectOnError = ( error ) => {
+                        logger.log( `In Redis reconnect on error strategy: ${ error.message }`, logger.logSeverity.ERROR, error );
+                        return !!error.message.includes( "READONLY" );
+                    };
+
+                    let options = {
+                        port: port,
+                        host: host,
+                        username: user,
+                        password: authKey,
+                        db: defaultDB,
+                        autoResendUnfulfilledCommands: true,
+                        maxRetriesPerRequest: null,
+                        retryStrategy: retryStrategy,
+                        reconnectOnError: reconnectOnError
+                    };
+
+                    /** @type Redis */
+                    this.#redisClient = new Redis( options );
+
+                    this.#redisClient.on( "ready", () => {
+                        logger.log( `Connection to Redis server ${ host }:${ port } (re)established by client '${ this.identifier }' and is ready to be used.`, logger.logSeverity.INFO );
+
+                        // Notify all connection observers about this event:
+                        _.forEach( this.#connectionObservers, ( connectionObservers ) => {
+                            connectionObservers.onConnectionRecovered( this.#clientIdentifier );
+                        } );
+
+                        // Fetch the server information and store it:
+                        this.#fetchServerInfo();
+
+                        resolve();
+                    } );
+                    this.#redisClient.on( "error", ( error ) => {
+                        logger.log( `Error received in Redis client '${ this.identifier }'.`, logger.logSeverity.ERROR, error );
+
+                        // Notify all connection observers about this event:
+                        _.forEach( this.#connectionObservers, ( connectionObservers ) => {
+                            connectionObservers.onConnectionDisrupted( this.#clientIdentifier );
+                        } );
+                    } );
+                    this.#redisClient.on( "reconnecting", ( info ) => {
+                        if ( info.attempt > 1 ) {
+                            logger.log( `Client '${ this.identifier }' reconnecting to Redis server after ${ info.delay } ms. This is attempt ${ info.attempt }.`, logger.logSeverity.DEBUG );
+                        }
+                    } );
+                } catch ( error ) {
+                    reject( exceptions.raise( error ) );
+                }
+            }
+        } );
     }
 
     /**
@@ -231,7 +235,7 @@ class RedisClient {
      *
      * @method
      * @param {Array[]} commands
-     * @return {Promise<*>}
+     * @returns {Promise<*>}
      * @public
      */
     executeCommands( commands ) {
@@ -252,7 +256,7 @@ class RedisClient {
      * @method
      * @param {string} command
      * @param {Array} commandArguments
-     * @return {Promise<*>}
+     * @returns {Promise<*>}
      * @public
      */
     blockingCommand( command, commandArguments ) {
@@ -271,7 +275,7 @@ class RedisClient {
      * @method
      * @param {string} channel
      * @param {(Object|string)} message
-     * @return {Promise<number>}
+     * @returns {Promise<number>}
      * @public
      */
     publishCommand( channel, message ) {
@@ -286,25 +290,69 @@ class RedisClient {
 
     /**
      * Used to subscribe to the specified channel for messages.
+     * <br/>
+     * NOTE: Call unsubscribeCommand(channel) to detach later.
      *
      * @method
-     * @param {string} channel
+     * @param {string} channel Unique identifier of the channel to subscribe to.
      * @param {function( Object )} messageHandler Will execute this handler every time a new message is received.
-     * @return {Promise}
+     * @returns {Promise}
      * @public
      */
     subscribeCommand( channel, messageHandler ) {
         return new Promise( ( resolve, reject ) => {
-            this.#redisClient.on( "subscribe", ( channel, count ) => {
-                logger.log( "Subscription to message channel '" + channel + "' successful.", logger.logSeverity.DEBUG );
+            // Avoid attaching multiple listeners for the same channel:
+            if ( this.#messageHandlersByChannel.has( channel ) ) {
+                logger.log( "Attempting to subscribe to message channel '" + channel + "' while already subscribed to it.", logger.logSeverity.WARNING );
                 resolve();
-            } );
-            this.#redisClient.on( "message", ( channel, message ) => {
-                if ( typeof ( messageHandler ) === "function" ) {
-                    messageHandler( tools.parseJSON( message ) );
-                }
-            } );
-            this.#redisClient.subscribe( channel ).catch( ( error ) => {
+            } else {
+                const onMessage = ( subscribedChannel, message ) => {
+                    if ( subscribedChannel === channel && typeof messageHandler === "function" ) {
+                        messageHandler( tools.parseJSON( message ) );
+                    }
+                };
+
+                this.#redisClient.once( "subscribe", ( subscribedChannel ) => {
+                    if ( subscribedChannel === channel ) {
+                        logger.log( "Subscription to message channel '" + channel + "' successful.", logger.logSeverity.DEBUG );
+                        resolve();
+                    }
+                } );
+
+                this.#redisClient.on( "message", onMessage );
+                this.#messageHandlersByChannel.set( channel, onMessage );
+
+                this.#redisClient.subscribe( channel ).catch( ( error ) => {
+                    // Cleanup partial state if subscribe fails:
+                    const handler = this.#messageHandlersByChannel.get( channel );
+                    if ( handler ) {
+                        this.#redisClient.off( "message", handler );
+                        this.#messageHandlersByChannel.delete( channel );
+                    }
+                    reject( exceptions.raise( error ) );
+                } );
+            }
+        } );
+    }
+
+    /**
+     * Used to unsubscribe from a channel and remove its message handler.
+     *
+     * @method
+     * @param {string} channel Unique identifier of the channel to unsubscribe from.
+     * @returns {Promise}
+     * @public
+     */
+    unsubscribeCommand( channel ) {
+        return new Promise( ( resolve, reject ) => {
+            const handler = this.#messageHandlersByChannel.get( channel );
+            if ( handler ) {
+                this.#redisClient.off( "message", handler );
+                this.#messageHandlersByChannel.delete( channel );
+            }
+            this.#redisClient.unsubscribe( channel ).then( () => {
+                resolve();
+            } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );
             } );
         } );
@@ -332,6 +380,84 @@ class RedisClient {
         } );
     }
 
+    /**
+     * Used to gracefully close the Redis connection.
+     * Attempts to quit(), then falls back to disconnect() on timeout.
+     *
+     * @method
+     * @param {number} [timeoutMs=1000]
+     * @returns {Promise<Object>}
+     * @public
+     */
+    shutDown( timeoutMs = 1000 ) {
+        return new Promise( ( resolve ) => {
+            let finished = false;
+            const done = () => {
+                if ( !finished ) {
+                    finished = true;
+                    resolve();
+                }
+            };
+
+            const timeout = setTimeout( () => {
+                try {
+                    this.#redisClient.disconnect();
+                } catch ( error ) {
+                }
+                done();
+            }, timeoutMs );
+
+            this.#redisClient.quit().then( () => {
+                clearTimeout( timeout );
+                done();
+            } ).catch( () => {
+                clearTimeout( timeout );
+                try {
+                    this.#redisClient.disconnect();
+                } catch ( error ) {
+                }
+                done();
+            } );
+        } );
+    }
+
+    /* Private interface */
+
+    /**
+     * Used to fetch and store Redis server information.
+     *
+     * @method
+     * @private
+     */
+    #fetchServerInfo() {
+        this.#redisClient.info().then( ( result ) => {
+            this.#serverInfo = {};
+            if ( _.isString( result ) ) {
+                let rawData = _.split( result, "\r\n" );
+                _.forEach( rawData, ( entry ) => {
+                    let details = _.split( entry, ":" );
+                    if ( !_.startsWith( details[ 0 ], "#" ) && details[ 0 ] !== "" && details[ 0 ] ) {
+                        if ( _.isNaN( _.toNumber( details[ 1 ] ) ) ) {
+                            this.#serverInfo[ details[ 0 ] ] = details[ 1 ];
+                        } else {
+                            this.#serverInfo[ details[ 0 ] ] = _.toNumber( details[ 1 ] );
+                        }
+                    }
+                } );
+            }
+            return this.#redisClient.module( "LIST" );
+        } ).then( ( result ) => {
+            this.#serverFeatures = {};
+            if ( _.isArray( result ) ) {
+                _.forEach( result, ( entry ) => {
+                    this.#serverFeatures[ entry[ 1 ] ] = entry[ 3 ];
+                } );
+            }
+        } ).catch( ( error ) => {
+            logger.log( `Failed to fetch server information by client '${ this.identifier }'!`, logger.logSeverity.WARNING, error );
+        } );
+    }
+
 }
 
 /**
@@ -339,16 +465,9 @@ class RedisClient {
  *
  * @method
  * @param {string} identifier
- * @param {string} host
- * @param {number} [port=6379]
- * @param {string} [authKey=undefined]
- * @param {string} [user="default"]
- * @param {number} [defaultDB=0]
- * @param {boolean} [autoRetryUnfulfilled=true]
- * @param {number} [maxRetries=20]
  * @return {RedisClient}
  * @public
  */
-module.exports.createRedisClient = ( identifier, host, port = 6379, authKey = undefined, user = "default", defaultDB = 0, autoRetryUnfulfilled = true, maxRetries = 20 ) => {
-    return Object.freeze( new RedisClient( identifier, host, port, authKey, user, defaultDB, autoRetryUnfulfilled, maxRetries ) );
-};
+module.exports.createRedisClient = ( identifier ) => {
+    return Object.freeze( new RedisClient( identifier ) );
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ti-engine/core",
-  "version": "1.1.5",
+  "version": "1.1.9",
   "description": "The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.",
   "author": "Boris Kostadinov <kostadinov.boris@gmail.com>",
   "license": "GPL-3.0-or-later",
@@ -44,15 +44,15 @@
   },
   "dependencies": {
     "blake2": "^5.0.0",
-    "dotenv": "^16.3.1",
-    "fs-extra": "^11.2.0",
+    "dotenv": "^17.2.1",
+    "fs-extra": "^11.3.1",
     "lodash": "^4.17.21",
     "node-schedule": "^2.1.1",
-    "ioredis": "^5.3.2"
+    "ioredis": "^5.7.0"
   },
   "optionalDependencies": {
     "@google-cloud/error-reporting": "^3.0.5",
-    "zeromq": "^6.0.0-beta.19"
+    "zeromq": "^6.5.0"
   },
   "repository": {
     "type": "git",
@@ -61,4 +61,4 @@
   "engines": {
     "node": ">=14.17.0"
   }
-}
+}

package/testRedis.js

@@ -0,0 +1,22 @@
+import Redis from "ioredis";
+
+const redisClient = new Redis( {
+    port: 17467,
+    host: "redis-17467.c300.eu-central-1-1.ec2.redns.redis-cloud.com",
+    username: "default",
+    password: "o49Iyj2JYnmD7NSFWa32x2iYqulWkIM1",
+    db: 0,
+    autoResendUnfulfilledCommands: true,
+    maxRetriesPerRequest: null,
+    retryStrategy: ( attempt ) => {
+        let result = Math.min( attempt * 50, 1000 );
+    }
+});
+
+redisClient.on('error', err => console.log('Redis Client Error', err));
+
+//await redisClient.connect();
+
+await redisClient.set('foo', 'bar');
+const result = await redisClient.get('foo');
+console.log(result);