@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/cjs/storages/inRedis/RedisAdapter.js

@@ -49,7 +49,7 @@ var RedisAdapter = /** @class */ (function () {
         this._runningCommands = new Set();
         // Instantiate the client using the dynamic constructor
         var librarySettings = RedisAdapter._defineLibrarySettings(options);
-        this.client = new (RedisConstructor.bind.apply(RedisConstructor, (0, tslib_1.__spreadArray)([void 0], librarySettings, false)))();
+        this.client = new (RedisConstructor.bind.apply(RedisConstructor, tslib_1.__spreadArray([void 0], librarySettings, false)))();
         this._listenToEvents();
         this._setTimeoutWrappers();
         this._setDisconnectWrapper();
@@ -61,9 +61,9 @@ var RedisAdapter = /** @class */ (function () {
         var _this = this;
         this.client.once('ready', function () {
             var commandsCount = _this._notReadyCommandsQueue ? _this._notReadyCommandsQueue.length : 0;
-            _this.log.info(LOG_PREFIX + ("Redis connection established. Queued commands: " + commandsCount + "."));
+            _this.log.info(LOG_PREFIX + "Redis connection established. Queued commands: ".concat(commandsCount, "."));
             _this._notReadyCommandsQueue && _this._notReadyCommandsQueue.forEach(function (queued) {
-                _this.log.info(LOG_PREFIX + ("Executing queued " + queued.name + " command."));
+                _this.log.info(LOG_PREFIX + "Executing queued ".concat(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.
@@ -85,7 +85,7 @@ var RedisAdapter = /** @class */ (function () {
                     params[_i] = arguments[_i];
                 }
                 function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
+                    instance.log.debug("".concat(LOG_PREFIX, "Executing ").concat(methodName, "."));
                     var result = originalMethod.apply(bindTarget, params);
                     if ((0, thenable_1.thenable)(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
@@ -97,7 +97,7 @@ var RedisAdapter = /** @class */ (function () {
                         // 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);
+                            instance.log.error("".concat(LOG_PREFIX).concat(methodName, " operation threw an error or exceeded configured timeout of ").concat(instance._options.operationTimeout, "ms. Message: ").concat(err));
                             // Handling is not the adapter responsibility.
                             throw err;
                         });
@@ -135,7 +135,7 @@ var RedisAdapter = /** @class */ (function () {
                 }
                 var res = originalFn.apply(instance.client, args);
                 var originalExec = res.exec;
-                res.exec = wrapCommand(originalExec, methodName + ".exec", res);
+                res.exec = wrapCommand(originalExec, "".concat(methodName, ".exec"), res);
                 return res;
             };
         });
@@ -150,14 +150,14 @@ var RedisAdapter = /** @class */ (function () {
             }
             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."));
+                    instance.log.info(LOG_PREFIX + "Attempting to disconnect but there are ".concat(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.client, params);
                     })
                         .catch(function (e) {
-                        instance.log.warn(LOG_PREFIX + ("Pending commands finished with error: " + e + ". Proceeding with disconnection."));
+                        instance.log.warn(LOG_PREFIX + "Pending commands finished with error: ".concat(e, ". Proceeding with disconnection."));
                         originalMethod.apply(instance.client, params);
                     });
                 }

package/cjs/storages/inRedis/TelemetryCacheInRedis.js

@@ -45,17 +45,17 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(latencies).forEach(function (field) {
                 var parsedField = (0, utils_1.parseLatencyField)(field);
                 if ((0, lang_1.isString)(parsedField)) {
-                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid latency field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var count = parseInt(latencies[field]);
                 if ((0, lang_1.isNaNNumber)(count)) {
-                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
+                    _this.log.error("Ignoring latency with invalid count: ".concat(latencies[field]));
                     return;
                 }
                 var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
                 if (bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT) {
-                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    _this.log.error("Ignoring latency with invalid bucket: ".concat(bucket));
                     return;
                 }
                 var methodLatencies = result.get(metadata) || {};
@@ -77,12 +77,12 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(exceptions).forEach(function (field) {
                 var parsedField = (0, utils_1.parseExceptionField)(field);
                 if ((0, lang_1.isString)(parsedField)) {
-                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid exception field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var count = parseInt(exceptions[field]);
                 if ((0, lang_1.isNaNNumber)(count)) {
-                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
+                    _this.log.error("Ignoring exception with invalid count: ".concat(exceptions[field]));
                     return;
                 }
                 var metadata = parsedField[0], method = parsedField[1];
@@ -104,7 +104,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(configs).forEach(function (field) {
                 var parsedField = (0, utils_1.parseMetadata)(field);
                 if ((0, lang_1.isString)(parsedField)) {
-                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid config field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var metadata = parsedField[0];
@@ -113,7 +113,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
                     result.set(metadata, config);
                 }
                 catch (e) {
-                    _this.log.error("Ignoring invalid config: " + configs[field]);
+                    _this.log.error("Ignoring invalid config: ".concat(configs[field]));
                 }
             });
             return _this.redis.del(_this.keys.initPrefix).then(function () { return result; });

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -7,7 +7,7 @@ var constants_1 = require("./constants");
 var constants_2 = require("./constants");
 var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(UniqueKeysCacheInRedis, _super);
+    tslib_1.__extends(UniqueKeysCacheInRedis, _super);
     function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
         if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
         if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
@@ -34,14 +34,14 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
             return JSON.stringify(uniqueKeysPayload);
         });
         this.clear();
-        return (_a = this.redis).rpush.apply(_a, (0, tslib_1.__spreadArray)([this.key], uniqueKeysArray, false)).then(function (data) {
+        return (_a = this.redis).rpush.apply(_a, tslib_1.__spreadArray([this.key], uniqueKeysArray, false)).then(function (data) {
             // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
             if (data === featureNames.length) {
                 return _this.redis.expire(_this.key, constants_1.TTL_REFRESH);
             }
         })
             .catch(function (err) {
-            _this.log.error(constants_2.LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            _this.log.error("".concat(constants_2.LOG_PREFIX, "Error in uniqueKeys pipeline: ").concat(err, "."));
             return false;
         });
     };

package/cjs/storages/inRedis/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InRedisStorage = void 0;
 var KeyBuilder_1 = require("../KeyBuilder");
 var KeyBuilderSS_1 = require("../KeyBuilderSS");
-var SplitsCacheInRedis_1 = require("./SplitsCacheInRedis");
+var DefinitionsCacheInRedis_1 = require("./DefinitionsCacheInRedis");
 var SegmentsCacheInRedis_1 = require("./SegmentsCacheInRedis");
 var ImpressionsCacheInRedis_1 = require("./ImpressionsCacheInRedis");
 var EventsCacheInRedis_1 = require("./EventsCacheInRedis");
@@ -48,7 +48,7 @@ function InRedisStorage(options) {
             telemetry.recordConfig();
         });
         return {
-            splits: new SplitsCacheInRedis_1.SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCacheInRedis_1.DefinitionsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCacheInRedis_1.RBSegmentsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis_1.SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis_1.ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),

package/cjs/storages/pluggable/DefinitionsCachePluggable.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionsCachePluggable = void 0;
+var tslib_1 = require("tslib");
+var lang_1 = require("../../utils/lang");
+var constants_1 = require("./constants");
+var AbstractDefinitionsCacheAsync_1 = require("../AbstractDefinitionsCacheAsync");
+var sets_1 = require("../../utils/lang/sets");
+/**
+ * IDefinitionsCacheAsync implementation for pluggable storages.
+ */
+var DefinitionsCachePluggable = /** @class */ (function (_super) {
+    tslib_1.__extends(DefinitionsCachePluggable, _super);
+    /**
+     * Create a DefinitionsCache that uses a storage wrapper.
+     * @param log -  Logger instance.
+     * @param keys -  Key builder.
+     * @param wrapper -  Adapted wrapper storage.
+     */
+    function DefinitionsCachePluggable(log, keys, wrapper, splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.log = log;
+        _this.keys = keys;
+        _this.wrapper = wrapper;
+        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    DefinitionsCachePluggable.prototype._decrementCounts = function (definition) {
+        var _this = this;
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.wrapper.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.wrapper.del(ttKey);
+        });
+    };
+    DefinitionsCachePluggable.prototype._incrementCounts = function (definition) {
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.wrapper.incr(ttKey);
+    };
+    DefinitionsCachePluggable.prototype._updateSets = function (definitionName, setsOfRemovedDefinition, setsOfAddedDefinition) {
+        var _this = this;
+        var removeFromSets = (0, sets_1.returnDifference)(setsOfRemovedDefinition, setsOfAddedDefinition);
+        var addToSets = (0, sets_1.returnDifference)(setsOfAddedDefinition, setsOfRemovedDefinition);
+        if (this.setsFilter.length > 0) {
+            addToSets = addToSets.filter(function (set) {
+                return _this.setsFilter.some(function (filterSet) { return filterSet === set; });
+            });
+        }
+        var items = [definitionName];
+        return Promise.all(tslib_1.__spreadArray(tslib_1.__spreadArray([], removeFromSets.map(function (setName) { return _this.wrapper.removeItems(_this.keys.buildSetKey(setName), items); }), true), addToSets.map(function (setName) { return _this.wrapper.addItems(_this.keys.buildSetKey(setName), items); }), true));
+    };
+    /**
+     * Add a given definition.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., wrapper operation fails)
+     */
+    DefinitionsCachePluggable.prototype.add = function (definition) {
+        var _this = this;
+        var name = definition.name;
+        var definitionKey = this.keys.buildDefinitionKey(name);
+        return this.wrapper.get(definitionKey).then(function (definitionFromStorage) {
+            // handling parsing error
+            var parsedPreviousDefinition, stringifiedNewDefinition;
+            try {
+                parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                stringifiedNewDefinition = JSON.stringify(definition);
+            }
+            catch (e) {
+                throw new Error('Error parsing feature flag definition: ' + e);
+            }
+            return _this.wrapper.set(definitionKey, stringifiedNewDefinition).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(definition).then(function () {
+                    if (parsedPreviousDefinition)
+                        return _this._decrementCounts(parsedPreviousDefinition);
+                });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
+        }).then(function () { return true; });
+    };
+    /**
+     * Remove a given definition.
+     * The returned promise is resolved when the operation success, with a boolean indicating if the definition existed or not.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    DefinitionsCachePluggable.prototype.remove = function (name) {
+        var _this = this;
+        return this.get(name).then(function (definition) {
+            if (definition) {
+                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
+            }
+        }).then(function () {
+            return _this.wrapper.del(_this.keys.buildDefinitionKey(name));
+        });
+    };
+    /**
+     * Get definition.
+     * The returned promise is resolved with the definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.get = function (name) {
+        return this.wrapper.get(this.keys.buildDefinitionKey(name))
+            .then(function (maybeDefinition) { return maybeDefinition && JSON.parse(maybeDefinition); });
+    };
+    /**
+     * Get list of definitions.
+     * The returned promise is resolved with a map of names to their definition or null if it's not defined,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getMany = function (names) {
+        var _this = this;
+        var keys = names.map(function (name) { return _this.keys.buildDefinitionKey(name); });
+        return this.wrapper.getMany(keys).then(function (stringifiedDefinitions) {
+            var definitions = {};
+            names.forEach(function (name, idx) {
+                var definition = stringifiedDefinitions[idx];
+                definitions[name] = definition && JSON.parse(definition);
+            });
+            return Promise.resolve(definitions);
+        });
+    };
+    /**
+     * Get list of all definitions.
+     * The returned promise is resolved with the list of definitions,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getAll = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (definitions) { return definitions.map(function (definition) {
+            return JSON.parse(definition);
+        }); });
+    };
+    /**
+     * Get list of definition names.
+     * The returned promise is resolved with the list of names,
+     * or rejected if wrapper operation fails.
+     */
+    DefinitionsCachePluggable.prototype.getNames = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.buildDefinitionKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+    };
+    /**
+     * Get list of definition names related to a given list of set names.
+     * The returned promise is resolved with the list of names per set.
+     * It never rejects (If there is a wrapper error for some set, an empty set is returned for it).
+     */
+    DefinitionsCachePluggable.prototype.getNamesBySets = function (sets) {
+        var _this = this;
+        return Promise.all(sets.map(function (set) {
+            var setKey = _this.keys.buildSetKey(set);
+            return _this.wrapper.getItems(setKey).catch(function () { return []; });
+        })).then(function (namesBySets) { return namesBySets.map(function (namesBySet) { return new Set(namesBySet); }); });
+    };
+    /**
+     * Check traffic type existence.
+     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+     * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
+     * It will never be rejected.
+     */
+    DefinitionsCachePluggable.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.wrapper.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 ".concat(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 ".concat(trafficType, " due to an error: ").concat(e, "."));
+            // If there is an error, bypass the validation so the event can get tracked.
+            return true;
+        });
+    };
+    /**
+     * Set till number.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    DefinitionsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
+        return this.wrapper.set(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+    };
+    /**
+     * 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 wrapper operation fails.
+     * The promise will never be rejected.
+     */
+    DefinitionsCachePluggable.prototype.getChangeNumber = function () {
+        var _this = this;
+        return this.wrapper.get(this.keys.buildDefinitionsTillKey()).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
+    DefinitionsCachePluggable.prototype.clear = function () {
+        return Promise.resolve(true);
+    };
+    return DefinitionsCachePluggable;
+}(AbstractDefinitionsCacheAsync_1.AbstractDefinitionsCacheAsync));
+exports.DefinitionsCachePluggable = DefinitionsCachePluggable;

package/cjs/storages/pluggable/EventsCachePluggable.js

@@ -21,7 +21,7 @@ var EventsCachePluggable = /** @class */ (function () {
             // We use boolean values to signal successful queueing
             .then(function () { return true; })
             .catch(function (e) {
-            _this.log.error(constants_1.LOG_PREFIX + "Error adding event to queue: " + e + ".");
+            _this.log.error("".concat(constants_1.LOG_PREFIX, "Error adding event to queue: ").concat(e, "."));
             return false;
         });
     };

package/cjs/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -6,7 +6,7 @@ var ImpressionCountsCacheInMemory_1 = require("../inMemory/ImpressionCountsCache
 var constants_1 = require("../inRedis/constants");
 var constants_2 = require("./constants");
 var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(ImpressionCountsCachePluggable, _super);
+    tslib_1.__extends(ImpressionCountsCachePluggable, _super);
     function ImpressionCountsCachePluggable(log, key, wrapper, impressionCountsCacheSize, refreshRate) {
         if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
         var _this = _super.call(this, impressionCountsCacheSize) || this;
@@ -24,10 +24,10 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
         if (!keys.length)
             return Promise.resolve(false);
         var pipeline = keys.reduce(function (pipeline, key) {
-            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
+            return pipeline.then(function () { return _this.wrapper.incr("".concat(_this.key, "::").concat(key), counts[key]); });
         }, Promise.resolve());
         return pipeline.catch(function (err) {
-            _this.log.error(constants_2.LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            _this.log.error("".concat(constants_2.LOG_PREFIX, "Error in impression counts pipeline: ").concat(err, "."));
             return false;
         });
     };
@@ -52,18 +52,18 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
                     var count = counts[i];
                     var keyFeatureNameAndTime = key.split('::');
                     if (keyFeatureNameAndTime.length !== 3) {
-                        _this.log.error(constants_2.LOG_PREFIX + "Error spliting key " + key);
+                        _this.log.error("".concat(constants_2.LOG_PREFIX, "Error spliting key ").concat(key));
                         continue;
                     }
                     var timeFrame = parseInt(keyFeatureNameAndTime[2]);
                     if (isNaN(timeFrame)) {
-                        _this.log.error(constants_2.LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        _this.log.error("".concat(constants_2.LOG_PREFIX, "Error parsing time frame ").concat(keyFeatureNameAndTime[2]));
                         continue;
                     }
                     // @ts-ignore
                     var rawCount = parseInt(count);
                     if (isNaN(rawCount)) {
-                        _this.log.error(constants_2.LOG_PREFIX + "Error parsing raw count " + count);
+                        _this.log.error("".concat(constants_2.LOG_PREFIX, "Error parsing raw count ").concat(count));
                         continue;
                     }
                     pf.push({

package/cjs/storages/pluggable/RBSegmentsCachePluggable.js

@@ -34,7 +34,7 @@ var RBSegmentsCachePluggable = /** @class */ (function () {
                 return _this.wrapper.set(key, stringifiedNewRBSegment).then(function () { return true; });
             })),
             Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove.name);
+                var key = _this.keys.buildRBSegmentKey(toRemove);
                 return _this.wrapper.del(key);
             }))
         ]).then(function (_a) {

package/cjs/storages/pluggable/TelemetryCachePluggable.js

@@ -45,18 +45,18 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = latencyKeys[i].split('::')[1];
                         var parsedField = (0, utils_1.parseLatencyField)(field);
                         if ((0, lang_1.isString)(parsedField)) {
-                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid latency field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         // @ts-ignore
                         var count = parseInt(latencies[i]);
                         if ((0, lang_1.isNaNNumber)(count)) {
-                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            _this.log.error("Ignoring latency with invalid count: ".concat(latencies[i]));
                             continue;
                         }
                         var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
                         if (bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT) {
-                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                            _this.log.error("Ignoring latency with invalid bucket: ".concat(bucket));
                             continue;
                         }
                         var methodLatencies = result.get(metadata) || {};
@@ -84,13 +84,13 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = exceptionKeys[i].split('::')[1];
                         var parsedField = (0, utils_1.parseExceptionField)(field);
                         if ((0, lang_1.isString)(parsedField)) {
-                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid exception field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         // @ts-ignore
                         var count = parseInt(exceptions[i]);
                         if ((0, lang_1.isNaNNumber)(count)) {
-                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            _this.log.error("Ignoring exception with invalid count: ".concat(exceptions[i]));
                             continue;
                         }
                         var metadata = parsedField[0], method = parsedField[1];
@@ -118,7 +118,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = configKeys[i].split('::')[1];
                         var parsedField = (0, utils_1.parseMetadata)(field);
                         if ((0, lang_1.isString)(parsedField)) {
-                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid config field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         var metadata = parsedField[0];
@@ -127,7 +127,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                             result.set(metadata, config);
                         }
                         catch (e) {
-                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                            _this.log.error("Ignoring invalid config: ".concat(configs[i]));
                         }
                     }
                     return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });

package/cjs/storages/pluggable/UniqueKeysCachePluggable.js

@@ -7,7 +7,7 @@ var constants_1 = require("../inRedis/constants");
 var constants_2 = require("./constants");
 var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCachePluggable = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(UniqueKeysCachePluggable, _super);
+    tslib_1.__extends(UniqueKeysCachePluggable, _super);
     function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
         if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
         if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
@@ -35,7 +35,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         this.clear();
         return this.wrapper.pushItems(this.key, uniqueKeysArray)
             .catch(function (err) {
-            _this.log.error(constants_2.LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            _this.log.error("".concat(constants_2.LOG_PREFIX, "Error in uniqueKeys pipeline: ").concat(err, "."));
             return false;
         });
     };

package/cjs/storages/pluggable/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluggableStorage = void 0;
 var tslib_1 = require("tslib");
 var KeyBuilderSS_1 = require("../KeyBuilderSS");
-var SplitsCachePluggable_1 = require("./SplitsCachePluggable");
+var DefinitionsCachePluggable_1 = require("./DefinitionsCachePluggable");
 var SegmentsCachePluggable_1 = require("./SegmentsCachePluggable");
 var ImpressionsCachePluggable_1 = require("./ImpressionsCachePluggable");
 var EventsCachePluggable_1 = require("./EventsCachePluggable");
@@ -38,7 +38,7 @@ function validatePluggableStorageOptions(options) {
     var wrapper = options.wrapper;
     var missingMethods = wrapperAdapter_1.METHODS_TO_PROMISE_WRAP.filter(function (method) { return typeof wrapper[method] !== 'function'; });
     if (missingMethods.length)
-        throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
+        throw new Error("".concat(NO_VALID_WRAPPER_INTERFACE, " The following methods are missing or invalid: ").concat(missingMethods));
 }
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
@@ -82,7 +82,7 @@ function PluggableStorage(options) {
                     var currentHash = (0, KeyBuilder_1.getStorageHash)(settings);
                     if (hash !== currentHash) {
                         log.info(constants_2.LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                        return wrapper.getKeysByPrefix("".concat(keys.prefix, ".")).then(function (storageKeys) {
                             return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
                         }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
                     }
@@ -106,7 +106,7 @@ function PluggableStorage(options) {
             return e; // Propagate error for shared clients
         });
         return {
-            splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCachePluggable_1.DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCachePluggable_1.RBSegmentsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
@@ -124,7 +124,7 @@ function PluggableStorage(options) {
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
                 connectPromise.then(onReadyCb);
-                return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, this), { 
+                return tslib_1.__assign(tslib_1.__assign({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });
             }

package/cjs/storages/pluggable/wrapperAdapter.js

@@ -34,7 +34,7 @@ function wrapperAdapter(log, wrapper) {
     exports.METHODS_TO_PROMISE_WRAP.forEach(function (method) {
         // Logs error and wraps it into a rejected promise.
         function handleError(e) {
-            log.error(constants_1.LOG_PREFIX + " Wrapper '" + method + "' operation threw an error. Message: " + e);
+            log.error("".concat(constants_1.LOG_PREFIX, " Wrapper '").concat(method, "' operation threw an error. Message: ").concat(e));
             return Promise.reject(e);
         }
         wrapperAdapter[method] = function () {

package/cjs/storages/setRolloutPlan.js

@@ -24,16 +24,16 @@ exports.validateRolloutPlan = validateRolloutPlan;
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
 function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
     var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
-    log.debug("storage: set feature flags and segments" + (matchingKey ? " for key " + matchingKey : ''));
-    if (splits && ff) {
-        splits.clear();
-        splits.update(ff.d, [], ff.t);
+    log.debug("storage: set feature flags and segments".concat(matchingKey ? " for key ".concat(matchingKey) : ''));
+    if (definitions && ff) {
+        definitions.clear();
+        definitions.update(ff.d || [], [], ff.t);
     }
     if (rbSegments && rbs) {
         rbSegments.clear();
-        rbSegments.update(rbs.d, [], rbs.t);
+        rbSegments.update(rbs.d || [], [], rbs.t);
     }
     var segmentChanges = rolloutPlan.segmentChanges;
     if (matchingKey) { // add memberships data (client-side)

package/cjs/storages/utils.js

@@ -42,7 +42,7 @@ var REVERSE_METHOD_NAMES = Object.keys(KeyBuilderSS_1.METHOD_NAMES).reduce(funct
 function parseMetadata(field) {
     var parts = field.split('/');
     if (parts.length !== 3)
-        return "invalid subsection count. Expected 3, got: " + parts.length;
+        return "invalid subsection count. Expected 3, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
     return [JSON.stringify({ s: s, n: n, i: i })];
 }
@@ -50,25 +50,25 @@ exports.parseMetadata = parseMetadata;
 function parseExceptionField(field) {
     var parts = field.split('/');
     if (parts.length !== 4)
-        return "invalid subsection count. Expected 4, got: " + parts.length;
+        return "invalid subsection count. Expected 4, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
     var method = REVERSE_METHOD_NAMES[m];
     if (!method)
-        return "unknown method '" + m + "'";
+        return "unknown method '".concat(m, "'");
     return [JSON.stringify({ s: s, n: n, i: i }), method];
 }
 exports.parseExceptionField = parseExceptionField;
 function parseLatencyField(field) {
     var parts = field.split('/');
     if (parts.length !== 5)
-        return "invalid subsection count. Expected 5, got: " + parts.length;
+        return "invalid subsection count. Expected 5, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
     var method = REVERSE_METHOD_NAMES[m];
     if (!method)
-        return "unknown method '" + m + "'";
+        return "unknown method '".concat(m, "'");
     var bucket = parseInt(b);
     if (isNaN(bucket) || bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT)
-        return "invalid bucket. Expected a number between 0 and " + (TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+        return "invalid bucket. Expected a number between 0 and ".concat(TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT - 1, ", got: ").concat(b);
     return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
 }
 exports.parseLatencyField = parseLatencyField;