@splitsoftware/splitio-commons 2.11.0 → 2.11.1-rc.0

package/CHANGES.txt

@@ -1,3 +1,6 @@
+2.12.0 (February 20, 2026)
+ - Add support for ioredis v5
+
 2.11.0 (January 28, 2026)
  - Added functionality to provide metadata alongside SDK update and READY events. Read more in our docs.
 

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -30,7 +30,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         return pipeline.exec()
             .then(function (data) {
             // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
-            if (data.length && data.length === keys.length) {
+            if (data && data.length && data.length === keys.length) {
                 return _this.redis.expire(_this.key, constants_1.TTL_REFRESH);
             }
         })

package/cjs/storages/inRedis/ImpressionsCacheInRedis.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionsCacheInRedis = void 0;
+var tslib_1 = require("tslib");
 var utils_1 = require("../utils");
 var IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 var ImpressionsCacheInRedis = /** @class */ (function () {
@@ -11,8 +12,9 @@ var ImpressionsCacheInRedis = /** @class */ (function () {
         this.metadata = metadata;
     }
     ImpressionsCacheInRedis.prototype.track = function (impressions) {
+        var _a;
         var _this = this;
-        return this.redis.rpush(this.key, (0, utils_1.impressionsToJSON)(impressions, this.metadata)).then(function (queuedCount) {
+        return (_a = this.redis).rpush.apply(_a, (0, tslib_1.__spreadArray)([this.key], (0, utils_1.impressionsToJSON)(impressions, this.metadata), false)).then(function (queuedCount) {
             // If this is the creation of the key on Redis, set the expiration for it in 1hr.
             if (queuedCount === impressions.length) {
                 return _this.redis.expire(_this.key, IMPRESSIONS_TTL_REFRESH);

package/cjs/storages/inRedis/RedisAdapter.js

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisAdapter = void 0;
 var tslib_1 = require("tslib");
-var ioredis_1 = (0, tslib_1.__importDefault)(require("ioredis"));
+// Dynamically require ioredis to prevent strict TypeScript binding
+// and handle module export differences between v4 and v5.
+var RedisConstructor;
+try {
+    var ioredisLib = require('ioredis');
+    RedisConstructor = ioredisLib.default || ioredisLib;
+}
+catch (e) {
+    // If we reach here, the peer dependency is missing
+    throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+}
 var lang_1 = require("../../utils/lang");
 var thenable_1 = require("../../utils/promise/thenable");
 var timeout_1 = require("../../utils/promise/timeout");
@@ -20,31 +30,49 @@ var DEFAULT_OPTIONS = {
 var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false
+    lazyConnect: false,
+    // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
+    // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+    slotsRefreshInterval: 5000,
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
+ * Refactored to use Composition and Proxy instead of Inheritance to support both v4 and v5.
  */
-var RedisAdapter = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(RedisAdapter, _super);
+var RedisAdapter = /** @class */ (function () {
     function RedisAdapter(log, storageSettings) {
         if (storageSettings === void 0) { storageSettings = {}; }
-        var _this = this;
         var options = RedisAdapter._defineOptions(storageSettings);
-        // Call the ioredis constructor
-        _this = _super.apply(this, RedisAdapter._defineLibrarySettings(options)) || this;
-        _this.log = log;
-        _this._options = options;
-        _this._notReadyCommandsQueue = [];
-        _this._runningCommands = new Set();
-        _this._listenToEvents();
-        _this._setTimeoutWrappers();
-        _this._setDisconnectWrapper();
-        return _this;
+        this.log = log;
+        this._options = options;
+        this._notReadyCommandsQueue = [];
+        this._runningCommands = new Set();
+        // Instantiate the client using the dynamic constructor
+        var librarySettings = RedisAdapter._defineLibrarySettings(options);
+        this.client = new (RedisConstructor.bind.apply(RedisConstructor, (0, tslib_1.__spreadArray)([void 0], librarySettings, false)))();
+        this._listenToEvents();
+        this._setTimeoutWrappers();
+        this._setDisconnectWrapper();
+        // Return a Proxy. This allows the adapter to act exactly like an extended class.
+        // If a method/property is accessed that we didn't explicitly wrap, it forwards it to `this.client`.
+        return new Proxy(this, {
+            get: function (target, prop) {
+                // If the property exists on our wrapper (like wrapped 'get', 'set', or internal methods)
+                if (prop in target) {
+                    return target[prop];
+                }
+                // If it doesn't exist on our wrapper but exists on the real client (like 'on', 'quit')
+                if (target.client && prop in target.client) {
+                    var val = target.client[prop];
+                    return typeof val === 'function' ? val.bind(target.client) : val;
+                }
+                return undefined;
+            }
+        });
     }
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
-        this.once('ready', function () {
+        this.client.once('ready', function () {
             var commandsCount = _this._notReadyCommandsQueue ? _this._notReadyCommandsQueue.length : 0;
             _this.log.info(LOG_PREFIX + ("Redis connection established. Queued commands: " + commandsCount + "."));
             _this._notReadyCommandsQueue && _this._notReadyCommandsQueue.forEach(function (queued) {
@@ -54,21 +82,24 @@ var RedisAdapter = /** @class */ (function (_super) {
             // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
             _this._notReadyCommandsQueue = undefined;
         });
-        this.once('close', function () {
+        this.client.once('close', function () {
             _this.log.info(LOG_PREFIX + 'Redis connection closed.');
         });
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
+        var _this = this;
         var instance = this;
-        var wrapCommand = function (originalMethod, methodName) {
-            // The value of "this" in this function should be the instance actually executing the method. It might be the instance referred (the base one)
-            // or it can be the instance of a Pipeline object.
+        // We pass `bindTarget` so pipeline execution is bound to the pipeline object,
+        // while standard commands are bound to the client.
+        var wrapCommand = function (originalMethod, methodName, bindTarget) {
             return function () {
-                var params = arguments;
-                var caller = this;
+                var params = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    params[_i] = arguments[_i];
+                }
                 function commandWrapper() {
                     instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
-                    var result = originalMethod.apply(caller, params);
+                    var result = originalMethod.apply(bindTarget, params);
                     if ((0, thenable_1.thenable)(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
                         // On sync commands there's no need, only thenables.
@@ -103,25 +134,29 @@ var RedisAdapter = /** @class */ (function (_super) {
         };
         // Wrap regular async methods to track timeouts and queue when Redis is not yet executing commands.
         METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
-            var originalFn = instance[methodName];
-            instance[methodName] = wrapCommand(originalFn, methodName);
+            var originalFn = _this.client[methodName];
+            _this[methodName] = wrapCommand(originalFn, methodName, _this.client);
         });
         // Special handling for pipeline~like methods. We need to wrap the async trigger, which is exec, but return the Pipeline right away.
         METHODS_TO_PROMISE_WRAP_EXEC.forEach(function (methodName) {
-            var originalFn = instance[methodName];
+            var originalFn = _this.client[methodName];
             // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
-            instance[methodName] = function () {
-                var res = originalFn.apply(instance, arguments);
+            _this[methodName] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var res = originalFn.apply(instance.client, args);
                 var originalExec = res.exec;
-                res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+                res.exec = wrapCommand(originalExec, methodName + ".exec", res);
                 return res;
             };
         });
     };
     RedisAdapter.prototype._setDisconnectWrapper = function () {
         var instance = this;
-        var originalMethod = instance.disconnect;
-        instance.disconnect = function disconnect() {
+        var originalMethod = this.client.disconnect;
+        this.disconnect = function disconnect() {
             var params = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 params[_i] = arguments[_i];
@@ -132,17 +167,17 @@ var RedisAdapter = /** @class */ (function (_super) {
                     Promise.all((0, sets_1.setToArray)(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
-                        originalMethod.apply(instance, params);
+                        originalMethod.apply(instance.client, params);
                     })
                         .catch(function (e) {
                         instance.log.warn(LOG_PREFIX + ("Pending commands finished with error: " + e + ". Proceeding with disconnection."));
-                        originalMethod.apply(instance, params);
+                        originalMethod.apply(instance.client, params);
                     });
                 }
                 else {
                     instance.log.debug(LOG_PREFIX + 'No commands pending execution, disconnect.');
                     // Nothing pending, just proceed.
-                    originalMethod.apply(instance, params);
+                    originalMethod.apply(instance.client, params);
                 }
             }, 10);
         };
@@ -191,5 +226,5 @@ var RedisAdapter = /** @class */ (function (_super) {
         return (0, lang_1.merge)({}, DEFAULT_OPTIONS, parsedOptions);
     };
     return RedisAdapter;
-}(ioredis_1.default));
+}());
 exports.RedisAdapter = RedisAdapter;

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -10,11 +10,11 @@ var sets_1 = require("../../utils/lang/sets");
  * Discard errors for an answer of multiple operations.
  */
 function processPipelineAnswer(results) {
-    return results.reduce(function (accum, errValuePair) {
+    return results ? results.reduce(function (accum, errValuePair) {
         if (errValuePair[0] === null)
             accum.push(errValuePair[1]);
         return accum;
-    }, []);
+    }, []) : [];
 }
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -175,12 +175,12 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
         return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
-            .then(function (results) { return results.map(function (_a, index) {
+            .then(function (results) { return results ? results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
                 return value;
             _this.log.error(constants_1.LOG_PREFIX + ("Could not read result from get members of flag set " + flagSets[index] + " due to an error: " + e));
-        }); })
+        }) : []; })
             .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -20,6 +20,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         return _this;
     }
     UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
+        var _a;
         var _this = this;
         var featureNames = Object.keys(this.uniqueKeysTracker);
         if (!featureNames.length)
@@ -33,8 +34,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
             return JSON.stringify(uniqueKeysPayload);
         });
         this.clear();
-        return this.redis.rpush(this.key, uniqueKeysArray)
-            .then(function (data) {
+        return (_a = this.redis).rpush.apply(_a, (0, tslib_1.__spreadArray)([this.key], uniqueKeysArray, false)).then(function (data) {
             // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
             if (data === featureNames.length) {
                 return _this.redis.expire(_this.key, constants_1.TTL_REFRESH);

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -27,7 +27,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         return pipeline.exec()
             .then(function (data) {
             // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
-            if (data.length && data.length === keys.length) {
+            if (data && data.length && data.length === keys.length) {
                 return _this.redis.expire(_this.key, TTL_REFRESH);
             }
         })

package/esm/storages/inRedis/ImpressionsCacheInRedis.js

@@ -1,3 +1,4 @@
+import { __spreadArray } from "tslib";
 import { impressionsToJSON } from '../utils';
 var IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 var ImpressionsCacheInRedis = /** @class */ (function () {
@@ -8,8 +9,9 @@ var ImpressionsCacheInRedis = /** @class */ (function () {
         this.metadata = metadata;
     }
     ImpressionsCacheInRedis.prototype.track = function (impressions) {
+        var _a;
         var _this = this;
-        return this.redis.rpush(this.key, impressionsToJSON(impressions, this.metadata)).then(function (queuedCount) {
+        return (_a = this.redis).rpush.apply(_a, __spreadArray([this.key], impressionsToJSON(impressions, this.metadata), false)).then(function (queuedCount) {
             // If this is the creation of the key on Redis, set the expiration for it in 1hr.
             if (queuedCount === impressions.length) {
                 return _this.redis.expire(_this.key, IMPRESSIONS_TTL_REFRESH);

package/esm/storages/inRedis/RedisAdapter.js

@@ -1,5 +1,15 @@
-import { __extends } from "tslib";
-import ioredis from 'ioredis';
+import { __spreadArray } from "tslib";
+// Dynamically require ioredis to prevent strict TypeScript binding
+// and handle module export differences between v4 and v5.
+var RedisConstructor;
+try {
+    var ioredisLib = require('ioredis');
+    RedisConstructor = ioredisLib.default || ioredisLib;
+}
+catch (e) {
+    // If we reach here, the peer dependency is missing
+    throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+}
 import { merge, isString } from '../../utils/lang';
 import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
@@ -17,31 +27,49 @@ var DEFAULT_OPTIONS = {
 var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false
+    lazyConnect: false,
+    // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
+    // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+    slotsRefreshInterval: 5000,
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
+ * Refactored to use Composition and Proxy instead of Inheritance to support both v4 and v5.
  */
-var RedisAdapter = /** @class */ (function (_super) {
-    __extends(RedisAdapter, _super);
+var RedisAdapter = /** @class */ (function () {
     function RedisAdapter(log, storageSettings) {
         if (storageSettings === void 0) { storageSettings = {}; }
-        var _this = this;
         var options = RedisAdapter._defineOptions(storageSettings);
-        // Call the ioredis constructor
-        _this = _super.apply(this, RedisAdapter._defineLibrarySettings(options)) || this;
-        _this.log = log;
-        _this._options = options;
-        _this._notReadyCommandsQueue = [];
-        _this._runningCommands = new Set();
-        _this._listenToEvents();
-        _this._setTimeoutWrappers();
-        _this._setDisconnectWrapper();
-        return _this;
+        this.log = log;
+        this._options = options;
+        this._notReadyCommandsQueue = [];
+        this._runningCommands = new Set();
+        // Instantiate the client using the dynamic constructor
+        var librarySettings = RedisAdapter._defineLibrarySettings(options);
+        this.client = new (RedisConstructor.bind.apply(RedisConstructor, __spreadArray([void 0], librarySettings, false)))();
+        this._listenToEvents();
+        this._setTimeoutWrappers();
+        this._setDisconnectWrapper();
+        // Return a Proxy. This allows the adapter to act exactly like an extended class.
+        // If a method/property is accessed that we didn't explicitly wrap, it forwards it to `this.client`.
+        return new Proxy(this, {
+            get: function (target, prop) {
+                // If the property exists on our wrapper (like wrapped 'get', 'set', or internal methods)
+                if (prop in target) {
+                    return target[prop];
+                }
+                // If it doesn't exist on our wrapper but exists on the real client (like 'on', 'quit')
+                if (target.client && prop in target.client) {
+                    var val = target.client[prop];
+                    return typeof val === 'function' ? val.bind(target.client) : val;
+                }
+                return undefined;
+            }
+        });
     }
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
-        this.once('ready', function () {
+        this.client.once('ready', function () {
             var commandsCount = _this._notReadyCommandsQueue ? _this._notReadyCommandsQueue.length : 0;
             _this.log.info(LOG_PREFIX + ("Redis connection established. Queued commands: " + commandsCount + "."));
             _this._notReadyCommandsQueue && _this._notReadyCommandsQueue.forEach(function (queued) {
@@ -51,21 +79,24 @@ var RedisAdapter = /** @class */ (function (_super) {
             // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
             _this._notReadyCommandsQueue = undefined;
         });
-        this.once('close', function () {
+        this.client.once('close', function () {
             _this.log.info(LOG_PREFIX + 'Redis connection closed.');
         });
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
+        var _this = this;
         var instance = this;
-        var wrapCommand = function (originalMethod, methodName) {
-            // The value of "this" in this function should be the instance actually executing the method. It might be the instance referred (the base one)
-            // or it can be the instance of a Pipeline object.
+        // We pass `bindTarget` so pipeline execution is bound to the pipeline object,
+        // while standard commands are bound to the client.
+        var wrapCommand = function (originalMethod, methodName, bindTarget) {
             return function () {
-                var params = arguments;
-                var caller = this;
+                var params = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    params[_i] = arguments[_i];
+                }
                 function commandWrapper() {
                     instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
-                    var result = originalMethod.apply(caller, params);
+                    var result = originalMethod.apply(bindTarget, params);
                     if (thenable(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
                         // On sync commands there's no need, only thenables.
@@ -100,25 +131,29 @@ var RedisAdapter = /** @class */ (function (_super) {
         };
         // Wrap regular async methods to track timeouts and queue when Redis is not yet executing commands.
         METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
-            var originalFn = instance[methodName];
-            instance[methodName] = wrapCommand(originalFn, methodName);
+            var originalFn = _this.client[methodName];
+            _this[methodName] = wrapCommand(originalFn, methodName, _this.client);
         });
         // Special handling for pipeline~like methods. We need to wrap the async trigger, which is exec, but return the Pipeline right away.
         METHODS_TO_PROMISE_WRAP_EXEC.forEach(function (methodName) {
-            var originalFn = instance[methodName];
+            var originalFn = _this.client[methodName];
             // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
-            instance[methodName] = function () {
-                var res = originalFn.apply(instance, arguments);
+            _this[methodName] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var res = originalFn.apply(instance.client, args);
                 var originalExec = res.exec;
-                res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+                res.exec = wrapCommand(originalExec, methodName + ".exec", res);
                 return res;
             };
         });
     };
     RedisAdapter.prototype._setDisconnectWrapper = function () {
         var instance = this;
-        var originalMethod = instance.disconnect;
-        instance.disconnect = function disconnect() {
+        var originalMethod = this.client.disconnect;
+        this.disconnect = function disconnect() {
             var params = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 params[_i] = arguments[_i];
@@ -129,17 +164,17 @@ var RedisAdapter = /** @class */ (function (_super) {
                     Promise.all(setToArray(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
-                        originalMethod.apply(instance, params);
+                        originalMethod.apply(instance.client, params);
                     })
                         .catch(function (e) {
                         instance.log.warn(LOG_PREFIX + ("Pending commands finished with error: " + e + ". Proceeding with disconnection."));
-                        originalMethod.apply(instance, params);
+                        originalMethod.apply(instance.client, params);
                     });
                 }
                 else {
                     instance.log.debug(LOG_PREFIX + 'No commands pending execution, disconnect.');
                     // Nothing pending, just proceed.
-                    originalMethod.apply(instance, params);
+                    originalMethod.apply(instance.client, params);
                 }
             }, 10);
         };
@@ -188,5 +223,5 @@ var RedisAdapter = /** @class */ (function (_super) {
         return merge({}, DEFAULT_OPTIONS, parsedOptions);
     };
     return RedisAdapter;
-}(ioredis));
+}());
 export { RedisAdapter };

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -7,11 +7,11 @@ import { returnDifference } from '../../utils/lang/sets';
  * Discard errors for an answer of multiple operations.
  */
 function processPipelineAnswer(results) {
-    return results.reduce(function (accum, errValuePair) {
+    return results ? results.reduce(function (accum, errValuePair) {
         if (errValuePair[0] === null)
             accum.push(errValuePair[1]);
         return accum;
-    }, []);
+    }, []) : [];
 }
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -172,12 +172,12 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
         return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
-            .then(function (results) { return results.map(function (_a, index) {
+            .then(function (results) { return results ? results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
                 return value;
             _this.log.error(LOG_PREFIX + ("Could not read result from get members of flag set " + flagSets[index] + " due to an error: " + e));
-        }); })
+        }) : []; })
             .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -1,4 +1,4 @@
-import { __extends } from "tslib";
+import { __extends, __spreadArray } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
@@ -17,6 +17,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         return _this;
     }
     UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
+        var _a;
         var _this = this;
         var featureNames = Object.keys(this.uniqueKeysTracker);
         if (!featureNames.length)
@@ -30,8 +31,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
             return JSON.stringify(uniqueKeysPayload);
         });
         this.clear();
-        return this.redis.rpush(this.key, uniqueKeysArray)
-            .then(function (data) {
+        return (_a = this.redis).rpush.apply(_a, __spreadArray([this.key], uniqueKeysArray, false)).then(function (data) {
             // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
             if (data === featureNames.length) {
                 return _this.redis.expire(_this.key, TTL_REFRESH);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.11.0",
+  "version": "2.11.1-rc.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -45,11 +45,10 @@
   "bugs": "https://github.com/splitio/javascript-commons/issues",
   "homepage": "https://github.com/splitio/javascript-commons#readme",
   "dependencies": {
-    "@types/ioredis": "^4.28.0",
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
-    "ioredis": "^4.28.0"
+    "ioredis": "^4.28.0 || ^5.0.0"
   },
   "peerDependenciesMeta": {
     "ioredis": {
@@ -68,7 +67,7 @@
     "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-tsdoc": "^0.3.0",
     "fetch-mock": "^9.11.0",
-    "ioredis": "^4.28.0",
+    "ioredis": "^5.0.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
     "lodash": "^4.17.21",

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -31,7 +31,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
     )
       // We use boolean values to signal successful queueing
       .then(() => true)
-      .catch(err => {
+      .catch((err: unknown) => {
         this.log.error(`${LOG_PREFIX}Error adding event to queue: ${err}.`);
         return false;
       });
@@ -65,9 +65,9 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
    * It is the submitter responsability to handle that.
    */
   popNWithMetadata(count: number): Promise<StoredEventWithMetadata[]> {
-    return this.redis.lrange(this.key, 0, count - 1).then(items => {
+    return this.redis.lrange(this.key, 0, count - 1).then((items: string[]) => {
       return this.redis.ltrim(this.key, items.length, -1).then(() => {
-        return items.map(item => JSON.parse(item) as StoredEventWithMetadata);
+        return items.map((item: string) => JSON.parse(item) as StoredEventWithMetadata);
       });
     });
   }

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -32,13 +32,13 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
       pipeline.hincrby(this.key, key, counts[key]);
     });
     return pipeline.exec()
-      .then(data => {
+      .then((data: [Error | null, unknown][] | null) => {
         // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
-        if (data.length && data.length === keys.length) {
+        if (data && data.length && data.length === keys.length) {
           return this.redis.expire(this.key, TTL_REFRESH);
         }
       })
-      .catch(err => {
+      .catch((err: unknown) => {
         this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
         return false;
       });
@@ -56,14 +56,14 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
   // Async consumer API, used by synchronizer
   getImpressionsCount(): Promise<ImpressionCountsPayload | undefined> {
     return this.redis.hgetall(this.key)
-      .then(counts => {
+      .then((counts: Record<string, string>) => {
         if (!Object.keys(counts).length) return undefined;
 
         this.redis.del(this.key).catch(() => { /* no-op */ });
 
         const pf: ImpressionCountsPayload['pf'] = [];
 
-        forOwn(counts, (count, key) => {
+        forOwn(counts, (count: string, key) => {
           const nameAndTime = key.split('::');
           if (nameAndTime.length !== 2) {
             this.log.error(`${LOG_PREFIX}Error spliting key ${key}`);

package/src/storages/inRedis/ImpressionsCacheInRedis.ts

@@ -25,8 +25,8 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
   track(impressions: SplitIO.ImpressionDTO[]): Promise<void> { // @ts-ignore
     return this.redis.rpush(
       this.key,
-      impressionsToJSON(impressions, this.metadata),
-    ).then(queuedCount => {
+      ...impressionsToJSON(impressions, this.metadata),
+    ).then((queuedCount: number) => {
       // If this is the creation of the key on Redis, set the expiration for it in 1hr.
       if (queuedCount === impressions.length) {
         return this.redis.expire(this.key, IMPRESSIONS_TTL_REFRESH);
@@ -45,7 +45,7 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
   }
 
   popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]> {
-    return this.redis.lrange(this.key, 0, count - 1).then(items => {
+    return this.redis.lrange(this.key, 0, count - 1).then((items: string[]) => {
       return this.redis.ltrim(this.key, items.length, -1).then(() => {
         // This operation will simply do nothing if the key no longer exists (queue is empty)
         // It's only done in the "successful" exit path so that the TTL is not overriden if impressons weren't
@@ -53,7 +53,7 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
         // a huge amount of memory.
         this.redis.expire(this.key, IMPRESSIONS_TTL_REFRESH).catch(() => { }); // noop catch handler
 
-        return items.map(item => JSON.parse(item) as StoredImpressionWithMetadata);
+        return items.map((item: string) => JSON.parse(item) as StoredImpressionWithMetadata);
       });
     });
   }

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -21,12 +21,12 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
 
   get(name: string): Promise<IRBSegment | null> {
     return this.redis.get(this.keys.buildRBSegmentKey(name))
-      .then(maybeRBSegment => maybeRBSegment && JSON.parse(maybeRBSegment));
+      .then((maybeRBSegment: string | null) => maybeRBSegment && JSON.parse(maybeRBSegment));
   }
 
   private getNames(): Promise<string[]> {
     return this.redis.keys(this.keys.searchPatternForRBSegmentKeys()).then(
-      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+      (listOfKeys: string[]) => listOfKeys.map(this.keys.extractKey)
     );
   }
 
@@ -47,7 +47,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
       })),
       Promise.all(toRemove.map(toRemove => {
         const key = this.keys.buildRBSegmentKey(toRemove.name);
-        return this.redis.del(key).then(status => status === 1);
+        return this.redis.del(key).then((status: number) => status === 1);
       }))
     ]).then(([, added, removed]) => {
       return added.some(result => result) || removed.some(result => result);
@@ -56,7 +56,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
 
   setChangeNumber(changeNumber: number) {
     return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
-      status => status === 'OK'
+      (status: string | null) => status === 'OK'
     );
   }
 
@@ -65,7 +65,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
       const i = parseInt(value as string, 10);
 
       return isNaNNumber(i) ? -1 : i;
-    }).catch((e) => {
+    }).catch((e: unknown) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
       return -1;
     });

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,4 +1,14 @@
-import ioredis, { Pipeline } from 'ioredis';
+// Dynamically require ioredis to prevent strict TypeScript binding
+// and handle module export differences between v4 and v5.
+let RedisConstructor: any;
+try {
+  const ioredisLib = require('ioredis');
+  RedisConstructor = ioredisLib.default || ioredisLib;
+} catch (e) {
+  // If we reach here, the peer dependency is missing
+  throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+}
+
 import { ILogger } from '../../logger/types';
 import { merge, isString } from '../../utils/lang';
 import { thenable } from '../../utils/promise/thenable';
@@ -20,41 +30,70 @@ const DEFAULT_OPTIONS = {
 const DEFAULT_LIBRARY_OPTIONS = {
   enableOfflineQueue: false,
   connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-  lazyConnect: false
+  lazyConnect: false,
+  // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
+  // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+  slotsRefreshInterval: 5000,
 };
 
 interface IRedisCommand {
-  resolve: () => void,
+  resolve: (value?: any) => void,
   reject: (err?: any) => void,
-  command: () => Promise<void>,
-  name: string
+  command: () => Promise<any>,
+  name: string,
 }
 
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
+ * Refactored to use Composition and Proxy instead of Inheritance to support both v4 and v5.
  */
-export class RedisAdapter extends ioredis {
+export class RedisAdapter {
+  // eslint-disable-next-line no-undef -- Index signature to allow proxying dynamic ioredis methods without TS errors
+  [key: string]: any;
   private readonly log: ILogger;
-  private _options: object;
+  private _options: Record<string, any>;
   private _notReadyCommandsQueue?: IRedisCommand[];
   private _runningCommands: Set<Promise<any>>;
 
+  // The actual ioredis instance
+  public client: any;
+
   constructor(log: ILogger, storageSettings: Record<string, any> = {}) {
     const options = RedisAdapter._defineOptions(storageSettings);
-    // Call the ioredis constructor
-    super(...RedisAdapter._defineLibrarySettings(options));
 
     this.log = log;
     this._options = options;
     this._notReadyCommandsQueue = [];
     this._runningCommands = new Set();
+
+    // Instantiate the client using the dynamic constructor
+    const librarySettings = RedisAdapter._defineLibrarySettings(options);
+    this.client = new RedisConstructor(...librarySettings);
+
     this._listenToEvents();
     this._setTimeoutWrappers();
     this._setDisconnectWrapper();
+
+    // Return a Proxy. This allows the adapter to act exactly like an extended class.
+    // If a method/property is accessed that we didn't explicitly wrap, it forwards it to `this.client`.
+    return new Proxy(this, {
+      get(target: RedisAdapter, prop: string | symbol) {
+        // If the property exists on our wrapper (like wrapped 'get', 'set', or internal methods)
+        if (prop in target) {
+          return target[prop as keyof RedisAdapter];
+        }
+        // If it doesn't exist on our wrapper but exists on the real client (like 'on', 'quit')
+        if (target.client && prop in target.client) {
+          const val = target.client[prop];
+          return typeof val === 'function' ? val.bind(target.client) : val;
+        }
+        return undefined;
+      }
+    });
   }
 
   _listenToEvents() {
-    this.once('ready', () => {
+    this.client.once('ready', () => {
       const commandsCount = this._notReadyCommandsQueue ? this._notReadyCommandsQueue.length : 0;
       this.log.info(LOG_PREFIX + `Redis connection established. Queued commands: ${commandsCount}.`);
 
@@ -65,24 +104,21 @@ export class RedisAdapter extends ioredis {
       // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
       this._notReadyCommandsQueue = undefined;
     });
-    this.once('close', () => {
+    this.client.once('close', () => {
       this.log.info(LOG_PREFIX + 'Redis connection closed.');
     });
   }
 
   _setTimeoutWrappers() {
-    const instance: Record<string, any> = this;
-
-    const wrapCommand = (originalMethod: Function, methodName: string) => {
-      // The value of "this" in this function should be the instance actually executing the method. It might be the instance referred (the base one)
-      // or it can be the instance of a Pipeline object.
-      return function (this: RedisAdapter | Pipeline) {
-        const params = arguments;
-        const caller = this;
+    const instance = this;
 
+    // We pass `bindTarget` so pipeline execution is bound to the pipeline object,
+    // while standard commands are bound to the client.
+    const wrapCommand = (originalMethod: Function, methodName: string, bindTarget: any) => {
+      return function (...params: any[]) {
         function commandWrapper() {
           instance.log.debug(`${LOG_PREFIX}Executing ${methodName}.`);
-          const result = originalMethod.apply(caller, params);
+          const result = originalMethod.apply(bindTarget, params);
 
           if (thenable(result)) {
             // For handling pending commands on disconnect, add to the set and remove once finished.
@@ -106,7 +142,7 @@ export class RedisAdapter extends ioredis {
 
         if (instance._notReadyCommandsQueue) {
           return new Promise((resolve, reject) => {
-            instance._notReadyCommandsQueue.unshift({
+            instance._notReadyCommandsQueue!.unshift({
               resolve,
               reject,
               command: commandWrapper,
@@ -121,19 +157,19 @@ export class RedisAdapter extends ioredis {
 
     // Wrap regular async methods to track timeouts and queue when Redis is not yet executing commands.
     METHODS_TO_PROMISE_WRAP.forEach(methodName => {
-      const originalFn = instance[methodName];
-      instance[methodName] = wrapCommand(originalFn, methodName);
+      const originalFn = this.client[methodName];
+      this[methodName] = wrapCommand(originalFn, methodName, this.client);
     });
 
     // Special handling for pipeline~like methods. We need to wrap the async trigger, which is exec, but return the Pipeline right away.
     METHODS_TO_PROMISE_WRAP_EXEC.forEach(methodName => {
-      const originalFn = instance[methodName];
+      const originalFn = this.client[methodName];
       // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
-      instance[methodName] = function () {
-        const res = originalFn.apply(instance, arguments);
+      this[methodName] = function (...args: any[]) {
+        const res = originalFn.apply(instance.client, args);
         const originalExec = res.exec;
 
-        res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+        res.exec = wrapCommand(originalExec, `${methodName}.exec`, res);
 
         return res;
       };
@@ -142,10 +178,9 @@ export class RedisAdapter extends ioredis {
 
   _setDisconnectWrapper() {
     const instance = this;
-    const originalMethod = instance.disconnect;
-
-    instance.disconnect = function disconnect(...params: []) {
+    const originalMethod = this.client.disconnect;
 
+    this.disconnect = function disconnect(...params: any[]) {
       setTimeout(function deferredDisconnect() {
         if (instance._runningCommands.size > 0) {
           instance.log.info(LOG_PREFIX + `Attempting to disconnect but there are ${instance._runningCommands.size} commands still waiting for resolution. Defering disconnection until those finish.`);
@@ -153,16 +188,16 @@ export class RedisAdapter extends ioredis {
           Promise.all(setToArray(instance._runningCommands))
             .then(() => {
               instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
-              originalMethod.apply(instance, params);
+              originalMethod.apply(instance.client, params);
             })
             .catch(e => {
               instance.log.warn(LOG_PREFIX + `Pending commands finished with error: ${e}. Proceeding with disconnection.`);
-              originalMethod.apply(instance, params);
+              originalMethod.apply(instance.client, params);
             });
         } else {
           instance.log.debug(LOG_PREFIX + 'No commands pending execution, disconnect.');
           // Nothing pending, just proceed.
-          originalMethod.apply(instance, params);
+          originalMethod.apply(instance.client, params);
         }
       }, 10);
     };

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -37,7 +37,7 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
   isInSegment(name: string, key: string) {
     return this.redis.sismember(
       this.keys.buildSegmentNameKey(name), key
-    ).then(matches => matches !== 0);
+    ).then((matches: number) => matches !== 0);
   }
 
   getChangeNumber(name: string) {
@@ -45,7 +45,7 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
       const i = parseInt(value as string, 10);
 
       return isNaNNumber(i) ? undefined : i;
-    }).catch((e) => {
+    }).catch((e: unknown) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
       return undefined;
     });

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -10,11 +10,11 @@ import type { RedisAdapter } from './RedisAdapter';
 /**
  * Discard errors for an answer of multiple operations.
  */
-function processPipelineAnswer(results: Array<[Error | null, string]>): string[] {
-  return results.reduce((accum: string[], errValuePair: [Error | null, string]) => {
-    if (errValuePair[0] === null) accum.push(errValuePair[1]);
+function processPipelineAnswer(results: Array<[Error | null, unknown]> | null): string[] {
+  return results ? results.reduce((accum: string[], errValuePair: [Error | null, unknown]) => {
+    if (errValuePair[0] === null) accum.push(errValuePair[1] as string);
     return accum;
-  }, []);
+  }, []) : [];
 }
 
 /**
@@ -26,7 +26,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   private readonly log: ILogger;
   private readonly redis: RedisAdapter;
   private readonly keys: KeyBuilderSS;
-  private redisError?: string;
+  private redisError?: Error;
   private readonly flagSetsFilter: string[];
 
   constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter, splitFiltersValidation?: ISplitFiltersValidation) {
@@ -38,7 +38,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
 
     // There is no need to listen for redis 'error' event, because in that case ioredis calls will be rejected and handled by redis storage adapters.
     // But it is done just to avoid getting the ioredis message `Unhandled error event`.
-    this.redis.on('error', (e) => {
+    this.redis.on('error', (e: Error) => {
       this.redisError = e;
     });
 
@@ -49,7 +49,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
 
   private _decrementCounts(split: ISplit) {
     const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-    return this.redis.decr(ttKey).then(count => {
+    return this.redis.decr(ttKey).then((count: number) => {
       if (count === 0) return this.redis.del(ttKey);
     });
   }
@@ -85,7 +85,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   addSplit(split: ISplit): Promise<boolean> {
     const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
-    return this.redis.get(splitKey).then(splitFromStorage => {
+    return this.redis.get(splitKey).then((splitFromStorage: string | null) => {
 
       // handling parsing error
       let parsedPreviousSplit: ISplit, stringifiedNewSplit;
@@ -119,7 +119,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
     }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name)).then(status => status === 1);
+      return this.redis.del(this.keys.buildSplitKey(name)).then((status: number) => status === 1);
     });
   }
 
@@ -135,7 +135,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     }
 
     return this.redis.get(this.keys.buildSplitKey(name))
-      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
+      .then((maybeSplit: string | null) => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -145,7 +145,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    */
   setChangeNumber(changeNumber: number): Promise<boolean> {
     return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(
-      status => status === 'OK'
+      (status: string | null) => status === 'OK'
     );
   }
 
@@ -159,7 +159,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
       const i = parseInt(value as string, 10);
 
       return isNaNNumber(i) ? -1 : i;
-    }).catch((e) => {
+    }).catch((e: unknown) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
       return -1;
     });
@@ -173,9 +173,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
   getAll(): Promise<ISplit[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys())
-      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
+      .then((listOfKeys: string[]) => this.redis.pipeline(listOfKeys.map((k: string) => ['get', k])).exec())
       .then(processPipelineAnswer)
-      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+      .then((splitDefinitions: string[]) => splitDefinitions.map((splitDefinition: string) => {
         return JSON.parse(splitDefinition);
       }));
   }
@@ -187,7 +187,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    */
   getSplitNames(): Promise<string[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
-      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+      (listOfKeys: string[]) => listOfKeys.map(this.keys.extractKey)
     );
   }
 
@@ -198,12 +198,12 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   */
   getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
-      .then((results) => results.map(([e, value], index) => {
-        if (e === null) return value;
+      .then((results: [Error | null, unknown][] | null) => results ? results.map(([e, value]: [Error | null, unknown], index: number) => {
+        if (e === null) return value as string;
 
         this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
-      }))
-      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
+      }) : [])
+      .then((namesByFlagSets: (string | undefined)[]) => namesByFlagSets.map((namesByFlagSet: string | undefined) => new Set(namesByFlagSet)));
   }
 
   /**
@@ -226,7 +226,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
 
         return ttCount > 0;
       })
-      .catch(e => {
+      .catch((e: unknown) => {
         this.log.error(LOG_PREFIX + `Could not validate traffic type existence of ${trafficType} due to an error: ${e}.`);
         // If there is an error, bypass the validation so the event can get tracked.
         return true;
@@ -251,7 +251,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
 
     const keys = names.map(name => this.keys.buildSplitKey(name));
     return this.redis.mget(...keys)
-      .then(splitDefinitions => {
+      .then((splitDefinitions: (string | null)[]) => {
         const splits: Record<string, ISplit | null> = {};
         names.forEach((name, idx) => {
           const split = splitDefinitions[idx];
@@ -259,7 +259,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         });
         return Promise.resolve(splits);
       })
-      .catch(e => {
+      .catch((e: unknown) => {
         this.log.error(LOG_PREFIX + `Could not grab feature flags due to an error: ${e}.`);
         return Promise.reject(e);
       });

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -43,7 +43,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
    * The returned promise rejects if redis operations fail.
    */
   popLatencies(): Promise<MultiMethodLatencies> {
-    return this.redis.hgetall(this.keys.latencyPrefix).then(latencies => {
+    return this.redis.hgetall(this.keys.latencyPrefix).then((latencies: Record<string, string>) => {
 
       const result: MultiMethodLatencies = new Map();
 
@@ -83,7 +83,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
    * The returned promise rejects if redis operations fail.
    */
   popExceptions(): Promise<MultiMethodExceptions> {
-    return this.redis.hgetall(this.keys.exceptionPrefix).then(exceptions => {
+    return this.redis.hgetall(this.keys.exceptionPrefix).then((exceptions: Record<string, string>) => {
 
       const result: MultiMethodExceptions = new Map();
 
@@ -116,7 +116,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
    * The returned promise rejects if redis operations fail.
    */
   popConfigs(): Promise<MultiConfigs> {
-    return this.redis.hgetall(this.keys.initPrefix).then(configs => {
+    return this.redis.hgetall(this.keys.initPrefix).then((configs: Record<string, string>) => {
 
       const result: MultiConfigs = new Map();
 

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -38,14 +38,14 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
     });
 
     this.clear();
-    return this.redis.rpush(this.key, uniqueKeysArray)
-      .then(data => {
+    return this.redis.rpush(this.key, ...uniqueKeysArray)
+      .then((data: number) => {
         // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
         if (data === featureNames.length) {
           return this.redis.expire(this.key, TTL_REFRESH);
         }
       })
-      .catch(err => {
+      .catch((err: unknown) => {
         this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
         return false;
       });
@@ -66,9 +66,9 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
    * @param count - number of items to pop from the queue. If not provided or equal 0, all items will be popped.
    */
   popNRaw(count = 0): Promise<UniqueKeysItemSs[]> {
-    return this.redis.lrange(this.key, 0, count - 1).then(uniqueKeyItems => {
+    return this.redis.lrange(this.key, 0, count - 1).then((uniqueKeyItems: string[]) => {
       return this.redis.ltrim(this.key, uniqueKeyItems.length, -1)
-        .then(() => uniqueKeyItems.map(uniqueKeyItem => JSON.parse(uniqueKeyItem)));
+        .then(() => uniqueKeyItems.map((uniqueKeyItem: string) => JSON.parse(uniqueKeyItem)));
     });
   }