@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/cjs/storages/inRedis/ImpressionsCacheInRedis.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImpressionsCacheInRedis = void 0;
-var utils_1 = require("../utils");
-var IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
-var ImpressionsCacheInRedis = /** @class */ (function () {
-    function ImpressionsCacheInRedis(log, key, redis, metadata) {
-        this.log = log;
-        this.key = key;
-        this.redis = redis;
-        this.metadata = metadata;
-    }
-    ImpressionsCacheInRedis.prototype.track = function (impressions) {
-        var _this = this;
-        return this.redis.rpush(this.key, (0, utils_1.impressionsToJSON)(impressions, this.metadata)).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);
-            }
-        });
-    };
-    ImpressionsCacheInRedis.prototype.count = function () {
-        return this.redis.llen(this.key).catch(function () { return 0; });
-    };
-    ImpressionsCacheInRedis.prototype.drop = function (count) {
-        if (!count)
-            return this.redis.del(this.key);
-        return this.redis.ltrim(this.key, count, -1);
-    };
-    ImpressionsCacheInRedis.prototype.popNWithMetadata = function (count) {
-        var _this = this;
-        return this.redis.lrange(this.key, 0, count - 1).then(function (items) {
-            return _this.redis.ltrim(_this.key, items.length, -1).then(function () {
-                // 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
-                // popped correctly. This will result in impressions getting lost but will prevent the queue from taking
-                // a huge amount of memory.
-                _this.redis.expire(_this.key, IMPRESSIONS_TTL_REFRESH).catch(function () { }); // noop catch handler
-                return items.map(function (item) { return JSON.parse(item); });
-            });
-        });
-    };
-    return ImpressionsCacheInRedis;
-}());
-exports.ImpressionsCacheInRedis = ImpressionsCacheInRedis;

package/cjs/storages/inRedis/RBSegmentsCacheInRedis.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBSegmentsCacheInRedis = void 0;
-var lang_1 = require("../../utils/lang");
-var constants_1 = require("./constants");
-var sets_1 = require("../../utils/lang/sets");
-var RBSegmentsCacheInRedis = /** @class */ (function () {
-    function RBSegmentsCacheInRedis(log, keys, redis) {
-        this.log = log;
-        this.keys = keys;
-        this.redis = redis;
-    }
-    RBSegmentsCacheInRedis.prototype.get = function (name) {
-        return this.redis.get(this.keys.buildRBSegmentKey(name))
-            .then(function (maybeRBSegment) { return maybeRBSegment && JSON.parse(maybeRBSegment); });
-    };
-    RBSegmentsCacheInRedis.prototype.getNames = function () {
-        var _this = this;
-        return this.redis.keys(this.keys.searchPatternForRBSegmentKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
-    };
-    RBSegmentsCacheInRedis.prototype.contains = function (names) {
-        var namesArray = (0, sets_1.setToArray)(names);
-        return this.getNames().then(function (namesInStorage) {
-            return namesArray.every(function (name) { return namesInStorage.includes(name); });
-        });
-    };
-    RBSegmentsCacheInRedis.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (toAdd) {
-                var key = _this.keys.buildRBSegmentKey(toAdd.name);
-                var stringifiedNewRBSegment = JSON.stringify(toAdd);
-                return _this.redis.set(key, stringifiedNewRBSegment).then(function () { return true; });
-            })),
-            Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove.name);
-                return _this.redis.del(key).then(function (status) { return status === 1; });
-            }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    RBSegmentsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
-    };
-    RBSegmentsCacheInRedis.prototype.getChangeNumber = function () {
-        var _this = this;
-        return this.redis.get(this.keys.buildRBSegmentsTillKey()).then(function (value) {
-            var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
-        }).catch(function (e) {
-            _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
-            return -1;
-        });
-    };
-    // @TODO implement if required by DataLoader or producer mode
-    RBSegmentsCacheInRedis.prototype.clear = function () {
-        return Promise.resolve();
-    };
-    return RBSegmentsCacheInRedis;
-}());
-exports.RBSegmentsCacheInRedis = RBSegmentsCacheInRedis;

package/cjs/storages/inRedis/RedisAdapter.js

@@ -1,195 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisAdapter = void 0;
-var tslib_1 = require("tslib");
-var ioredis_1 = (0, tslib_1.__importDefault)(require("ioredis"));
-var lang_1 = require("../../utils/lang");
-var thenable_1 = require("../../utils/promise/thenable");
-var timeout_1 = require("../../utils/promise/timeout");
-var sets_1 = require("../../utils/lang/sets");
-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'];
-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,
-    operationTimeout: 5000
-};
-// Library specifics.
-var DEFAULT_LIBRARY_OPTIONS = {
-    enableOfflineQueue: false,
-    connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false
-};
-/**
- * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- */
-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
-        _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;
-    }
-    RedisAdapter.prototype._listenToEvents = function () {
-        var _this = this;
-        this.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) {
-                _this.log.info(LOG_PREFIX + ("Executing queued " + queued.name + " command."));
-                queued.command().then(queued.resolve).catch(queued.reject);
-            });
-            // 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.log.info(LOG_PREFIX + 'Redis connection closed.');
-        });
-    };
-    RedisAdapter.prototype._setTimeoutWrappers = function () {
-        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.
-            return function () {
-                var params = arguments;
-                var caller = this;
-                function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
-                    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.
-                        instance._runningCommands.add(result);
-                        var cleanUpRunningCommandsCb = function () {
-                            instance._runningCommands.delete(result);
-                        };
-                        // Both success and error remove from queue.
-                        result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
-                        return (0, timeout_1.timeout)(instance._options.operationTimeout, result).catch(function (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;
-                        });
-                    }
-                    return result;
-                }
-                if (instance._notReadyCommandsQueue) {
-                    return new Promise(function (resolve, reject) {
-                        instance._notReadyCommandsQueue.unshift({
-                            resolve: resolve,
-                            reject: reject,
-                            command: commandWrapper,
-                            name: methodName.toUpperCase()
-                        });
-                    });
-                }
-                else {
-                    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 () {
-        var instance = this;
-        var originalMethod = instance.disconnect;
-        instance.disconnect = function disconnect() {
-            var params = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                params[_i] = arguments[_i];
-            }
-            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."));
-                    Promise.all((0, sets_1.setToArray)(instance._runningCommands))
-                        .then(function () {
-                        instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
-                        originalMethod.apply(instance, params);
-                    })
-                        .catch(function (e) {
-                        instance.log.warn(LOG_PREFIX + ("Pending commands finished with error: " + e + ". Proceeding with disconnection."));
-                        originalMethod.apply(instance, params);
-                    });
-                }
-                else {
-                    instance.log.debug(LOG_PREFIX + 'No commands pending execution, disconnect.');
-                    // Nothing pending, just proceed.
-                    originalMethod.apply(instance, params);
-                }
-            }, 10);
-        };
-    };
-    /**
-     * Receives the options and returns an array of parameters for the ioredis constructor.
-     * Keeping both redis setup options for backwards compatibility.
-     */
-    RedisAdapter._defineLibrarySettings = function (options) {
-        var opts = (0, lang_1.merge)({}, DEFAULT_LIBRARY_OPTIONS);
-        var result = [opts];
-        if (!(0, lang_1.isString)(options.url)) {
-            (0, lang_1.merge)(opts, {
-                host: options.host,
-                port: options.port,
-                db: options.db,
-                password: options.pass
-            });
-        }
-        else { // If it IS the string URL, that'll be the first param for ioredis.
-            result.unshift(options.url);
-        }
-        if (options.connectionTimeout) {
-            (0, lang_1.merge)(opts, { connectTimeout: options.connectionTimeout });
-        }
-        if (options.tls) {
-            (0, lang_1.merge)(opts, { tls: options.tls });
-        }
-        return result;
-    };
-    /**
-     * Parses the options into what we care about.
-     */
-    RedisAdapter._defineOptions = function (_a) {
-        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,
-            url: url,
-            host: host,
-            port: port,
-            db: db,
-            pass: pass,
-            tls: tls
-        };
-        return (0, lang_1.merge)({}, DEFAULT_OPTIONS, parsedOptions);
-    };
-    return RedisAdapter;
-}(ioredis_1.default));
-exports.RedisAdapter = RedisAdapter;

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SegmentsCacheInRedis = void 0;
-var lang_1 = require("../../utils/lang");
-var constants_1 = require("../inLocalStorage/constants");
-var SegmentsCacheInRedis = /** @class */ (function () {
-    function SegmentsCacheInRedis(log, keys, redis) {
-        this.log = log;
-        this.redis = redis;
-        this.keys = keys;
-    }
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., Redis operation fails).
-     */
-    SegmentsCacheInRedis.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        return Promise.all([
-            addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
-            removedKeys.length && this.redis.srem(segmentKey, removedKeys),
-            this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
-        ]).then(function () {
-            return addedKeys.length > 0 || removedKeys.length > 0;
-        });
-    };
-    SegmentsCacheInRedis.prototype.isInSegment = function (name, key) {
-        return this.redis.sismember(this.keys.buildSegmentNameKey(name), key).then(function (matches) { return matches !== 0; });
-    };
-    SegmentsCacheInRedis.prototype.getChangeNumber = function (name) {
-        var _this = this;
-        return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
-            var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
-        }).catch(function (e) {
-            _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return undefined;
-        });
-    };
-    SegmentsCacheInRedis.prototype.registerSegments = function (segments) {
-        if (segments.length) {
-            return this.redis.sadd(this.keys.buildRegisteredSegmentsKey(), segments).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
-    };
-    SegmentsCacheInRedis.prototype.getRegisteredSegments = function () {
-        return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
-    };
-    // @TODO remove or implement. It is not being used.
-    SegmentsCacheInRedis.prototype.clear = function () {
-        return Promise.resolve();
-    };
-    return SegmentsCacheInRedis;
-}());
-exports.SegmentsCacheInRedis = SegmentsCacheInRedis;

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SplitsCacheInRedis = void 0;
-var tslib_1 = require("tslib");
-var lang_1 = require("../../utils/lang");
-var constants_1 = require("./constants");
-var AbstractSplitsCacheAsync_1 = require("../AbstractSplitsCacheAsync");
-var sets_1 = require("../../utils/lang/sets");
-/**
- * Discard errors for an answer of multiple operations.
- */
-function processPipelineAnswer(results) {
-    return results.reduce(function (accum, errValuePair) {
-        if (errValuePair[0] === null)
-            accum.push(errValuePair[1]);
-        return accum;
-    }, []);
-}
-/**
- * ISplitsCacheAsync implementation that stores split definitions in Redis.
- * Supported by Node.js
- */
-var SplitsCacheInRedis = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(SplitsCacheInRedis, _super);
-    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) {
-            _this.redisError = e;
-        });
-        _this.redis.on('connect', function () {
-            _this.redisError = undefined;
-        });
-        return _this;
-    }
-    SplitsCacheInRedis.prototype._decrementCounts = function (split) {
-        var _this = this;
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.redis.decr(ttKey).then(function (count) {
-            if (count === 0)
-                return _this.redis.del(ttKey);
-        });
-    };
-    SplitsCacheInRedis.prototype._incrementCounts = function (split) {
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.redis.incr(ttKey);
-    };
-    SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
-        var _this = this;
-        var removeFromFlagSets = (0, sets_1.returnDifference)(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = (0, sets_1.returnDifference)(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((0, tslib_1.__spreadArray)((0, tslib_1.__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
-     * or rejected if it fails (e.g., redis operation fails)
-     */
-    SplitsCacheInRedis.prototype.addSplit = function (split) {
-        var _this = this;
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        return this.redis.get(splitKey).then(function (splitFromStorage) {
-            // handling parsing error
-            var parsedPreviousSplit, stringifiedNewSplit;
-            try {
-                parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                stringifiedNewSplit = JSON.stringify(split);
-            }
-            catch (e) {
-                throw new Error('Error parsing feature flag definition: ' + e);
-            }
-            return _this.redis.set(splitKey, stringifiedNewSplit).then(function () {
-                // avoid unnecessary increment/decrement operations
-                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
-                    return;
-                // update traffic type counts
-                return _this._incrementCounts(split).then(function () {
-                    if (parsedPreviousSplit)
-                        return _this._decrementCounts(parsedPreviousSplit);
-                });
-            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
-        }).then(function () { return true; });
-    };
-    /**
-     * Remove a given split.
-     * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
-     * or rejected if it fails (e.g., redis operation fails).
-     */
-    SplitsCacheInRedis.prototype.removeSplit = function (name) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split) {
-                return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
-            }
-        }).then(function () {
-            return _this.redis.del(_this.keys.buildSplitKey(name)).then(function (status) { return status === 1; });
-        });
-    };
-    /**
-     * Get split definition or null if it's not defined.
-     * Returned promise is rejected if redis operation fails.
-     */
-    SplitsCacheInRedis.prototype.getSplit = function (name) {
-        if (this.redisError) {
-            this.log.error(constants_1.LOG_PREFIX + this.redisError);
-            return Promise.reject(this.redisError);
-        }
-        return this.redis.get(this.keys.buildSplitKey(name))
-            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
-    };
-    /**
-     * Set till number.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails.
-     */
-    SplitsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
-    };
-    /**
-     * Get till number or -1 if it's not defined.
-     * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a redis operation fails.
-     * The promise will never be rejected.
-     */
-    SplitsCacheInRedis.prototype.getChangeNumber = function () {
-        var _this = this;
-        return this.redis.get(this.keys.buildSplitsTillKey()).then(function (value) {
-            var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
-        }).catch(function (e) {
-            _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
-            return -1;
-        });
-    };
-    /**
-     * Get list of all split definitions.
-     * The returned promise is resolved with the list of split definitions,
-     * or rejected if redis operation fails.
-     */
-    // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
-    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(processPipelineAnswer)
-            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
-            return JSON.parse(splitDefinition);
-        }); });
-    };
-    /**
-     * Get list of split names.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if redis operation fails.
-     */
-    SplitsCacheInRedis.prototype.getSplitNames = function () {
-        var _this = this;
-        return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
-    };
-    /**
-     * 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 (e.g., timeout).
-    */
-    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) {
-            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); }); });
-    };
-    /**
-     * Check traffic type existence.
-     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
-     * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
-     * It will never be rejected.
-     */
-    SplitsCacheInRedis.prototype.trafficTypeExists = function (trafficType) {
-        var _this = this;
-        // If there is a number there should be > 0, otherwise the TT is considered as not existent.
-        return this.redis.get(this.keys.buildTrafficTypeKey(trafficType))
-            .then(function (ttCount) {
-            if (ttCount === null)
-                return false; // if entry doesn't exist, means that TT doesn't exist
-            ttCount = parseInt(ttCount, 10);
-            if (!(0, lang_1.isFiniteNumber)(ttCount) || ttCount < 0) {
-                _this.log.info(constants_1.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(constants_1.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;
-        });
-    };
-    // @TODO remove or implement. It is not being used.
-    SplitsCacheInRedis.prototype.clear = function () {
-        return Promise.resolve();
-    };
-    /**
-     * Fetches multiple splits definitions.
-     * Returned promise is rejected if redis operation fails.
-     */
-    SplitsCacheInRedis.prototype.getSplits = function (names) {
-        var _a;
-        var _this = this;
-        if (this.redisError) {
-            this.log.error(constants_1.LOG_PREFIX + this.redisError);
-            return Promise.reject(this.redisError);
-        }
-        var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
-        return (_a = this.redis).mget.apply(_a, keys).then(function (splitDefinitions) {
-            var splits = {};
-            names.forEach(function (name, idx) {
-                var split = splitDefinitions[idx];
-                splits[name] = split && JSON.parse(split);
-            });
-            return Promise.resolve(splits);
-        })
-            .catch(function (e) {
-            _this.log.error(constants_1.LOG_PREFIX + ("Could not grab feature flags due to an error: " + e + "."));
-            return Promise.reject(e);
-        });
-    };
-    return SplitsCacheInRedis;
-}(AbstractSplitsCacheAsync_1.AbstractSplitsCacheAsync));
-exports.SplitsCacheInRedis = SplitsCacheInRedis;