@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.10

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RBSegmentsCacheInMemory = void 0;
 var sets_1 = require("../../utils/lang/sets");
-var AbstractDefinitionsCacheSync_1 = require("../AbstractDefinitionsCacheSync");
+var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var RBSegmentsCacheInMemory = /** @class */ (function () {
     function RBSegmentsCacheInMemory() {
         this.cache = {};
@@ -17,17 +17,17 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
         var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove); }).some(function (result) { return result; }) || updated;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.changeNumber = changeNumber;
         return updated;
     };
     RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
         var name = rbSegment.name;
         var previous = this.get(name);
-        if (previous && (0, AbstractDefinitionsCacheSync_1.usesSegments)(previous))
+        if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
             this.segmentsCount--;
         this.cache[name] = rbSegment;
-        if ((0, AbstractDefinitionsCacheSync_1.usesSegments)(rbSegment))
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
             this.segmentsCount++;
         return true;
     };
@@ -36,7 +36,7 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
         if (!rbSegment)
             return false;
         delete this.cache[name];
-        if ((0, AbstractDefinitionsCacheSync_1.usesSegments)(rbSegment))
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
             this.segmentsCount--;
         return true;
     };

package/cjs/storages/inMemory/SegmentsCacheInMemory.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentsCacheInMemory = void 0;
 var lang_1 = require("../../utils/lang");
 /**
- * Default IDefinitionsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
  */
 var SegmentsCacheInMemory = /** @class */ (function () {
     function SegmentsCacheInMemory() {

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitsCacheInMemory = void 0;
+var tslib_1 = require("tslib");
+var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
+var lang_1 = require("../../utils/lang");
+/**
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ */
+var SplitsCacheInMemory = /** @class */ (function (_super) {
+    tslib_1.__extends(SplitsCacheInMemory, _super);
+    function SplitsCacheInMemory(splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.splitsCache = {};
+        _this.ttCache = {};
+        _this.changeNumber = -1;
+        _this.segmentsCount = 0;
+        _this.flagSetsCache = {};
+        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    SplitsCacheInMemory.prototype.clear = function () {
+        this.splitsCache = {};
+        this.ttCache = {};
+        this.changeNumber = -1;
+        this.segmentsCount = 0;
+        this.flagSetsCache = {};
+    };
+    SplitsCacheInMemory.prototype.addSplit = function (split) {
+        var name = split.name;
+        var previousSplit = this.getSplit(name);
+        if (previousSplit) { // We had this Split already
+            var previousTtName = previousSplit.trafficTypeName;
+            this.ttCache[previousTtName]--;
+            if (!this.ttCache[previousTtName])
+                delete this.ttCache[previousTtName];
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+            // Subtract from segments count for the previous version of this Split
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit))
+                this.segmentsCount--;
+        }
+        // Store the Split.
+        this.splitsCache[name] = split;
+        // Update TT cache
+        var ttName = split.trafficTypeName;
+        this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+        this.addToFlagSets(split);
+        // Add to segments count for the new version of the Split
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
+            this.segmentsCount++;
+        return true;
+    };
+    SplitsCacheInMemory.prototype.removeSplit = function (name) {
+        var split = this.getSplit(name);
+        if (!split)
+            return false;
+        // Delete the Split
+        delete this.splitsCache[name];
+        var ttName = split.trafficTypeName;
+        this.ttCache[ttName]--; // Update tt cache
+        if (!this.ttCache[ttName])
+            delete this.ttCache[ttName];
+        this.removeFromFlagSets(split.name, split.sets);
+        // Update the segments count.
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
+            this.segmentsCount--;
+        return true;
+    };
+    SplitsCacheInMemory.prototype.getSplit = function (name) {
+        return this.splitsCache[name] || null;
+    };
+    SplitsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
+        this.changeNumber = changeNumber;
+        return true;
+    };
+    SplitsCacheInMemory.prototype.getChangeNumber = function () {
+        return this.changeNumber;
+    };
+    SplitsCacheInMemory.prototype.getSplitNames = function () {
+        return Object.keys(this.splitsCache);
+    };
+    SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
+        return (0, lang_1.isFiniteNumber)(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
+    };
+    SplitsCacheInMemory.prototype.usesSegments = function () {
+        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+    };
+    SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new Set(); });
+    };
+    SplitsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
+        var _this = this;
+        if (!featureFlag.sets)
+            return;
+        featureFlag.sets.forEach(function (featureFlagSet) {
+            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
+                return;
+            if (!_this.flagSetsCache[featureFlagSet])
+                _this.flagSetsCache[featureFlagSet] = new Set([]);
+            _this.flagSetsCache[featureFlagSet].add(featureFlag.name);
+        });
+    };
+    SplitsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
+        var _this = this;
+        if (!flagSets)
+            return;
+        flagSets.forEach(function (flagSet) {
+            _this.removeNames(flagSet, featureFlagName);
+        });
+    };
+    SplitsCacheInMemory.prototype.removeNames = function (flagSetName, featureFlagName) {
+        if (!this.flagSetsCache[flagSetName])
+            return;
+        this.flagSetsCache[flagSetName].delete(featureFlagName);
+        if (this.flagSetsCache[flagSetName].size === 0)
+            delete this.flagSetsCache[flagSetName];
+    };
+    return SplitsCacheInMemory;
+}(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));
+exports.SplitsCacheInMemory = SplitsCacheInMemory;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -19,13 +19,13 @@ var ACCEPTANCE_RANGE = 0.001;
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
 function shouldRecordTelemetry(_a) {
-    var settings = _a.settings, disableTelemetry = _a.disableTelemetry;
-    return !disableTelemetry && settings.mode !== constants_1.LOCALHOST_MODE && ((0, key_1.checkIfServerSide)(settings) || Math.random() <= ACCEPTANCE_RANGE);
+    var settings = _a.settings;
+    return settings.mode !== constants_1.LOCALHOST_MODE && ((0, key_1.checkIfServerSide)(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(definitions, segments, largeSegments) {
-        this.definitions = definitions;
+    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+        this.splits = splits;
         this.segments = segments;
         this.largeSegments = largeSegments;
         this.name = 'telemetry stats';
@@ -61,7 +61,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             iQ: this.getImpressionStats(constants_1.QUEUED),
             iDe: this.getImpressionStats(constants_1.DEDUPED),
             iDr: this.getImpressionStats(constants_1.DROPPED),
-            spC: this.definitions && this.definitions.getNames().length,
+            spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
             lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,

package/cjs/storages/inRedis/RBSegmentsCacheInRedis.js

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

package/cjs/storages/inRedis/RedisAdapter.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisAdapter = void 0;
 var tslib_1 = require("tslib");
 // Dynamically require ioredis to prevent strict TypeScript binding
-// and handle module export differences between v4 and v5.
+// and handle module export differences between v4 and later major versions.
 var RedisConstructor;
 try {
     var ioredisLib = require('ioredis');
@@ -11,7 +11,7 @@ try {
 }
 catch (e) {
     // If we reach here, the peer dependency is missing
-    throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+    throw new Error('ioredis is missing. Please install ioredis v4, v5 or v6.');
 }
 var lang_1 = require("../../utils/lang");
 var thenable_1 = require("../../utils/promise/thenable");
@@ -31,13 +31,16 @@ var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
     lazyConnect: false,
-    // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
-    // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+    // CRITICAL: v5 and v6 default this to 0 (disabled), which breaks dynamic clusters.
+    // v4 defaulted to 5000. We explicitly set it here to ensure v5 and v6 work like v4.
     slotsRefreshInterval: 5000,
+    // v6 defaults to RESP3 (`protocol: 3`). The SDK doesn't use any RESP3 feature,
+    // so we stick to RESP2 to keep the v4 and v5 behavior. Ignored by v4 and v5.
+    protocol: 2,
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- * Refactored to use Composition instead of Inheritance to support both v4 and v5.
+ * Refactored to use Composition instead of Inheritance to support v4, v5 and v6.
  */
 var RedisAdapter = /** @class */ (function () {
     function RedisAdapter(log, storageSettings) {

package/cjs/storages/inRedis/{DefinitionsCacheInRedis.js → SplitsCacheInRedis.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefinitionsCacheInRedis = void 0;
+exports.SplitsCacheInRedis = void 0;
 var tslib_1 = require("tslib");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./constants");
-var AbstractDefinitionsCacheAsync_1 = require("../AbstractDefinitionsCacheAsync");
+var AbstractSplitsCacheAsync_1 = require("../AbstractSplitsCacheAsync");
 var sets_1 = require("../../utils/lang/sets");
 /**
  * Discard errors for an answer of multiple operations.
@@ -17,17 +17,17 @@ function processPipelineAnswer(results) {
     }, []) : [];
 }
 /**
- * IDefinitionsCacheAsync implementation that stores definitions in Redis.
+ * ISplitsCacheAsync implementation that stores split definitions in Redis.
  * Supported by Node.js
  */
-var DefinitionsCacheInRedis = /** @class */ (function (_super) {
-    tslib_1.__extends(DefinitionsCacheInRedis, _super);
-    function DefinitionsCacheInRedis(log, keys, redis, splitFiltersValidation) {
+var SplitsCacheInRedis = /** @class */ (function (_super) {
+    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.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        _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) {
@@ -38,104 +38,104 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
         });
         return _this;
     }
-    DefinitionsCacheInRedis.prototype._decrementCounts = function (definition) {
+    SplitsCacheInRedis.prototype._decrementCounts = function (split) {
         var _this = this;
-        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
         return this.redis.decr(ttKey).then(function (count) {
             if (count === 0)
                 return _this.redis.del(ttKey);
         });
     };
-    DefinitionsCacheInRedis.prototype._incrementCounts = function (definition) {
-        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+    SplitsCacheInRedis.prototype._incrementCounts = function (split) {
+        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
         return this.redis.incr(ttKey);
     };
-    DefinitionsCacheInRedis.prototype._updateSets = function (definitionName, setsOfRemovedDefinition, setsOfAddedDefinition) {
+    SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
         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 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 = [definitionName];
-        return Promise.all(tslib_1.__spreadArray(tslib_1.__spreadArray([], removeFromSets.map(function (setName) { return _this.redis.srem(_this.keys.buildSetKey(setName), items); }), true), addToSets.map(function (setName) { return _this.redis.sadd(_this.keys.buildSetKey(setName), items); }), true));
+        var items = [featureFlagName];
+        return Promise.all(tslib_1.__spreadArray(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 definition.
+     * Add a given split.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    DefinitionsCacheInRedis.prototype.add = function (definition) {
+    SplitsCacheInRedis.prototype.addSplit = function (split) {
         var _this = this;
-        var name = definition.name;
-        var definitionKey = this.keys.buildDefinitionKey(name);
-        return this.redis.get(definitionKey).then(function (definitionFromStorage) {
+        var name = split.name;
+        var splitKey = this.keys.buildSplitKey(name);
+        return this.redis.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
-            var parsedPreviousDefinition, stringifiedNewDefinition;
+            var parsedPreviousSplit, stringifiedNewSplit;
             try {
-                parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
-                stringifiedNewDefinition = JSON.stringify(definition);
+                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(definitionKey, stringifiedNewDefinition).then(function () {
+            return _this.redis.set(splitKey, stringifiedNewSplit).then(function () {
                 // avoid unnecessary increment/decrement operations
-                if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName)
+                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
                     return;
                 // update traffic type counts
-                return _this._incrementCounts(definition).then(function () {
-                    if (parsedPreviousDefinition)
-                        return _this._decrementCounts(parsedPreviousDefinition);
+                return _this._incrementCounts(split).then(function () {
+                    if (parsedPreviousSplit)
+                        return _this._decrementCounts(parsedPreviousSplit);
                 });
-            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
+            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
         }).then(function () { return true; });
     };
     /**
-     * Remove a given definition.
-     * The returned promise is resolved when the operation success, with true or false indicating if the definition existed (and was removed) or not.
+     * 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).
      */
-    DefinitionsCacheInRedis.prototype.remove = function (name) {
+    SplitsCacheInRedis.prototype.removeSplit = 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); });
+        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.buildDefinitionKey(name)).then(function (status) { return status === 1; });
+            return _this.redis.del(_this.keys.buildSplitKey(name)).then(function (status) { return status === 1; });
         });
     };
     /**
-     * Get definition or null if it's not defined.
+     * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.
      */
-    DefinitionsCacheInRedis.prototype.get = function (name) {
+    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.buildDefinitionKey(name))
-            .then(function (maybeDefinition) { return maybeDefinition && JSON.parse(maybeDefinition); });
+        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.
      */
-    DefinitionsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
-        return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+    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.
      */
-    DefinitionsCacheInRedis.prototype.getChangeNumber = function () {
+    SplitsCacheInRedis.prototype.getChangeNumber = function () {
         var _this = this;
-        return this.redis.get(this.keys.buildDefinitionsTillKey()).then(function (value) {
+        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) {
@@ -144,44 +144,44 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
         });
     };
     /**
-     * Get list of all definitions.
-     * The returned promise is resolved with the list of definitions,
+     * 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.
-    DefinitionsCacheInRedis.prototype.getAll = function () {
+    SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForDefinitionKeys())
+        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 (definitions) { return definitions.map(function (definition) {
-            return JSON.parse(definition);
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
         }); });
     };
     /**
-     * Get list of definition names.
-     * The returned promise is resolved with the list of names,
+     * Get list of split names.
+     * The returned promise is resolved with the list of split names,
      * or rejected if redis operation fails.
      */
-    DefinitionsCacheInRedis.prototype.getNames = function () {
+    SplitsCacheInRedis.prototype.getSplitNames = function () {
         var _this = this;
-        return this.redis.keys(this.keys.searchPatternForDefinitionKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+        return this.redis.keys(this.keys.searchPatternForSplitKeys()).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,
+     * 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).
     */
-    DefinitionsCacheInRedis.prototype.getNamesBySets = function (sets) {
+    SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return this.redis.pipeline(sets.map(function (set) { return ['smembers', _this.keys.buildSetKey(set)]; })).exec()
+        return this.redis.pipeline(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; })).exec()
             .then(function (results) { return results ? results.map(function (_a, index) {
             var e = _a[0], value = _a[1];
             if (e === null)
                 return value;
-            _this.log.error(constants_1.LOG_PREFIX + "Could not read result from get members of set ".concat(sets[index], " due to an error: ").concat(e));
+            _this.log.error(constants_1.LOG_PREFIX + "Could not read result from get members of flag set ".concat(flagSets[index], " due to an error: ").concat(e));
         }) : []; })
-            .then(function (namesBySets) { return namesBySets.map(function (namesBySet) { return new Set(namesBySet); }); });
+            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.
@@ -189,7 +189,7 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
      * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
      * It will never be rejected.
      */
-    DefinitionsCacheInRedis.prototype.trafficTypeExists = function (trafficType) {
+    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))
@@ -210,34 +210,34 @@ var DefinitionsCacheInRedis = /** @class */ (function (_super) {
         });
     };
     // @TODO remove or implement. It is not being used.
-    DefinitionsCacheInRedis.prototype.clear = function () {
+    SplitsCacheInRedis.prototype.clear = function () {
         return Promise.resolve();
     };
     /**
-     * Fetches multiple definitions.
+     * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.
      */
-    DefinitionsCacheInRedis.prototype.getMany = function (names) {
+    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.buildDefinitionKey(name); });
-        return (_a = this.redis).mget.apply(_a, keys).then(function (stringifiedDefinitions) {
-            var definitions = {};
+        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 definition = stringifiedDefinitions[idx];
-                definitions[name] = definition && JSON.parse(definition);
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
-            return Promise.resolve(definitions);
+            return Promise.resolve(splits);
         })
             .catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + "Could not grab feature flags due to an error: ".concat(e, "."));
             return Promise.reject(e);
         });
     };
-    return DefinitionsCacheInRedis;
-}(AbstractDefinitionsCacheAsync_1.AbstractDefinitionsCacheAsync));
-exports.DefinitionsCacheInRedis = DefinitionsCacheInRedis;
+    return SplitsCacheInRedis;
+}(AbstractSplitsCacheAsync_1.AbstractSplitsCacheAsync));
+exports.SplitsCacheInRedis = SplitsCacheInRedis;

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 DefinitionsCacheInRedis_1 = require("./DefinitionsCacheInRedis");
+var SplitsCacheInRedis_1 = require("./SplitsCacheInRedis");
 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 {
-            definitions: new DefinitionsCacheInRedis_1.DefinitionsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+            splits: new SplitsCacheInRedis_1.SplitsCacheInRedis(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/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);
+                var key = _this.keys.buildRBSegmentKey(toRemove.name);
                 return _this.wrapper.del(key);
             }))
         ]).then(function (_a) {