@splitsoftware/splitio-commons 1.9.1 → 1.9.2-rc.0

package/esm/sdkClient/clientInputValidation.js

@@ -3,6 +3,7 @@ import { validateAttributes, validateEvent, validateEventValue, validateEventPro
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { flagSetsAreValid } from '../utils/settingsValidation/splitFilters';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
@@ -13,18 +14,26 @@ export function clientInputValidationDecorator(settings, client, readinessManage
     /**
      * Avoid repeating this validations code
      */
-    function validateEvaluationParams(maybeKey, maybeFeatureFlagNameOrNames, maybeAttributes, methodName) {
+    function validateEvaluationParams(maybeKey, maybeFeatureFlagNameOrNames, maybeAttributes, methodName, maybeFlagSetNameOrNames) {
         var multi = startsWith(methodName, 'getTreatments');
         var key = validateKey(log, maybeKey, methodName);
-        var splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
+        var splitOrSplits = false;
+        var flagSetOrFlagSets = [];
+        if (maybeFeatureFlagNameOrNames) {
+            splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
+        }
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
+        if (maybeFlagSetNameOrNames) {
+            flagSetOrFlagSets = flagSetsAreValid(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
+        }
         validateIfOperational(log, readinessManager, methodName);
-        var valid = isNotDestroyed && key && splitOrSplits && attributes !== false;
+        var valid = isNotDestroyed && key && (splitOrSplits || flagSetOrFlagSets.length > 0) && attributes !== false;
         return {
             valid: valid,
             key: key,
             splitOrSplits: splitOrSplits,
+            flagSetOrFlagSets: flagSetOrFlagSets,
             attributes: attributes
         };
     }
@@ -73,6 +82,42 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return wrapResult(res_2);
         }
     }
+    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSets', maybeFlagSets);
+        if (params.valid) {
+            return client.getTreatmentsByFlagSets(params.key, params.flagSetOrFlagSets, params.attributes);
+        }
+        else {
+            return wrapResult({});
+        }
+    }
+    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSets', maybeFlagSets);
+        if (params.valid) {
+            return client.getTreatmentsWithConfigByFlagSets(params.key, params.flagSetOrFlagSets, params.attributes);
+        }
+        else {
+            return wrapResult({});
+        }
+    }
+    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSet', [maybeFlagSet]);
+        if (params.valid) {
+            return client.getTreatmentsByFlagSet(params.key, params.flagSetOrFlagSets[0], params.attributes);
+        }
+        else {
+            return wrapResult({});
+        }
+    }
+    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
+        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSet', [maybeFlagSet]);
+        if (params.valid) {
+            return client.getTreatmentsWithConfigByFlagSet(params.key, params.flagSetOrFlagSets[0], params.attributes);
+        }
+        else {
+            return wrapResult({});
+        }
+    }
     function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
         var key = validateKey(log, maybeKey, 'track');
         var tt = validateTrafficType(log, maybeTT, 'track');
@@ -92,6 +137,10 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         getTreatmentWithConfig: getTreatmentWithConfig,
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
+        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
+        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
+        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
+        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
         track: track
     };
 }

package/esm/sdkManager/index.js

@@ -24,7 +24,8 @@ function objectToView(splitObject) {
         killed: splitObject.killed,
         changeNumber: splitObject.changeNumber || 0,
         treatments: collectTreatments(splitObject),
-        configs: splitObject.configurations || {}
+        configs: splitObject.configurations || {},
+        sets: splitObject.sets || []
     };
 }
 function objectsToViews(splitObjects) {

package/esm/services/splitApi.js

@@ -1,6 +1,7 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
@@ -37,7 +38,12 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
         },
         fetchSplitChanges: function (since, noCache, till) {
             var url = urls.sdk + "/splitChanges?since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
+                .catch(function (err) {
+                if (err.statusCode === 414)
+                    settings.log.error(ERROR_TOO_MANY_SETS);
+                throw err;
+            });
         },
         fetchSegmentChanges: function (since, segmentName, noCache, till) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');

package/esm/storages/KeyBuilder.js

@@ -12,6 +12,9 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
         return this.prefix + ".trafficType." + trafficType;
     };
+    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
+        return this.prefix + ".flagset." + flagSet;
+    };
     KeyBuilder.prototype.buildSplitKey = function (splitName) {
         return this.prefix + ".split." + splitName;
     };

package/esm/storages/KeyBuilderSS.js

@@ -5,6 +5,10 @@ export var METHOD_NAMES = {
     ts: 'treatments',
     tc: 'treatmentWithConfig',
     tcs: 'treatmentsWithConfig',
+    tf: 'treatmentsByFlagSet',
+    tfs: 'treatmentsByFlagSets',
+    tcf: 'treatmentsWithConfigByFlagSet',
+    tcfs: 'treatmentsWithConfigByFlagSets',
     tr: 'track'
 };
 var KeyBuilderSS = /** @class */ (function (_super) {

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -2,6 +2,7 @@ import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
+import { _Set, returnSetsUnion, setToArray } from '../../utils/lang/sets';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -13,12 +14,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * @param {ISplitFiltersValidation} splitFiltersValidation
      */
     function SplitsCacheInLocal(log, keys, expirationTimestamp, splitFiltersValidation) {
-        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { byName: [], byPrefix: [] }, validFilters: [] }; }
+        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
         var _this = _super.call(this) || this;
         _this.log = log;
-        _this.cacheReadyButNeedsToFlush = false;
         _this.keys = keys;
         _this.splitFiltersValidation = splitFiltersValidation;
+        _this.flagSetsFilter = _this.splitFiltersValidation.groupedFilters.bySet;
         _this._checkExpiration(expirationTimestamp);
         _this._checkFilterQuery();
         return _this;
@@ -91,6 +92,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             localStorage.setItem(splitKey, JSON.stringify(split));
             this._incrementCounts(split);
             this._decrementCounts(previousSplit);
+            if (previousSplit)
+                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+            this.addToFlagSets(split);
             return true;
         }
         catch (e) {
@@ -103,6 +107,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var split = this.getSplit(name);
             localStorage.removeItem(this.keys.buildSplitKey(name));
             this._decrementCounts(split);
+            if (split)
+                this.removeFromFlagSets(split.name, split.sets);
             return true;
         }
         catch (e) {
@@ -115,11 +121,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        // when cache is ready but using a new split query, we must clear all split data
-        if (this.cacheReadyButNeedsToFlush) {
-            this.clear();
-            this.cacheReadyButNeedsToFlush = false;
-        }
         // when using a new split query, we must update it at the store
         if (this.updateNewFilter) {
             this.log.info(LOG_PREFIX + 'Split filter query was modified. Updating cache.');
@@ -192,7 +193,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * @override
      */
     SplitsCacheInLocal.prototype.checkCache = function () {
-        return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;
+        return this.getChangeNumber() > -1;
     };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
@@ -208,31 +209,16 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype._checkFilterQuery = function () {
-        var _this = this;
-        var _a = this.splitFiltersValidation, queryString = _a.queryString, groupedFilters = _a.groupedFilters;
+        var queryString = this.splitFiltersValidation.queryString;
         var queryKey = this.keys.buildSplitsFilterQueryKey();
         var currentQueryString = localStorage.getItem(queryKey);
         if (currentQueryString !== queryString) {
             try {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
-                // if cache is ready:
-                if (this.checkCache()) {
-                    // * set change number to -1, to fetch splits with -1 `since` value.
-                    localStorage.setItem(this.keys.buildSplitsTillKey(), '-1');
-                    // * remove from cache splits that doesn't match with the new filters
-                    this.getSplitNames().forEach(function (splitName) {
-                        if (queryString && (
-                        // @TODO consider redefining `groupedFilters` to expose a method like `groupedFilters::filter(splitName): boolean`
-                        groupedFilters.byName.indexOf(splitName) > -1 ||
-                            groupedFilters.byPrefix.some(function (prefix) { return splitName.startsWith(prefix + '__'); }))) {
-                            // * set `cacheReadyButNeedsToFlush` so that `checkCache` returns true (the storage is ready to be used) and the data is cleared before updating on first successful splits fetch
-                            _this.cacheReadyButNeedsToFlush = true;
-                            return;
-                        }
-                        _this.removeSplit(splitName);
-                    });
-                }
+                // if there is cache, clear it
+                if (this.checkCache())
+                    this.clear();
             }
             catch (e) {
                 this.log.error(LOG_PREFIX + e);
@@ -240,6 +226,56 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
         // if the filter didn't change, nothing is done
     };
+    SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        var toReturn = new _Set([]);
+        flagSets.forEach(function (flagSet) {
+            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
+            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+            if (flagSetFromLocalStorage) {
+                var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+                toReturn = returnSetsUnion(toReturn, flagSetCache);
+            }
+        });
+        return toReturn;
+    };
+    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 flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+            if (!flagSetFromLocalStorage)
+                flagSetFromLocalStorage = '[]';
+            var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+            flagSetCache.add(featureFlag.name);
+            localStorage.setItem(flagSetKey, JSON.stringify(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 flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+        if (!flagSetFromLocalStorage)
+            return;
+        var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+        flagSetCache.delete(featureFlagName);
+        if (flagSetCache.size === 0) {
+            localStorage.removeItem(flagSetKey);
+            return;
+        }
+        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+    };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));
 export { SplitsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -43,7 +43,7 @@ export function InLocalStorage(options) {
             uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
                 var _a;
-                this.splits = new SplitsCacheInMemory();
+                this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
@@ -61,7 +61,7 @@ export function InLocalStorage(options) {
                     events: this.events,
                     telemetry: this.telemetry,
                     destroy: function () {
-                        this.splits = new SplitsCacheInMemory();
+                        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory();
                     }
                 };

package/esm/storages/inMemory/InMemoryStorage.js

@@ -12,8 +12,8 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
-    var splits = new SplitsCacheInMemory();
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new SegmentsCacheInMemory();
     var storage = {
         splits: splits,

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -12,8 +12,8 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
-    var splits = new SplitsCacheInMemory();
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
@@ -43,7 +43,7 @@ export function InMemoryStorageCSFactory(params) {
                 telemetry: this.telemetry,
                 // Set a new splits cache to clean it for the client without affecting other clients
                 destroy: function () {
-                    this.splits = new SplitsCacheInMemory();
+                    this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
                 }
             };

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,18 +1,22 @@
 import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
+import { _Set, returnSetsUnion } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     __extends(SplitsCacheInMemory, _super);
-    function SplitsCacheInMemory() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
+    function SplitsCacheInMemory(splitFiltersValidation) {
+        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
+        var _this = _super.call(this) || this;
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
         _this.splitsWithSegmentsCount = 0;
+        _this.flagSetsCache = {};
+        _this.flagSetsFilter = splitFiltersValidation.groupedFilters.bySet;
         return _this;
     }
     SplitsCacheInMemory.prototype.clear = function () {
@@ -28,6 +32,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[previousTtName]--;
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
             if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
                 this.splitsWithSegmentsCount--;
             }
@@ -38,6 +43,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             // 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 (usesSegments(split))
                 this.splitsWithSegmentsCount++;
@@ -56,6 +62,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             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 (usesSegments(split))
                 this.splitsWithSegmentsCount--;
@@ -84,6 +91,44 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.usesSegments = function () {
         return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
+    SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
+        var _this = this;
+        var toReturn = new _Set([]);
+        flagSets.forEach(function (flagSet) {
+            var featureFlagNames = _this.flagSetsCache[flagSet];
+            if (featureFlagNames) {
+                toReturn = returnSetsUnion(toReturn, featureFlagNames);
+            }
+        });
+        return toReturn;
+    };
+    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));
 export { SplitsCacheInMemory };

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -2,6 +2,7 @@ import { __extends } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { _Set } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -168,6 +169,16 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
+    /**
+     * Get list of split names related to a given flag set names list.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if wrapper operation fails.
+     * @todo this is a no-op method to be implemented
+    */
+    SplitsCacheInRedis.prototype.getNamesByFlagSets = function () {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return new Promise(function (flagSets) { return new _Set([]); });
+    };
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -2,6 +2,7 @@ import { __extends } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { _Set } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -142,6 +143,16 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var _this = this;
         return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
+    /**
+     * Get list of split names related to a given flag set names list.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if wrapper operation fails.
+     * @todo this is a no-op method to be implemented
+    */
+    SplitsCachePluggable.prototype.getNamesByFlagSets = function () {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return new Promise(function (flagSets) { return new _Set([]); });
+    };
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -5,5 +5,5 @@ import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -2,6 +2,7 @@ import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { startsWith } from '../../../utils/lang';
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -28,15 +29,34 @@ export function parseSegments(_a) {
     }
     return segments;
 }
+/**
+ * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
+ * If there are set filter defined, names filter is ignored
+ *
+ * @param featureFlag feature flag to be evaluated
+ * @param filters splitFiltersValidation bySet | byName
+ */
+function matchFilters(featureFlag, filters) {
+    var _a = filters.groupedFilters, setsFilter = _a.bySet, namesFilter = _a.byName, prefixFilter = _a.byPrefix;
+    if (setsFilter.length > 0)
+        return featureFlag.sets && featureFlag.sets.some(function (featureFlagSet) { return setsFilter.indexOf(featureFlagSet) > -1; });
+    var namesFilterConfigured = namesFilter.length > 0;
+    var prefixFilterConfigured = prefixFilter.length > 0;
+    if (!namesFilterConfigured && !prefixFilterConfigured)
+        return true;
+    var matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
+    var matchPrefix = prefixFilterConfigured && prefixFilter.some(function (prefix) { return startsWith(featureFlag.name, prefix); });
+    return matchNames || matchPrefix;
+}
 /**
  * Given the list of splits from /splitChanges endpoint, it returns the mutations,
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeSplitsMutation(entries) {
+export function computeSplitsMutation(entries, filters) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
-        if (split.status === 'ACTIVE') {
+        if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
             accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
@@ -64,7 +84,7 @@ export function computeSplitsMutation(entries) {
  * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
     var startingUp = true;
@@ -94,7 +114,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
                 startingUp = false;
-                var mutation = computeSplitsMutation(splitChanges.splits);
+                var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
                 log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
                 log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
                 log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);

package/esm/sync/submitters/telemetrySubmitter.js

@@ -29,6 +29,17 @@ function getRedundantActiveFactories() {
         return acum + usedKeysMap[sdkKey] - 1;
     }, 0);
 }
+function getTelemetryFlagSetsStats(splitFiltersValidation) {
+    // Group every configured flag set in an unique array called originalSets
+    var flagSetsTotal = 0;
+    splitFiltersValidation.validFilters.forEach(function (filter) {
+        if (filter.type === 'bySet')
+            flagSetsTotal += filter.values.length;
+    });
+    var flagSetsValid = splitFiltersValidation.groupedFilters.bySet.length;
+    var flagSetsIgnored = flagSetsTotal - flagSetsValid;
+    return { flagSetsTotal: flagSetsTotal, flagSetsIgnored: flagSetsIgnored };
+}
 export function getTelemetryConfigStats(mode, storageType) {
     return {
         oM: OPERATION_MODE_MAP[mode],
@@ -47,6 +58,7 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         pop: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
             var isClientSide = settings.core.key !== undefined;
+            var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
@@ -74,7 +86,9 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
                 nR: telemetry.getNonReadyUsage(),
                 t: telemetry.popTags(),
                 i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0,
+                fsT: flagSetsTotal,
+                fsI: flagSetsIgnored
             });
         }
     };

package/esm/utils/constants/index.js

@@ -51,6 +51,10 @@ export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';
 export var TREATMENTS_WITH_CONFIG = 'tcs';
+export var TREATMENTS_BY_FLAGSET = 'tf';
+export var TREATMENTS_BY_FLAGSETS = 'tfs';
+export var TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf';
+export var TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs';
 export var TRACK = 'tr';
 export var CONNECTION_ESTABLISHED = 0;
 export var OCCUPANCY_PRI = 10;

package/esm/utils/lang/sets.js

@@ -95,3 +95,10 @@ export function __getSetConstructor() {
     return SetPoly;
 }
 export var _Set = __getSetConstructor();
+export function returnSetsUnion(set, set2) {
+    var result = new _Set(setToArray(set));
+    set2.forEach(function (value) {
+        result.add(value);
+    });
+    return result;
+}