@splitsoftware/splitio-commons 1.12.1-rc.2 → 1.12.1-rc.3

package/CHANGES.txt

@@ -1,17 +1,18 @@
 1.12.0 (December XX, 2023)
  - Added support for Flag Sets in "consumer" and "partial consumer" modes for Pluggable and Redis storages.
  - Updated evaluation flow to log a warning when using flag sets that don't contain cached feature flags.
- - Updated Redis adapter to wrap missing commands: 'hincrby', 'popNRaw', 'flushdb' and 'pipeline.exec'.
+ - Updated Redis adapter to handle timeouts and queueing of some missing commands: 'hincrby', 'popNRaw', and 'pipeline.exec'.
+ - Bugfixing - Fixed manager methods in consumer modes to return results in a promise when the SDK is not operational (not ready or destroyed).
 
 1.11.0 (November 3, 2023)
-  - Added support for Flag Sets on the SDK, which enables grouping feature flags and interacting with the group rather than individually (more details in our documentation):
-    - Added new variations of the get treatment methods to support evaluating flags in given flag set/s.
-      - getTreatmentsByFlagSet and getTreatmentsByFlagSets
-      - getTreatmentsWithConfigByFlagSets and getTreatmentsWithConfigByFlagSets
-    - Added a new optional Split Filter configuration option. This allows the SDK and Split services to only synchronize the flags in the specified flag sets, avoiding unused or unwanted flags from being synced on the SDK instance, bringing all the benefits from a reduced payload.
-      - Note: Only applicable when the SDK is in charge of the rollout data synchronization. When not applicable, the SDK will log a warning on init.
-    - Added `sets` property to the `SplitView` object returned by the `split` and `splits` methods of the SDK manager to expose flag sets on flag views.
-  - Bugfixing - Fixed SDK key validation in NodeJS to ensure the SDK_READY_TIMED_OUT event is emitted when a client-side type SDK key is provided instead of a server-side one (Related to issue https://github.com/splitio/javascript-client/issues/768).
+ - Added support for Flag Sets on the SDK, which enables grouping feature flags and interacting with the group rather than individually (more details in our documentation):
+   - Added new variations of the get treatment methods to support evaluating flags in given flag set/s.
+     - getTreatmentsByFlagSet and getTreatmentsByFlagSets
+     - getTreatmentsWithConfigByFlagSets and getTreatmentsWithConfigByFlagSets
+   - Added a new optional Split Filter configuration option. This allows the SDK and Split services to only synchronize the flags in the specified flag sets, avoiding unused or unwanted flags from being synced on the SDK instance, bringing all the benefits from a reduced payload.
+     - Note: Only applicable when the SDK is in charge of the rollout data synchronization. When not applicable, the SDK will log a warning on init.
+   - Added `sets` property to the `SplitView` object returned by the `split` and `splits` methods of the SDK manager to expose flag sets on flag views.
+ - Bugfixing - Fixed SDK key validation in NodeJS to ensure the SDK_READY_TIMED_OUT event is emitted when a client-side type SDK key is provided instead of a server-side one (Related to issue https://github.com/splitio/javascript-client/issues/768).
 
 1.10.0 (October 20, 2023)
  - Added `defaultTreatment` property to the `SplitView` object returned by the `split` and `splits` methods of the SDK manager (Related to issue https://github.com/splitio/javascript-commons/issues/225).

package/cjs/sdkFactory/index.js

@@ -66,7 +66,7 @@ function sdkFactory(params) {
     ctx.signalListener = signalListener;
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
-    var managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
+    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     syncManager && syncManager.start();
     signalListener && signalListener.start();
     log.info(constants_1.NEW_FACTORY);

package/cjs/sdkManager/index.js

@@ -5,6 +5,7 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
 var thenable_1 = require("../utils/promise/thenable");
 var lang_1 = require("../utils/lang");
 var inputValidation_1 = require("../utils/inputValidation");
+var utils_1 = require("../trackers/impressionObserver/utils");
 var SPLIT_FN_LABEL = 'split';
 var SPLITS_FN_LABEL = 'splits';
 var NAMES_FN_LABEL = 'names';
@@ -41,8 +42,10 @@ function objectsToViews(splitObjects) {
     });
     return views;
 }
-function sdkManagerFactory(log, splits, _a) {
+function sdkManagerFactory(settings, splits, _a) {
     var readinessManager = _a.readinessManager, sdkStatus = _a.sdkStatus;
+    var log = settings.log;
+    var isSync = (0, utils_1.isStorageSync)(settings);
     return (0, objectAssign_1.objectAssign)(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus), {
@@ -52,7 +55,7 @@ function sdkManagerFactory(log, splits, _a) {
         split: function (featureFlagName) {
             var splitName = (0, inputValidation_1.validateSplit)(log, featureFlagName, SPLIT_FN_LABEL);
             if (!(0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, SPLIT_FN_LABEL) || !(0, inputValidation_1.validateIfOperational)(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-                return null;
+                return isSync ? null : Promise.resolve(null);
             }
             var split = splits.getSplit(splitName);
             if ((0, thenable_1.thenable)(split)) {
@@ -69,7 +72,7 @@ function sdkManagerFactory(log, splits, _a) {
          */
         splits: function () {
             if (!(0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, SPLITS_FN_LABEL) || !(0, inputValidation_1.validateIfOperational)(log, readinessManager, SPLITS_FN_LABEL)) {
-                return [];
+                return isSync ? [] : Promise.resolve([]);
             }
             var currentSplits = splits.getAll();
             return (0, thenable_1.thenable)(currentSplits) ?
@@ -81,7 +84,7 @@ function sdkManagerFactory(log, splits, _a) {
          */
         names: function () {
             if (!(0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, NAMES_FN_LABEL) || !(0, inputValidation_1.validateIfOperational)(log, readinessManager, NAMES_FN_LABEL)) {
-                return [];
+                return isSync ? [] : Promise.resolve([]);
             }
             var splitNames = splits.getSplitNames();
             return (0, thenable_1.thenable)(splitNames) ?

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -23,7 +23,11 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var keys = Object.keys(counts);
         if (!keys.length)
             return Promise.resolve(false);
-        return this.redis.pipelineExec(keys.map(function (key) { return ['hincrby', _this.key, key, counts[key]]; }))
+        var pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.hincrby(_this.key, key, counts[key]);
+        });
+        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) {

package/cjs/storages/inRedis/RedisAdapter.js

@@ -9,7 +9,8 @@ var thenable_1 = require("../../utils/promise/thenable");
 var timeout_1 = require("../../utils/promise/timeout");
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
+var METHODS_TO_PROMISE_WRAP_EXEC = ['pipeline'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,
@@ -27,6 +28,7 @@ var DEFAULT_LIBRARY_OPTIONS = {
 var RedisAdapter = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(RedisAdapter, _super);
     function RedisAdapter(log, storageSettings) {
+        if (storageSettings === void 0) { storageSettings = {}; }
         var _this = this;
         var options = RedisAdapter._defineOptions(storageSettings);
         // Call the ioredis constructor
@@ -40,9 +42,6 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this._setDisconnectWrapper();
         return _this;
     }
-    RedisAdapter.prototype.pipelineExec = function (commands) {
-        return this.pipeline(commands).exec();
-    };
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
         this.once('ready', function () {
@@ -61,13 +60,15 @@ var RedisAdapter = /** @class */ (function (_super) {
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
         var instance = this;
-        METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
-            var originalMethod = instance[methodName];
-            instance[methodName] = function () {
+        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.
+            return function () {
                 var params = arguments;
+                var caller = this;
                 function commandWrapper() {
                     instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
-                    var result = originalMethod.apply(instance, params);
+                    var result = originalMethod.apply(caller, 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.
@@ -86,10 +87,10 @@ var RedisAdapter = /** @class */ (function (_super) {
                     return result;
                 }
                 if (instance._notReadyCommandsQueue) {
-                    return new Promise(function (res, rej) {
+                    return new Promise(function (resolve, reject) {
                         instance._notReadyCommandsQueue.unshift({
-                            resolve: res,
-                            reject: rej,
+                            resolve: resolve,
+                            reject: reject,
                             command: commandWrapper,
                             name: methodName.toUpperCase()
                         });
@@ -99,6 +100,22 @@ var RedisAdapter = /** @class */ (function (_super) {
                     return commandWrapper();
                 }
             };
+        };
+        // 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);
+        });
+        // 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];
+            // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
+            instance[methodName] = function () {
+                var res = originalFn.apply(instance, arguments);
+                var originalExec = res.exec;
+                res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+                return res;
+            };
         });
     };
     RedisAdapter.prototype._setDisconnectWrapper = function () {
@@ -160,7 +177,7 @@ var RedisAdapter = /** @class */ (function (_super) {
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout, operationTimeout = _b.operationTimeout, url = _b.url, host = _b.host, port = _b.port, db = _b.db, pass = _b.pass, tls = _b.tls;
+        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
         var parsedOptions = {
             connectionTimeout: connectionTimeout,
             operationTimeout: operationTimeout,

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -54,9 +54,9 @@ var SegmentsCacheInRedis = /** @class */ (function () {
     SegmentsCacheInRedis.prototype.getRegisteredSegments = function () {
         return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
     };
-    // @TODO remove/review. It is not being used.
+    // @TODO remove or implement. It is not being used.
     SegmentsCacheInRedis.prototype.clear = function () {
-        return this.redis.flushdb().then(function (status) { return status === 'OK'; });
+        return Promise.resolve();
     };
     return SegmentsCacheInRedis;
 }());

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -171,7 +171,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys())
-            .then(function (listOfKeys) { return _this.redis.pipelineExec(listOfKeys.map(function (k) { return ['get', k]; })); })
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
             .then(processPipelineAnswer)
             .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
             return JSON.parse(splitDefinition);
@@ -189,11 +189,11 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     /**
      * Get list of feature flag names related to a given list of flag set names.
      * The returned promise is resolved with the list of feature flag names per flag set,
-     * or rejected if the pipelined redis operation fails.
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return this.redis.pipelineExec(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; }))
+        return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
             .then(function (results) { return results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
@@ -228,13 +228,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             return true;
         });
     };
-    /**
-     * Delete everything in the current database.
-     *
-     * @NOTE documentation says it never fails.
-     */
+    // @TODO remove or implement. It is not being used.
     SplitsCacheInRedis.prototype.clear = function () {
-        return this.redis.flushdb().then(function (status) { return status === 'OK'; });
+        return Promise.resolve();
     };
     /**
      * Fetches multiple splits definitions.

package/cjs/utils/redis/RedisMock.js

@@ -9,16 +9,22 @@ function asyncFunction(data) {
     return Promise.resolve(data);
 }
 var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
 var RedisMock = /** @class */ (function () {
     function RedisMock() {
         var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
         IDENTITY_METHODS.forEach(function (method) {
             _this[method] = jest.fn(identityFunction);
         });
         ASYNC_METHODS.forEach(function (method) {
             _this[method] = jest.fn(asyncFunction);
         });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
     }
     return RedisMock;
 }());

package/esm/sdkFactory/index.js

@@ -63,7 +63,7 @@ export function sdkFactory(params) {
     ctx.signalListener = signalListener;
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
-    var managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
+    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     syncManager && syncManager.start();
     signalListener && signalListener.start();
     log.info(NEW_FACTORY);

package/esm/sdkManager/index.js

@@ -2,6 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
 import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
 var SPLIT_FN_LABEL = 'split';
 var SPLITS_FN_LABEL = 'splits';
 var NAMES_FN_LABEL = 'names';
@@ -38,8 +39,10 @@ function objectsToViews(splitObjects) {
     });
     return views;
 }
-export function sdkManagerFactory(log, splits, _a) {
+export function sdkManagerFactory(settings, splits, _a) {
     var readinessManager = _a.readinessManager, sdkStatus = _a.sdkStatus;
+    var log = settings.log;
+    var isSync = isStorageSync(settings);
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus), {
@@ -49,7 +52,7 @@ export function sdkManagerFactory(log, splits, _a) {
         split: function (featureFlagName) {
             var splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
             if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-                return null;
+                return isSync ? null : Promise.resolve(null);
             }
             var split = splits.getSplit(splitName);
             if (thenable(split)) {
@@ -66,7 +69,7 @@ export function sdkManagerFactory(log, splits, _a) {
          */
         splits: function () {
             if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-                return [];
+                return isSync ? [] : Promise.resolve([]);
             }
             var currentSplits = splits.getAll();
             return thenable(currentSplits) ?
@@ -78,7 +81,7 @@ export function sdkManagerFactory(log, splits, _a) {
          */
         names: function () {
             if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-                return [];
+                return isSync ? [] : Promise.resolve([]);
             }
             var splitNames = splits.getSplitNames();
             return thenable(splitNames) ?

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -20,7 +20,11 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var keys = Object.keys(counts);
         if (!keys.length)
             return Promise.resolve(false);
-        return this.redis.pipelineExec(keys.map(function (key) { return ['hincrby', _this.key, key, counts[key]]; }))
+        var pipeline = this.redis.pipeline();
+        keys.forEach(function (key) {
+            pipeline.hincrby(_this.key, key, counts[key]);
+        });
+        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) {

package/esm/storages/inRedis/RedisAdapter.js

@@ -6,7 +6,8 @@ import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
+var METHODS_TO_PROMISE_WRAP_EXEC = ['pipeline'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,
@@ -24,6 +25,7 @@ var DEFAULT_LIBRARY_OPTIONS = {
 var RedisAdapter = /** @class */ (function (_super) {
     __extends(RedisAdapter, _super);
     function RedisAdapter(log, storageSettings) {
+        if (storageSettings === void 0) { storageSettings = {}; }
         var _this = this;
         var options = RedisAdapter._defineOptions(storageSettings);
         // Call the ioredis constructor
@@ -37,9 +39,6 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this._setDisconnectWrapper();
         return _this;
     }
-    RedisAdapter.prototype.pipelineExec = function (commands) {
-        return this.pipeline(commands).exec();
-    };
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
         this.once('ready', function () {
@@ -58,13 +57,15 @@ var RedisAdapter = /** @class */ (function (_super) {
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
         var instance = this;
-        METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
-            var originalMethod = instance[methodName];
-            instance[methodName] = function () {
+        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.
+            return function () {
                 var params = arguments;
+                var caller = this;
                 function commandWrapper() {
                     instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
-                    var result = originalMethod.apply(instance, params);
+                    var result = originalMethod.apply(caller, 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.
@@ -83,10 +84,10 @@ var RedisAdapter = /** @class */ (function (_super) {
                     return result;
                 }
                 if (instance._notReadyCommandsQueue) {
-                    return new Promise(function (res, rej) {
+                    return new Promise(function (resolve, reject) {
                         instance._notReadyCommandsQueue.unshift({
-                            resolve: res,
-                            reject: rej,
+                            resolve: resolve,
+                            reject: reject,
                             command: commandWrapper,
                             name: methodName.toUpperCase()
                         });
@@ -96,6 +97,22 @@ var RedisAdapter = /** @class */ (function (_super) {
                     return commandWrapper();
                 }
             };
+        };
+        // 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);
+        });
+        // 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];
+            // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
+            instance[methodName] = function () {
+                var res = originalFn.apply(instance, arguments);
+                var originalExec = res.exec;
+                res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+                return res;
+            };
         });
     };
     RedisAdapter.prototype._setDisconnectWrapper = function () {
@@ -157,7 +174,7 @@ var RedisAdapter = /** @class */ (function (_super) {
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout, operationTimeout = _b.operationTimeout, url = _b.url, host = _b.host, port = _b.port, db = _b.db, pass = _b.pass, tls = _b.tls;
+        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
         var parsedOptions = {
             connectionTimeout: connectionTimeout,
             operationTimeout: operationTimeout,

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -51,9 +51,9 @@ var SegmentsCacheInRedis = /** @class */ (function () {
     SegmentsCacheInRedis.prototype.getRegisteredSegments = function () {
         return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
     };
-    // @TODO remove/review. It is not being used.
+    // @TODO remove or implement. It is not being used.
     SegmentsCacheInRedis.prototype.clear = function () {
-        return this.redis.flushdb().then(function (status) { return status === 'OK'; });
+        return Promise.resolve();
     };
     return SegmentsCacheInRedis;
 }());

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -168,7 +168,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys())
-            .then(function (listOfKeys) { return _this.redis.pipelineExec(listOfKeys.map(function (k) { return ['get', k]; })); })
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
             .then(processPipelineAnswer)
             .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
             return JSON.parse(splitDefinition);
@@ -186,11 +186,11 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     /**
      * Get list of feature flag names related to a given list of flag set names.
      * The returned promise is resolved with the list of feature flag names per flag set,
-     * or rejected if the pipelined redis operation fails.
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return this.redis.pipelineExec(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; }))
+        return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
             .then(function (results) { return results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
@@ -225,13 +225,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             return true;
         });
     };
-    /**
-     * Delete everything in the current database.
-     *
-     * @NOTE documentation says it never fails.
-     */
+    // @TODO remove or implement. It is not being used.
     SplitsCacheInRedis.prototype.clear = function () {
-        return this.redis.flushdb().then(function (status) { return status === 'OK'; });
+        return Promise.resolve();
     };
     /**
      * Fetches multiple splits definitions.

package/esm/utils/redis/RedisMock.js

@@ -6,16 +6,22 @@ function asyncFunction(data) {
     return Promise.resolve(data);
 }
 var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
 var RedisMock = /** @class */ (function () {
     function RedisMock() {
         var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
         IDENTITY_METHODS.forEach(function (method) {
             _this[method] = jest.fn(identityFunction);
         });
         ASYNC_METHODS.forEach(function (method) {
             _this[method] = jest.fn(asyncFunction);
         });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
     }
     return RedisMock;
 }());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.12.1-rc.2",
+  "version": "1.12.1-rc.3",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/sdkFactory/index.ts

@@ -83,7 +83,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   // SDK client and manager
   const clientMethod = sdkClientMethodFactory(ctx);
-  const managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
+  const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
   syncManager && syncManager.start();
   signalListener && signalListener.start();

package/src/sdkFactory/types.ts

@@ -1,9 +1,9 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
+import type { sdkManagerFactory } from '../sdkManager';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
-import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
+import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
@@ -87,11 +87,7 @@ export interface ISdkFactoryParams {
   syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager,
 
   // Sdk manager factory
-  sdkManagerFactory: (
-    log: ILogger,
-    splits: ISplitsCacheSync | ISplitsCacheAsync,
-    sdkReadinessManager: ISdkReadinessManager
-  ) => SplitIO.IManager | SplitIO.IAsyncManager,
+  sdkManagerFactory: typeof sdkManagerFactory,
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).

package/src/sdkManager/index.ts

@@ -5,8 +5,8 @@ import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validate
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { ISettings, SplitIO } from '../types';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
 
 const SPLIT_FN_LABEL = 'split';
 const SPLITS_FN_LABEL = 'splits';
@@ -49,11 +49,14 @@ function objectsToViews(splitObjects: ISplit[]) {
 }
 
 export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(
-  log: ILogger,
+  settings: Pick<ISettings, 'log' | 'mode'>,
   splits: TSplitCache,
-  { readinessManager, sdkStatus }: ISdkReadinessManager
+  { readinessManager, sdkStatus }: ISdkReadinessManager,
 ): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
 
+  const log = settings.log;
+  const isSync = isStorageSync(settings);
+
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus),
@@ -64,7 +67,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
       split(featureFlagName: string) {
         const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-          return null;
+          return isSync ? null : Promise.resolve(null);
         }
 
         const split = splits.getSplit(splitName);
@@ -85,7 +88,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       splits() {
         if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-          return [];
+          return isSync ? [] : Promise.resolve([]);
         }
         const currentSplits = splits.getAll();
 
@@ -98,7 +101,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       names() {
         if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-          return [];
+          return isSync ? [] : Promise.resolve([]);
         }
         const splitNames = splits.getSplitNames();
 

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -27,7 +27,11 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
     const keys = Object.keys(counts);
     if (!keys.length) return Promise.resolve(false);
 
-    return this.redis.pipelineExec(keys.map(key => ['hincrby', this.key, key, counts[key]]))
+    const pipeline = this.redis.pipeline();
+    keys.forEach(key => {
+      pipeline.hincrby(this.key, key, counts[key]);
+    });
+    return pipeline.exec()
       .then(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) {

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,4 +1,4 @@
-import ioredis from 'ioredis';
+import ioredis, { Pipeline } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { merge, isString } from '../../utils/lang';
 import { _Set, setToArray, ISet } from '../../utils/lang/sets';
@@ -8,7 +8,8 @@ import { timeout } from '../../utils/promise/timeout';
 const LOG_PREFIX = 'storage:redis-adapter: ';
 
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
+const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
+const METHODS_TO_PROMISE_WRAP_EXEC = ['pipeline'];
 
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 const DEFAULT_OPTIONS = {
@@ -38,7 +39,7 @@ export class RedisAdapter extends ioredis {
   private _notReadyCommandsQueue?: IRedisCommand[];
   private _runningCommands: ISet<Promise<any>>;
 
-  constructor(log: ILogger, storageSettings?: Record<string, any>) {
+  constructor(log: ILogger, storageSettings: Record<string, any> = {}) {
     const options = RedisAdapter._defineOptions(storageSettings);
     // Call the ioredis constructor
     super(...RedisAdapter._defineLibrarySettings(options));
@@ -52,10 +53,6 @@ export class RedisAdapter extends ioredis {
     this._setDisconnectWrapper();
   }
 
-  pipelineExec(commands?: (string | number)[][]): Promise<Array<[Error | null, any]>> {
-    return this.pipeline(commands as string[][]).exec();
-  }
-
   _listenToEvents() {
     this.once('ready', () => {
       const commandsCount = this._notReadyCommandsQueue ? this._notReadyCommandsQueue.length : 0;
@@ -76,21 +73,22 @@ export class RedisAdapter extends ioredis {
   _setTimeoutWrappers() {
     const instance: Record<string, any> = this;
 
-    METHODS_TO_PROMISE_WRAP.forEach(methodName => {
-      const originalMethod = instance[methodName];
-
-      instance[methodName] = function () {
+    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;
 
         function commandWrapper() {
           instance.log.debug(`${LOG_PREFIX}Executing ${methodName}.`);
-          const result = originalMethod.apply(instance, params);
+          const result = originalMethod.apply(caller, 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.
             instance._runningCommands.add(result);
-            const cleanUpRunningCommandsCb = () => {
+            const cleanUpRunningCommandsCb = function () {
               instance._runningCommands.delete(result);
             };
             // Both success and error remove from queue.
@@ -107,10 +105,10 @@ export class RedisAdapter extends ioredis {
         }
 
         if (instance._notReadyCommandsQueue) {
-          return new Promise((res, rej) => {
+          return new Promise((resolve, reject) => {
             instance._notReadyCommandsQueue.unshift({
-              resolve: res,
-              reject: rej,
+              resolve,
+              reject,
               command: commandWrapper,
               name: methodName.toUpperCase()
             });
@@ -119,6 +117,26 @@ export class RedisAdapter extends ioredis {
           return commandWrapper();
         }
       };
+    };
+
+    // 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);
+    });
+
+    // 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];
+      // "First level wrapper" to handle the sync execution and wrap async, queueing later if applicable.
+      instance[methodName] = function () {
+        const res = originalFn.apply(instance, arguments);
+        const originalExec = res.exec;
+
+        res.exec = wrapCommand(originalExec, methodName + '.exec').bind(res);
+
+        return res;
+      };
     });
   }
 
@@ -181,7 +199,7 @@ export class RedisAdapter extends ioredis {
   /**
    * Parses the options into what we care about.
    */
-  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any> = {}) {
+  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>) {
     const parsedOptions = {
       connectionTimeout, operationTimeout, url, host, port, db, pass, tls
     };

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -72,8 +72,8 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
   }
 
-  // @TODO remove/review. It is not being used.
+  // @TODO remove or implement. It is not being used.
   clear() {
-    return this.redis.flushdb().then(status => status === 'OK');
+    return Promise.resolve();
   }
 }

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -192,7 +192,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    */
   getAll(): Promise<ISplit[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys())
-      .then((listOfKeys) => this.redis.pipelineExec(listOfKeys.map(k => ['get', k])))
+      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
       .then(processPipelineAnswer)
       .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
         return JSON.parse(splitDefinition);
@@ -213,10 +213,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   /**
    * Get list of feature flag names related to a given list of flag set names.
    * The returned promise is resolved with the list of feature flag names per flag set,
-   * or rejected if the pipelined redis operation fails.
+   * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
   getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
-    return this.redis.pipelineExec(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)]))
+    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;
 
@@ -252,13 +252,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
       });
   }
 
-  /**
-   * Delete everything in the current database.
-   *
-   * @NOTE documentation says it never fails.
-   */
+  // @TODO remove or implement. It is not being used.
   clear() {
-    return this.redis.flushdb().then(status => status === 'OK');
+    return Promise.resolve();
   }
 
   /**

package/src/trackers/impressionObserver/utils.ts

@@ -4,6 +4,6 @@ import { ISettings } from '../../types';
 /**
  * Storage is async if mode is consumer or partial consumer
  */
-export function isStorageSync(settings: ISettings) {
+export function isStorageSync(settings: Pick<ISettings, 'mode'>) {
   return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
 }

package/src/utils/redis/RedisMock.ts

@@ -8,10 +8,13 @@ function asyncFunction(data: any): Promise<any> {
 }
 
 const IDENTITY_METHODS: string[] = [];
-const ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
+const ASYNC_METHODS = ['rpush', 'hincrby'];
+const PIPELINE_METHODS = ['rpush', 'hincrby'];
 
 export class RedisMock {
 
+  private pipelineMethods: any = { exec: jest.fn(asyncFunction) };
+
   constructor() {
     IDENTITY_METHODS.forEach(method => {
       this[method] = jest.fn(identityFunction);
@@ -19,5 +22,10 @@ export class RedisMock {
     ASYNC_METHODS.forEach(method => {
       this[method] = jest.fn(asyncFunction);
     });
+    PIPELINE_METHODS.forEach(method => {
+      this.pipelineMethods[method] = this[method];
+    });
+
+    this.pipeline = jest.fn(() => { return this.pipelineMethods; });
   }
 }

package/types/sdkFactory/types.d.ts

@@ -1,9 +1,9 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
+import type { sdkManagerFactory } from '../sdkManager';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
-import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
+import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
@@ -66,7 +66,7 @@ export interface ISdkFactoryParams {
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker) => ISplitApi;
     syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager;
-    sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
+    sdkManagerFactory: typeof sdkManagerFactory;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;

package/types/sdkManager/index.d.ts

@@ -1,5 +1,4 @@
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
-export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(log: ILogger, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;
+import { ISettings, SplitIO } from '../types';
+export declare function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplitsCacheAsync>(settings: Pick<ISettings, 'log' | 'mode'>, splits: TSplitCache, { readinessManager, sdkStatus }: ISdkReadinessManager): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager;

package/types/storages/inRedis/RedisAdapter.d.ts

@@ -9,7 +9,6 @@ export declare class RedisAdapter extends ioredis {
     private _notReadyCommandsQueue?;
     private _runningCommands;
     constructor(log: ILogger, storageSettings?: Record<string, any>);
-    pipelineExec(commands?: (string | number)[][]): Promise<Array<[Error | null, any]>>;
     _listenToEvents(): void;
     _setTimeoutWrappers(): void;
     _setDisconnectWrapper(): void;
@@ -21,5 +20,5 @@ export declare class RedisAdapter extends ioredis {
     /**
      * Parses the options into what we care about.
      */
-    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }?: Record<string, any>): object;
+    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
 }

package/types/storages/inRedis/SegmentsCacheInRedis.d.ts

@@ -14,5 +14,5 @@ export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     getChangeNumber(name: string): Promise<number>;
     registerSegments(segments: string[]): Promise<boolean>;
     getRegisteredSegments(): Promise<string[]>;
-    clear(): Promise<boolean>;
+    clear(): Promise<void>;
 }

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -77,7 +77,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     /**
      * Get list of feature flag names related to a given list of flag set names.
      * The returned promise is resolved with the list of feature flag names per flag set,
-     * or rejected if the pipelined redis operation fails.
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
     */
     getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**
@@ -87,12 +87,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * It will never be rejected.
      */
     trafficTypeExists(trafficType: string): Promise<boolean>;
-    /**
-     * Delete everything in the current database.
-     *
-     * @NOTE documentation says it never fails.
-     */
-    clear(): Promise<boolean>;
+    clear(): Promise<void>;
     /**
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.

package/types/trackers/impressionObserver/utils.d.ts

@@ -2,4 +2,4 @@ import { ISettings } from '../../types';
 /**
  * Storage is async if mode is consumer or partial consumer
  */
-export declare function isStorageSync(settings: ISettings): boolean;
+export declare function isStorageSync(settings: Pick<ISettings, 'mode'>): boolean;

package/types/utils/redis/RedisMock.d.ts

@@ -1,3 +1,4 @@
 export declare class RedisMock {
+    private pipelineMethods;
     constructor();
 }