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

package/cjs/services/splitHttpClient.js

@@ -24,17 +24,19 @@ function splitHttpClientFactory(settings, _a) {
     var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'Authorization': "Bearer ".concat(authorizationKey)
+        'Authorization': "Bearer ".concat(authorizationKey),
+        'SplitSDKVersion': version
     };
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
         commonHeaders['SplitSDKMachineName'] = (0, decorateHeaders_1.removeNonISO88591)(hostname);
-    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo, newVersionHeader) {
+    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
+        if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
         var request = (0, objectAssign_1.objectAssign)({
-            headers: (0, decorateHeaders_1.decorateHeaders)(settings, (0, objectAssign_1.objectAssign)(newVersionHeader ? { 'X-Harness-FME-SDK-Version': version } : { 'SplitSDKVersion': version }, commonHeaders, reqOpts.headers || {})),
+            headers: (0, decorateHeaders_1.decorateHeaders)(settings, (0, objectAssign_1.objectAssign)({}, commonHeaders, reqOpts.headers || {})),
             method: reqOpts.method || 'GET',
             body: reqOpts.body
         }, options);

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSplitsCacheAsync = void 0;
+var objectAssign_1 = require("../utils/lang/objectAssign");
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractSplitsCacheAsync = /** @class */ (function () {
+    function AbstractSplitsCacheAsync() {
+    }
+    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        return Promise.all([
+            this.setChangeNumber(changeNumber),
+            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
+            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
+        ]).then(function (_a) {
+            var added = _a[1], removed = _a[2];
+            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+        });
+    };
+    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
+    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
+    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
+        return Promise.resolve(true);
+    };
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
+     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     * The promise will never be rejected.
+     */
+    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var _this = this;
+        return this.getSplit(name).then(function (split) {
+            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+                var newSplit = (0, objectAssign_1.objectAssign)({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(newSplit);
+            }
+            return false;
+        }).catch(function () { return false; });
+    };
+    return AbstractSplitsCacheAsync;
+}());
+exports.AbstractSplitsCacheAsync = AbstractSplitsCacheAsync;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usesSegmentsSync = exports.usesSegments = exports.AbstractSplitsCacheSync = void 0;
+var objectAssign_1 = require("../utils/lang/objectAssign");
+var constants_1 = require("../utils/constants");
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractSplitsCacheSync = /** @class */ (function () {
+    function AbstractSplitsCacheSync() {
+    }
+    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
+        this.setChangeNumber(changeNumber);
+        return updated;
+    };
+    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
+        var _this = this;
+        var splits = {};
+        names.forEach(function (name) {
+            splits[name] = _this.getSplit(name);
+        });
+        return splits;
+    };
+    AbstractSplitsCacheSync.prototype.getAll = function () {
+        var _this = this;
+        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
+    };
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
+     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     */
+    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var split = this.getSplit(name);
+        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+            var newSplit = (0, objectAssign_1.objectAssign)({}, split);
+            newSplit.killed = true;
+            newSplit.defaultTreatment = defaultTreatment;
+            newSplit.changeNumber = changeNumber;
+            return this.addSplit(newSplit);
+        }
+        return false;
+    };
+    return AbstractSplitsCacheSync;
+}());
+exports.AbstractSplitsCacheSync = AbstractSplitsCacheSync;
+/**
+ * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
+ * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
+ */
+function usesSegments(ruleEntity) {
+    var conditions = ruleEntity.conditions || [];
+    for (var i = 0; i < conditions.length; i++) {
+        var matchers = conditions[i].matcherGroup.matchers;
+        for (var j = 0; j < matchers.length; j++) {
+            var matcher = matchers[j].matcherType;
+            if (matcher === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
+                return true;
+        }
+    }
+    var excluded = ruleEntity.excluded;
+    if (excluded && excluded.segments && excluded.segments.length > 0)
+        return true;
+    return false;
+}
+exports.usesSegments = usesSegments;
+function usesSegmentsSync(storage) {
+    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+}
+exports.usesSegmentsSync = usesSegmentsSync;

package/cjs/storages/KeyBuilder.js

@@ -16,16 +16,16 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
         return "".concat(this.prefix, ".trafficType.").concat(trafficType);
     };
-    KeyBuilder.prototype.buildSetKey = function (set) {
-        return "".concat(this.prefix, ".flagSet.").concat(set);
+    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
+        return "".concat(this.prefix, ".flagSet.").concat(flagSet);
     };
-    KeyBuilder.prototype.buildDefinitionKey = function (definitionName) {
-        return "".concat(this.prefix, ".split.").concat(definitionName);
+    KeyBuilder.prototype.buildSplitKey = function (splitName) {
+        return "".concat(this.prefix, ".split.").concat(splitName);
     };
-    KeyBuilder.prototype.buildDefinitionsTillKey = function () {
+    KeyBuilder.prototype.buildSplitsTillKey = function () {
         return "".concat(this.prefix, ".splits.till");
     };
-    KeyBuilder.prototype.buildDefinitionKeyPrefix = function () {
+    KeyBuilder.prototype.buildSplitKeyPrefix = function () {
         return "".concat(this.prefix, ".split.");
     };
     KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {

package/cjs/storages/KeyBuilderCS.js

@@ -9,7 +9,7 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     function KeyBuilderCS(prefix, matchingKey) {
         var _this = _super.call(this, prefix) || this;
         _this.matchingKey = matchingKey;
-        _this.regexDefinitionsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
+        _this.regexSplitsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
         return _this;
     }
     /**
@@ -26,19 +26,19 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return "".concat(this.prefix, ".splits.lastUpdated");
     };
-    KeyBuilderCS.prototype.isDefinitionsCacheKey = function (key) {
-        return this.regexDefinitionsCacheKey.test(key);
+    KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
+        return this.regexSplitsCacheKey.test(key);
     };
     KeyBuilderCS.prototype.buildTillKey = function () {
         return "".concat(this.prefix, ".").concat(this.matchingKey, ".segments.till");
     };
-    KeyBuilderCS.prototype.isDefinitionKey = function (key) {
+    KeyBuilderCS.prototype.isSplitKey = function (key) {
         return (0, lang_1.startsWith)(key, "".concat(this.prefix, ".split."));
     };
     KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
         return (0, lang_1.startsWith)(key, "".concat(this.prefix, ".rbsegment."));
     };
-    KeyBuilderCS.prototype.buildDefinitionsWithSegmentCountKey = function () {
+    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
         return "".concat(this.prefix, ".splits.usingSegments");
     };
     KeyBuilderCS.prototype.buildLastClear = function () {

package/cjs/storages/KeyBuilderSS.js

@@ -39,8 +39,8 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return "".concat(this.prefix, ".events");
     };
-    KeyBuilderSS.prototype.searchPatternForDefinitionKeys = function () {
-        return "".concat(this.buildDefinitionKeyPrefix(), "*");
+    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
+        return "".concat(this.buildSplitKeyPrefix(), "*");
     };
     KeyBuilderSS.prototype.searchPatternForRBSegmentKeys = function () {
         return "".concat(this.buildRBSegmentKeyPrefix(), "*");

package/cjs/storages/getRolloutPlan.js

@@ -9,14 +9,14 @@ var key_1 = require("../utils/key");
 function getRolloutPlan(log, storage, options) {
     if (options === void 0) { options = {}; }
     var keys = options.keys, exposeSegments = options.exposeSegments;
-    var definitions = storage.definitions, segments = storage.segments, rbSegments = storage.rbSegments;
+    var splits = storage.splits, segments = storage.segments, rbSegments = storage.rbSegments;
     log.debug("storage: get feature flags".concat(keys ? ", and memberships for keys: ".concat(keys) : '').concat(exposeSegments ? ', and segments' : ''));
     return {
         splitChanges: {
             ff: {
-                t: definitions.getChangeNumber(),
+                t: splits.getChangeNumber(),
                 s: -1,
-                d: definitions.getAll(),
+                d: splits.getAll(),
             },
             rbs: {
                 t: rbSegments.getChangeNumber(),

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -7,8 +7,9 @@ var AbstractMySegmentsCacheSync_1 = require("../AbstractMySegmentsCacheSync");
 var constants_1 = require("./constants");
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     tslib_1.__extends(MySegmentsCacheInLocal, _super);
-    function MySegmentsCacheInLocal(_log, keys, storage) {
+    function MySegmentsCacheInLocal(log, keys, storage) {
         var _this = _super.call(this) || this;
+        _this.log = log;
         _this.keys = keys;
         _this.storage = storage;
         return _this;

package/cjs/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RBSegmentsCacheInLocal = void 0;
 var lang_1 = require("../../utils/lang");
 var sets_1 = require("../../utils/lang/sets");
-var AbstractDefinitionsCacheSync_1 = require("../AbstractDefinitionsCacheSync");
+var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var constants_1 = require("./constants");
 var RBSegmentsCacheInLocal = /** @class */ (function () {
     function RBSegmentsCacheInLocal(settings, keys, storage) {
@@ -19,7 +19,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     RBSegmentsCacheInLocal.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.setChangeNumber(changeNumber);
         return updated;
     };
@@ -33,7 +33,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         }
     };
     RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
-        var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
+        var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
         var count = (0, lang_1.toNumber)(this.storage.getItem(segmentsCountKey)) + diff;
         if (count > 0)
             this.storage.setItem(segmentsCountKey, count + '');
@@ -47,9 +47,9 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
         this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
         var usesSegmentsDiff = 0;
-        if (previous && (0, AbstractDefinitionsCacheSync_1.usesSegments)(previous))
+        if (previous && (0, AbstractSplitsCacheSync_1.usesSegments)(previous))
             usesSegmentsDiff--;
-        if ((0, AbstractDefinitionsCacheSync_1.usesSegments)(rbSegment))
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
             usesSegmentsDiff++;
         if (usesSegmentsDiff !== 0)
             this.updateSegmentCount(usesSegmentsDiff);
@@ -60,7 +60,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         if (!rbSegment)
             return false;
         this.storage.removeItem(this.keys.buildRBSegmentKey(name));
-        if ((0, AbstractDefinitionsCacheSync_1.usesSegments)(rbSegment))
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(rbSegment))
             this.updateSegmentCount(-1);
         return true;
     };
@@ -99,10 +99,10 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         return n;
     };
     RBSegmentsCacheInLocal.prototype.usesSegments = function () {
-        var storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
-        var definitionsWithSegmentsCount = storedCount === null ? 0 : (0, lang_1.toNumber)(storedCount);
-        return (0, lang_1.isFiniteNumber)(definitionsWithSegmentsCount) ?
-            definitionsWithSegmentsCount > 0 :
+        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var splitsWithSegmentsCount = storedCount === null ? 0 : (0, lang_1.toNumber)(storedCount);
+        return (0, lang_1.isFiniteNumber)(splitsWithSegmentsCount) ?
+            splitsWithSegmentsCount > 0 :
             true;
     };
     return RBSegmentsCacheInLocal;

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitsCacheInLocal = void 0;
+var tslib_1 = require("tslib");
+var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
+var lang_1 = require("../../utils/lang");
+var constants_1 = require("./constants");
+var sets_1 = require("../../utils/lang/sets");
+var SplitsCacheInLocal = /** @class */ (function (_super) {
+    tslib_1.__extends(SplitsCacheInLocal, _super);
+    function SplitsCacheInLocal(settings, keys, storage) {
+        var _this = _super.call(this) || this;
+        _this.keys = keys;
+        _this.log = settings.log;
+        _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+        _this.storage = storage;
+        return _this;
+    }
+    SplitsCacheInLocal.prototype._decrementCount = function (key) {
+        var count = (0, lang_1.toNumber)(this.storage.getItem(key)) - 1;
+        if (count > 0)
+            this.storage.setItem(key, count + '');
+        else
+            this.storage.removeItem(key);
+    };
+    SplitsCacheInLocal.prototype._decrementCounts = function (split) {
+        try {
+            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+            this._decrementCount(ttKey);
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
+                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+                this._decrementCount(segmentsCountKey);
+            }
+        }
+        catch (e) {
+            this.log.error(constants_1.LOG_PREFIX + e);
+        }
+    };
+    SplitsCacheInLocal.prototype._incrementCounts = function (split) {
+        try {
+            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+            this.storage.setItem(ttKey, ((0, lang_1.toNumber)(this.storage.getItem(ttKey)) + 1) + '');
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
+                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+                this.storage.setItem(segmentsCountKey, ((0, lang_1.toNumber)(this.storage.getItem(segmentsCountKey)) + 1) + '');
+            }
+        }
+        catch (e) {
+            this.log.error(constants_1.LOG_PREFIX + e);
+        }
+    };
+    /**
+     * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
+     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
+     */
+    SplitsCacheInLocal.prototype.clear = function () {
+        var _this = this;
+        // collect item keys
+        var len = this.storage.length;
+        var accum = [];
+        for (var cur = 0; cur < len; cur++) {
+            var key = this.storage.key(cur);
+            if (key != null && this.keys.isSplitsCacheKey(key))
+                accum.push(key);
+        }
+        // remove items
+        accum.forEach(function (key) {
+            _this.storage.removeItem(key);
+        });
+        this.hasSync = false;
+    };
+    SplitsCacheInLocal.prototype.addSplit = function (split) {
+        var name = split.name;
+        var splitKey = this.keys.buildSplitKey(name);
+        var splitFromStorage = this.storage.getItem(splitKey);
+        var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
+        if (previousSplit) {
+            this._decrementCounts(previousSplit);
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+        }
+        this.storage.setItem(splitKey, JSON.stringify(split));
+        this._incrementCounts(split);
+        this.addToFlagSets(split);
+        return true;
+    };
+    SplitsCacheInLocal.prototype.removeSplit = function (name) {
+        var split = this.getSplit(name);
+        if (!split)
+            return false;
+        this.storage.removeItem(this.keys.buildSplitKey(name));
+        this._decrementCounts(split);
+        this.removeFromFlagSets(split.name, split.sets);
+        return true;
+    };
+    SplitsCacheInLocal.prototype.getSplit = function (name) {
+        var item = this.storage.getItem(this.keys.buildSplitKey(name));
+        return item && JSON.parse(item);
+    };
+    SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
+        try {
+            this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
+            // update "last updated" timestamp with current time
+            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            this.hasSync = true;
+            return true;
+        }
+        catch (e) {
+            this.log.error(constants_1.LOG_PREFIX + e);
+            return false;
+        }
+    };
+    SplitsCacheInLocal.prototype.getChangeNumber = function () {
+        var n = -1;
+        var value = this.storage.getItem(this.keys.buildSplitsTillKey());
+        if (value !== null) {
+            value = parseInt(value, 10);
+            return (0, lang_1.isNaNNumber)(value) ? n : value;
+        }
+        return n;
+    };
+    SplitsCacheInLocal.prototype.getSplitNames = function () {
+        var len = this.storage.length;
+        var accum = [];
+        var cur = 0;
+        while (cur < len) {
+            var key = this.storage.key(cur);
+            if (key != null && this.keys.isSplitKey(key))
+                accum.push(this.keys.extractKey(key));
+            cur++;
+        }
+        return accum;
+    };
+    SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
+        var ttCount = (0, lang_1.toNumber)(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+        return (0, lang_1.isFiniteNumber)(ttCount) && ttCount > 0;
+    };
+    SplitsCacheInLocal.prototype.usesSegments = function () {
+        // If cache hasn't been synchronized with the cloud, assume we need them.
+        if (!this.hasSync)
+            return true;
+        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var splitsWithSegmentsCount = storedCount === null ? 0 : (0, lang_1.toNumber)(storedCount);
+        return (0, lang_1.isFiniteNumber)(splitsWithSegmentsCount) ?
+            splitsWithSegmentsCount > 0 :
+            true;
+    };
+    SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        return flagSets.map(function (flagSet) {
+            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
+            var flagSetFromStorage = _this.storage.getItem(flagSetKey);
+            return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+        });
+    };
+    SplitsCacheInLocal.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;
+            var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
+            var flagSetFromStorage = _this.storage.getItem(flagSetKey);
+            var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+            if (flagSetCache.has(featureFlag.name))
+                return;
+            flagSetCache.add(featureFlag.name);
+            _this.storage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
+        });
+    };
+    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
+        var _this = this;
+        if (!flagSets)
+            return;
+        flagSets.forEach(function (flagSet) {
+            _this.removeNames(flagSet, featureFlagName);
+        });
+    };
+    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
+        var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
+        var flagSetFromStorage = this.storage.getItem(flagSetKey);
+        if (!flagSetFromStorage)
+            return;
+        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
+        flagSetCache.delete(featureFlagName);
+        if (flagSetCache.size === 0) {
+            this.storage.removeItem(flagSetKey);
+            return;
+        }
+        this.storage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
+    };
+    return SplitsCacheInLocal;
+}(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));
+exports.SplitsCacheInLocal = SplitsCacheInLocal;

package/cjs/storages/inLocalStorage/index.js

@@ -7,7 +7,7 @@ var EventsCacheInMemory_1 = require("../inMemory/EventsCacheInMemory");
 var KeyBuilder_1 = require("../KeyBuilder");
 var KeyBuilderCS_1 = require("../KeyBuilderCS");
 var isLocalStorageAvailable_1 = require("../../utils/env/isLocalStorageAvailable");
-var DefinitionsCacheInLocal_1 = require("./DefinitionsCacheInLocal");
+var SplitsCacheInLocal_1 = require("./SplitsCacheInLocal");
 var RBSegmentsCacheInLocal_1 = require("./RBSegmentsCacheInLocal");
 var MySegmentsCacheInLocal_1 = require("./MySegmentsCacheInLocal");
 var InMemoryStorageCS_1 = require("../inMemory/InMemoryStorageCS");
@@ -44,24 +44,24 @@ function InLocalStorage(options) {
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
-        var definitions = new DefinitionsCacheInLocal_1.DefinitionsCacheInLocal(settings, keys, storage);
+        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, storage);
         var rbSegments = new RBSegmentsCacheInLocal_1.RBSegmentsCacheInLocal(settings, keys, storage);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys, storage);
         var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage);
         var validateCachePromise;
         return {
-            definitions: definitions,
+            splits: splits,
             rbSegments: rbSegments,
             segments: segments,
             largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory(),
             events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
-            telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(definitions, segments) : undefined,
+            telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
                 if (!validateCachePromise) {
-                    validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments);
+                    validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
                 }
                 return validateCachePromise;
             },
@@ -74,7 +74,7 @@ function InLocalStorage(options) {
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
-                    definitions: this.definitions,
+                    splits: this.splits,
                     rbSegments: this.rbSegments,
                     segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey), storage),
                     largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage),

package/cjs/storages/inLocalStorage/validateCache.js

@@ -57,16 +57,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  *
  * @returns Metadata object with `initialCacheLoad` (true if is fresh install, false if is ready from cache) and `lastUpdateTimestamp` (timestamp of last cache update or undefined)
  */
-function validateCache(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments) {
+function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
-        var isThereCache = definitions.getChangeNumber() > -1;
+        var isThereCache = splits.getChangeNumber() > -1;
         // Get lastUpdateTimestamp from storage
         var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
         var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : undefined;
         var lastUpdateTimestamp = (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp) && lastUpdatedTimestamp !== undefined) ? lastUpdatedTimestamp : undefined;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-            definitions.clear();
+            splits.clear();
             rbSegments.clear();
             segments.clear();
             largeSegments.clear();

package/cjs/storages/inMemory/InMemoryStorage.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryStorageFactory = void 0;
-var DefinitionsCacheInMemory_1 = require("./DefinitionsCacheInMemory");
+var SplitsCacheInMemory_1 = require("./SplitsCacheInMemory");
 var SegmentsCacheInMemory_1 = require("./SegmentsCacheInMemory");
 var ImpressionsCacheInMemory_1 = require("./ImpressionsCacheInMemory");
 var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
@@ -17,17 +17,17 @@ var RBSegmentsCacheInMemory_1 = require("./RBSegmentsCacheInMemory");
  */
 function InMemoryStorageFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var definitions = new DefinitionsCacheInMemory_1.DefinitionsCacheInMemory(__splitFiltersValidation);
+    var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory_1.RBSegmentsCacheInMemory();
     var segments = new SegmentsCacheInMemory_1.SegmentsCacheInMemory();
     var storage = {
-        definitions: definitions,
+        splits: splits,
         rbSegments: rbSegments,
         segments: segments,
         impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory(),
         events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
-        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(definitions, segments) : undefined,
+        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory(),
         destroy: function () { }
     };

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryStorageCSFactory = void 0;
-var DefinitionsCacheInMemory_1 = require("./DefinitionsCacheInMemory");
+var SplitsCacheInMemory_1 = require("./SplitsCacheInMemory");
 var MySegmentsCacheInMemory_1 = require("./MySegmentsCacheInMemory");
 var ImpressionsCacheInMemory_1 = require("./ImpressionsCacheInMemory");
 var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
@@ -17,25 +17,25 @@ var RBSegmentsCacheInMemory_1 = require("./RBSegmentsCacheInMemory");
  */
 function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var definitions = new DefinitionsCacheInMemory_1.DefinitionsCacheInMemory(__splitFiltersValidation);
+    var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory_1.RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var storage = {
-        definitions: definitions,
+        splits: splits,
         rbSegments: rbSegments,
         segments: segments,
         largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory(),
         events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
-        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(definitions, segments) : undefined,
+        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {
-                definitions: this.definitions,
+                splits: this.splits,
                 rbSegments: this.rbSegments,
                 segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
                 largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),