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

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -1,7 +1,8 @@
-import { __extends } from "tslib";
+import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { _Set, returnListDifference } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -18,11 +19,12 @@ function processPipelineAnswer(results) {
  */
 var SplitsCacheInRedis = /** @class */ (function (_super) {
     __extends(SplitsCacheInRedis, _super);
-    function SplitsCacheInRedis(log, keys, redis) {
+    function SplitsCacheInRedis(log, keys, redis, splitFiltersValidation) {
         var _this = _super.call(this) || this;
         _this.log = log;
         _this.redis = redis;
         _this.keys = keys;
+        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         // 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', function (e) {
@@ -45,6 +47,18 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
         return this.redis.incr(ttKey);
     };
+    SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
+        var _this = this;
+        var removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+        var addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+        if (this.flagSetsFilter.length > 0) {
+            addToFlagSets = addToFlagSets.filter(function (flagSet) {
+                return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });
+            });
+        }
+        var items = [featureFlagName];
+        return Promise.all(__spreadArray(__spreadArray([], removeFromFlagSets.map(function (flagSetName) { return _this.redis.srem(_this.keys.buildFlagSetKey(flagSetName), items); }), true), addToFlagSets.map(function (flagSetName) { return _this.redis.sadd(_this.keys.buildFlagSetKey(flagSetName), items); }), true));
+    };
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -54,16 +68,16 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         var splitKey = this.keys.buildSplitKey(name);
         return this.redis.get(splitKey).then(function (splitFromStorage) {
-            // handling parsing errors
-            var parsedPreviousSplit, newStringifiedSplit;
+            // handling parsing error
+            var parsedPreviousSplit, stringifiedNewSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                newStringifiedSplit = JSON.stringify(split);
+                stringifiedNewSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing feature flag definition: ' + e);
             }
-            return _this.redis.set(splitKey, newStringifiedSplit).then(function () {
+            return _this.redis.set(splitKey, stringifiedNewSplit).then(function () {
                 // avoid unnecessary increment/decrement operations
                 if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
                     return;
@@ -72,7 +86,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                     if (parsedPreviousSplit)
                         return _this._decrementCounts(parsedPreviousSplit);
                 });
-            });
+            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
         }).then(function () { return true; });
     };
     /**
@@ -93,8 +107,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                _this._decrementCounts(split);
+                return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
             }
+        }).then(function () {
             return _this.redis.del(_this.keys.buildSplitKey(name));
         });
     };
@@ -153,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.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(function (listOfKeys) { return _this.redis.pipelineExec(listOfKeys.map(function (k) { return ['get', k]; })); })
             .then(processPipelineAnswer)
             .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
             return JSON.parse(splitDefinition);
@@ -169,14 +184,20 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     * @todo this is a no-op method to be implemented
+     * 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.
     */
-    SplitsCacheInRedis.prototype.getNamesByFlagSets = function () {
-        this.log.error(LOG_PREFIX + 'ByFlagSet/s evaluations are not supported with Redis storage yet.');
-        return Promise.reject();
+    SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        return this.redis.pipelineExec(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; }))
+            .then(function (results) { return 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); }); });
     };
     /**
      * Check traffic type existence.
@@ -193,13 +214,13 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return false; // if entry doesn't exist, means that TT doesn't exist
             ttCount = parseInt(ttCount, 10);
             if (!isFiniteNumber(ttCount) || ttCount < 0) {
-                _this.log.info(LOG_PREFIX + ("Could not validate traffic type existance of " + trafficType + " due to data corruption of some sorts."));
+                _this.log.info(LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to data corruption of some sorts."));
                 return false;
             }
             return ttCount > 0;
         })
             .catch(function (e) {
-            _this.log.error(LOG_PREFIX + ("Could not validate traffic type existance of " + trafficType + " due to an error: " + e + "."));
+            _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;
         });

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -158,15 +158,15 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if any wrapper operation fails.
-    */
+     * 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.
+     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
+     */
     SplitsCachePluggable.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
         return Promise.all(flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.wrapper.getItems(flagSetKey);
+            return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
         })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
     };
     /**

package/esm/utils/inputValidation/index.js

@@ -8,6 +8,6 @@ export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
-export { validateSplitExistance } from './splitExistance';
-export { validateTrafficTypeExistance } from './trafficTypeExistance';
+export { validateSplitExistence } from './splitExistence';
+export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';

package/esm/utils/inputValidation/{splitExistance.js → splitExistence.js}

@@ -4,7 +4,7 @@ import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
  * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
-export function validateSplitExistance(log, readinessManager, splitName, labelOrSplitObj, method) {
+export function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
     if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
         if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null) {
             log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);

package/esm/utils/inputValidation/{trafficTypeExistance.js → trafficTypeExistence.js}

@@ -1,13 +1,13 @@
 import { thenable } from '../promise/thenable';
 import { LOCALHOST_MODE } from '../constants';
 import { WARN_NOT_EXISTENT_TT } from '../../logger/constants';
-function logTTExistanceWarning(log, maybeTT, method) {
+function logTTExistenceWarning(log, maybeTT, method) {
     log.warn(WARN_NOT_EXISTENT_TT, [method, maybeTT]);
 }
 /**
  * Separated from the previous method since on some cases it'll be async.
  */
-export function validateTrafficTypeExistance(log, readinessManager, splitsCache, mode, maybeTT, method) {
+export function validateTrafficTypeExistence(log, readinessManager, splitsCache, mode, maybeTT, method) {
     // If not ready or in localhost mode, we won't run the validation
     if (!readinessManager.isReady() || mode === LOCALHOST_MODE)
         return true;
@@ -15,13 +15,13 @@ export function validateTrafficTypeExistance(log, readinessManager, splitsCache,
     if (thenable(res)) {
         return res.then(function (isValid) {
             if (!isValid)
-                logTTExistanceWarning(log, maybeTT, method);
+                logTTExistenceWarning(log, maybeTT, method);
             return isValid; // propagate result
         });
     }
     else {
         if (!res)
-            logTTExistanceWarning(log, maybeTT, method);
+            logTTExistenceWarning(log, maybeTT, method);
         return res;
     }
 }

package/esm/utils/redis/RedisMock.js

@@ -6,22 +6,16 @@ function asyncFunction(data) {
     return Promise.resolve(data);
 }
 var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby'];
-var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
 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.0",
+  "version": "1.12.1-rc.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -22,7 +22,7 @@
     "build": "npm run build:cjs && npm run build:esm",
     "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
-    "test": "jest --runInBand",
+    "test": "jest",
     "test:coverage": "jest --coverage",
     "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",

package/src/sdkClient/client.ts

@@ -1,8 +1,8 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
-import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
+import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
@@ -133,7 +133,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const { treatment, label, changeNumber, config = null } = evaluation;
     log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
 
-    if (validateSplitExistance(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+    if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
       log.info(IMPRESSION_QUEUEING);
       queue.push({
         feature: featureFlagName,
@@ -171,7 +171,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-    validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
+    validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
 
     const result = eventTracker.track(eventData, size);
 

package/src/sdkManager/index.ts

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
@@ -71,12 +71,12 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
 
         if (thenable(split)) {
           return split.catch(() => null).then(result => { // handle possible rejections when using pluggable storage
-            validateSplitExistance(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+            validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
             return objectToView(result);
           });
         }
 
-        validateSplitExistance(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+        validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
 
         return objectToView(split);
       },

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -260,7 +260,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   getNamesByFlagSets(flagSets: string[]): ISet<string>[] {
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
       return new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
     });
@@ -275,10 +275,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
       const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
 
-      let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-      if (!flagSetFromLocalStorage) flagSetFromLocalStorage = '[]';
+      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-      const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+      const flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
       flagSetCache.add(featureFlag.name);
 
       localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
@@ -296,7 +295,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private removeNames(flagSetName: string, featureFlagName: string) {
     const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
 
-    let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+    const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
     if (!flagSetFromLocalStorage) return;
 

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -1,19 +1,19 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { Redis } from 'ioredis';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
+import type { RedisAdapter } from './RedisAdapter';
 
 export class EventsCacheInRedis implements IEventsCacheAsync {
 
   private readonly log: ILogger;
   private readonly key: string;
-  private readonly redis: Redis;
+  private readonly redis: RedisAdapter;
   private readonly metadata: IMetadata;
 
-  constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata) {
+  constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata) {
     this.log = log;
     this.key = key;
     this.redis = redis;

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -1,19 +1,19 @@
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { ImpressionCountsPayload } from '../../sync/submitters/types';
 import { forOwn } from '../../utils/lang';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
+import type { RedisAdapter } from './RedisAdapter';
 
 export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
 
   private readonly log: ILogger;
   private readonly key: string;
-  private readonly redis: Redis;
+  private readonly redis: RedisAdapter;
   private readonly refreshRate: number;
   private intervalId: any;
 
-  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
+  constructor(log: ILogger, key: string, redis: RedisAdapter, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
     super(impressionCountsCacheSize);
     this.log = log;
     this.key = key;
@@ -27,11 +27,7 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
     const keys = Object.keys(counts);
     if (!keys.length) return Promise.resolve(false);
 
-    const pipeline = this.redis.pipeline();
-    keys.forEach(key => {
-      pipeline.hincrby(this.key, key, counts[key]);
-    });
-    return pipeline.exec()
+    return this.redis.pipelineExec(keys.map(key => ['hincrby', this.key, key, counts[key]]))
       .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/ImpressionsCacheInRedis.ts

@@ -1,10 +1,10 @@
 import { IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
 import { impressionsToJSON } from '../utils';
+import type { RedisAdapter } from './RedisAdapter';
 
 const IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 
@@ -12,10 +12,10 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
 
   private readonly log: ILogger;
   private readonly key: string;
-  private readonly redis: Redis;
+  private readonly redis: RedisAdapter;
   private readonly metadata: IMetadata;
 
-  constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata) {
+  constructor(log: ILogger, key: string, redis: RedisAdapter, metadata: IMetadata) {
     this.log = log;
     this.key = key;
     this.redis = redis;

package/src/storages/inRedis/RedisAdapter.ts

@@ -8,7 +8,7 @@ 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', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
+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'];
 
 // 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 +38,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 +52,15 @@ 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;
       this.log.info(LOG_PREFIX + `Redis connection established. Queued commands: ${commandsCount}.`);
+
       this._notReadyCommandsQueue && this._notReadyCommandsQueue.forEach(queued => {
         this.log.info(LOG_PREFIX + `Executing queued ${queued.name} command.`);
         queued.command().then(queued.resolve).catch(queued.reject);
@@ -71,29 +76,28 @@ export class RedisAdapter extends ioredis {
   _setTimeoutWrappers() {
     const instance: Record<string, any> = this;
 
-    METHODS_TO_PROMISE_WRAP.forEach(method => {
-      const originalMethod = instance[method];
+    METHODS_TO_PROMISE_WRAP.forEach(methodName => {
+      const originalMethod = instance[methodName];
 
-      instance[method] = function () {
+      instance[methodName] = function () {
         const params = arguments;
 
         function commandWrapper() {
-          instance.log.debug(LOG_PREFIX + `Executing ${method}.`);
-          // Return original method
+          instance.log.debug(`${LOG_PREFIX}Executing ${methodName}.`);
           const result = originalMethod.apply(instance, 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 = function () {
+            const cleanUpRunningCommandsCb = () => {
               instance._runningCommands.delete(result);
             };
             // Both success and error remove from queue.
             result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
 
             return timeout(instance._options.operationTimeout, result).catch(err => {
-              instance.log.error(LOG_PREFIX + `${method} operation threw an error or exceeded configured timeout of ${instance._options.operationTimeout}ms. Message: ${err}`);
+              instance.log.error(`${LOG_PREFIX}${methodName} operation threw an error or exceeded configured timeout of ${instance._options.operationTimeout}ms. Message: ${err}`);
               // Handling is not the adapter responsibility.
               throw err;
             });
@@ -108,7 +112,7 @@ export class RedisAdapter extends ioredis {
               resolve: res,
               reject: rej,
               command: commandWrapper,
-              name: method.toUpperCase()
+              name: methodName.toUpperCase()
             });
           });
         } else {
@@ -124,7 +128,7 @@ export class RedisAdapter extends ioredis {
 
     instance.disconnect = function disconnect(...params: []) {
 
-      setTimeout(function deferedDisconnect() {
+      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.`);
 
@@ -177,7 +181,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

@@ -1,17 +1,17 @@
-import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from '../inLocalStorage/constants';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
+import type { RedisAdapter } from './RedisAdapter';
 
 export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
 
   private readonly log: ILogger;
-  private readonly redis: Redis;
+  private readonly redis: RedisAdapter;
   private readonly keys: KeyBuilderSS;
 
-  constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis) {
+  constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter) {
     this.log = log;
     this.redis = redis;
     this.keys = keys;