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

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -4,18 +4,22 @@ exports.SplitsCacheInMemory = void 0;
 var tslib_1 = require("tslib");
 var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     (0, tslib_1.__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 () {
@@ -31,6 +35,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[previousTtName]--;
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit)) { // Substract from segments count for the previous version of this Split.
                 this.splitsWithSegmentsCount--;
             }
@@ -41,6 +46,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 ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
                 this.splitsWithSegmentsCount++;
@@ -59,6 +65,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 ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
                 this.splitsWithSegmentsCount--;
@@ -87,6 +94,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 sets_1._Set([]);
+        flagSets.forEach(function (flagSet) {
+            var featureFlagNames = _this.flagSetsCache[flagSet];
+            if (featureFlagNames) {
+                toReturn = (0, sets_1.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 sets_1._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/inRedis/SplitsCacheInRedis.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./constants");
 var AbstractSplitsCacheAsync_1 = require("../AbstractSplitsCacheAsync");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -171,6 +172,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 sets_1._Set([]); });
+    };
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/cjs/storages/pluggable/SplitsCachePluggable.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./constants");
 var AbstractSplitsCacheAsync_1 = require("../AbstractSplitsCacheAsync");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -145,6 +146,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 sets_1._Set([]); });
+    };
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

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

@@ -8,6 +8,6 @@ var splitChangesUpdater_1 = require("../updaters/splitChangesUpdater");
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage.splits, storage.segments, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }
 exports.splitsSyncTaskFactory = splitsSyncTaskFactory;

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

@@ -5,6 +5,7 @@ var sets_1 = require("../../../utils/lang/sets");
 var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
+var lang_1 = require("../../../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
@@ -32,15 +33,34 @@ function parseSegments(_a) {
     return segments;
 }
 exports.parseSegments = parseSegments;
+/**
+ * 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 (0, lang_1.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.
  */
-function computeSplitsMutation(entries) {
+function computeSplitsMutation(entries, filters) {
     var segments = new sets_1._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);
@@ -69,7 +89,7 @@ exports.computeSplitsMutation = computeSplitsMutation;
  * @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.
  */
-function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+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;
@@ -99,7 +119,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
                 startingUp = false;
-                var mutation = computeSplitsMutation(splitChanges.splits);
+                var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
                 log.debug(constants_2.SYNC_SPLITS_NEW, [mutation.added.length]);
                 log.debug(constants_2.SYNC_SPLITS_REMOVED, [mutation.removed.length]);
                 log.debug(constants_2.SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -32,6 +32,17 @@ function getRedundantActiveFactories() {
         return acum + apiKey_1.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 };
+}
 function getTelemetryConfigStats(mode, storageType) {
     return {
         oM: OPERATION_MODE_MAP[mode],
@@ -51,6 +62,7 @@ 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 (0, objectAssign_1.objectAssign)(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
@@ -78,7 +90,9 @@ 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/cjs/utils/constants/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ABLY_ERROR = exports.TOKEN_REFRESH = exports.SSE_CONNECTION_ERROR = exports.STREAMING_STATUS = exports.OCCUPANCY_SEC = exports.OCCUPANCY_PRI = exports.CONNECTION_ESTABLISHED = exports.TRACK = exports.TREATMENTS_WITH_CONFIG = exports.TREATMENT_WITH_CONFIG = exports.TREATMENTS = exports.TREATMENT = exports.MY_SEGMENT = exports.SEGMENT = exports.TOKEN = exports.TELEMETRY = exports.EVENTS = exports.IMPRESSIONS_COUNT = exports.IMPRESSIONS = exports.SPLITS = exports.NONE_ENUM = exports.DEBUG_ENUM = exports.OPTIMIZED_ENUM = exports.CONSUMER_PARTIAL_ENUM = exports.CONSUMER_ENUM = exports.STANDALONE_ENUM = exports.DEDUPED = exports.DROPPED = exports.QUEUED = exports.CONSENT_UNKNOWN = exports.CONSENT_DECLINED = exports.CONSENT_GRANTED = exports.STORAGE_PLUGGABLE = exports.STORAGE_REDIS = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_MEMORY = exports.CONSUMER_PARTIAL_MODE = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = exports.NONE = exports.OPTIMIZED = exports.DEBUG = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = void 0;
-exports.PAUSED = exports.ENABLED = exports.DISABLED = exports.NON_REQUESTED = exports.REQUESTED = exports.POLLING = exports.STREAMING = exports.AUTH_REJECTION = exports.SYNC_MODE_UPDATE = void 0;
+exports.OCCUPANCY_SEC = exports.OCCUPANCY_PRI = exports.CONNECTION_ESTABLISHED = exports.TRACK = exports.TREATMENTS_WITH_CONFIG_BY_FLAGSETS = exports.TREATMENTS_WITH_CONFIG_BY_FLAGSET = exports.TREATMENTS_BY_FLAGSETS = exports.TREATMENTS_BY_FLAGSET = exports.TREATMENTS_WITH_CONFIG = exports.TREATMENT_WITH_CONFIG = exports.TREATMENTS = exports.TREATMENT = exports.MY_SEGMENT = exports.SEGMENT = exports.TOKEN = exports.TELEMETRY = exports.EVENTS = exports.IMPRESSIONS_COUNT = exports.IMPRESSIONS = exports.SPLITS = exports.NONE_ENUM = exports.DEBUG_ENUM = exports.OPTIMIZED_ENUM = exports.CONSUMER_PARTIAL_ENUM = exports.CONSUMER_ENUM = exports.STANDALONE_ENUM = exports.DEDUPED = exports.DROPPED = exports.QUEUED = exports.CONSENT_UNKNOWN = exports.CONSENT_DECLINED = exports.CONSENT_GRANTED = exports.STORAGE_PLUGGABLE = exports.STORAGE_REDIS = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_MEMORY = exports.CONSUMER_PARTIAL_MODE = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = exports.NONE = exports.OPTIMIZED = exports.DEBUG = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = void 0;
+exports.PAUSED = exports.ENABLED = exports.DISABLED = exports.NON_REQUESTED = exports.REQUESTED = exports.POLLING = exports.STREAMING = exports.AUTH_REJECTION = exports.SYNC_MODE_UPDATE = exports.ABLY_ERROR = exports.TOKEN_REFRESH = exports.SSE_CONNECTION_ERROR = exports.STREAMING_STATUS = void 0;
 // Special treatments
 exports.CONTROL = 'control';
 exports.CONTROL_WITH_CONFIG = {
@@ -55,6 +55,10 @@ exports.TREATMENT = 't';
 exports.TREATMENTS = 'ts';
 exports.TREATMENT_WITH_CONFIG = 'tc';
 exports.TREATMENTS_WITH_CONFIG = 'tcs';
+exports.TREATMENTS_BY_FLAGSET = 'tf';
+exports.TREATMENTS_BY_FLAGSETS = 'tfs';
+exports.TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf';
+exports.TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs';
 exports.TRACK = 'tr';
 exports.CONNECTION_ESTABLISHED = 0;
 exports.OCCUPANCY_PRI = 10;

package/cjs/utils/lang/sets.js

@@ -24,7 +24,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 **/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._Set = exports.__getSetConstructor = exports.setToArray = exports.SetPoly = void 0;
+exports.returnSetsUnion = exports._Set = exports.__getSetConstructor = exports.setToArray = exports.SetPoly = void 0;
 var SetPoly = /** @class */ (function () {
     // unlike ES6 `Set`, it only accepts an array as first argument iterable
     function SetPoly(values) {
@@ -100,3 +100,11 @@ function __getSetConstructor() {
 }
 exports.__getSetConstructor = __getSetConstructor;
 exports._Set = __getSetConstructor();
+function returnSetsUnion(set, set2) {
+    var result = new exports._Set(setToArray(set));
+    set2.forEach(function (value) {
+        result.add(value);
+    });
+    return result;
+}
+exports.returnSetsUnion = returnSetsUnion;

package/cjs/utils/settingsValidation/splitFilters.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplitFilters = void 0;
+exports.flagSetsAreValid = exports.validateSplitFilters = void 0;
 var constants_1 = require("../constants");
 var splits_1 = require("../inputValidation/splits");
 var constants_2 = require("../../logger/constants");
+var objectAssign_1 = require("../lang/objectAssign");
+var lang_1 = require("../lang");
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
 var FILTERS_METADATA = [
+    {
+        type: 'bySet',
+        maxLength: 50,
+        queryParam: 'sets='
+    },
     {
         type: 'byName',
         maxLength: 400,
@@ -18,6 +25,8 @@ var FILTERS_METADATA = [
         queryParam: 'prefixes='
     }
 ];
+var VALID_FLAGSET_REGEX = /^[a-z0-9][_a-z0-9]{0,49}$/;
+var CAPITAL_LETTERS_REGEX = /[A-Z]/;
 /**
  * Validates that the given value is a valid filter type
  */
@@ -38,6 +47,9 @@ function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
     var result = (0, splits_1.validateSplits)(log, values, constants_2.LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
     if (result) {
+        if (type === 'bySet') {
+            result = sanitizeFlagSets(log, result);
+        }
         // check max length
         if (result.length > maxLength)
             throw new Error(maxLength + " unique values can be specified at most for '" + type + "' filter. You passed " + result.length + ". Please consider reducing the amount or using other filter.");
@@ -68,6 +80,42 @@ function queryStringBuilder(groupedFilters) {
     });
     return queryParams.length > 0 ? '&' + queryParams.join('&') : null;
 }
+/**
+ * Sanitizes set names list taking in account:
+ *  - It should be lowercase
+ *  - Must adhere the following regular expression /^[a-z0-9][_a-z0-9]{0,49}$/ that means
+ *   - must start with a letter or number
+ *   - Be in lowercase
+ *   - Be alphanumeric
+ *   - have a max length of 50 characters
+ *
+ * @param {ILogger} log
+ * @param {string[]} flagSets
+ * @returns sanitized list of set names
+ */
+function sanitizeFlagSets(log, flagSets) {
+    var sanitizedSets = flagSets
+        .map(function (flagSet) {
+        if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
+            log.warn(constants_2.WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
+            flagSet = flagSet.toLowerCase();
+        }
+        return flagSet;
+    })
+        .filter(function (flagSet) {
+        if (!VALID_FLAGSET_REGEX.test(flagSet)) {
+            log.warn(constants_2.WARN_SPLITS_FILTER_INVALID_SET, [flagSet, VALID_FLAGSET_REGEX, flagSet]);
+            return false;
+        }
+        if (typeof flagSet !== 'string')
+            return false;
+        return true;
+    });
+    return (0, lang_1.uniq)(sanitizedSets);
+}
+function configuredFilter(validFilters, filterType) {
+    return (0, lang_1.find)(validFilters, function (filter) { return filter.type === filterType && filter.values.length > 0; });
+}
 /**
  * Validates `splitFilters` configuration object and parses it into a query string for filtering splits on `/splitChanges` fetch.
  *
@@ -86,7 +134,7 @@ function validateSplitFilters(log, maybeSplitFilters, mode) {
     var res = {
         validFilters: [],
         queryString: null,
-        groupedFilters: { byName: [], byPrefix: [] }
+        groupedFilters: { bySet: [], byName: [], byPrefix: [] },
     };
     // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
     if (!maybeSplitFilters)
@@ -118,9 +166,36 @@ function validateSplitFilters(log, maybeSplitFilters, mode) {
         if (res.groupedFilters[type].length > 0)
             res.groupedFilters[type] = validateSplitFilter(log, type, res.groupedFilters[type], maxLength);
     });
+    var setFilter = configuredFilter(res.validFilters, 'bySet');
+    // Clean all filters if set filter is present
+    if (setFilter) {
+        if (configuredFilter(res.validFilters, 'byName') || configuredFilter(res.validFilters, 'byPrefix'))
+            log.error(constants_2.ERROR_SETS_FILTER_EXCLUSIVE);
+        (0, objectAssign_1.objectAssign)(res.groupedFilters, { byName: [], byPrefix: [] });
+    }
     // build query string
     res.queryString = queryStringBuilder(res.groupedFilters);
     log.debug(constants_2.SETTINGS_SPLITS_FILTER, [res.queryString]);
     return res;
 }
 exports.validateSplitFilters = validateSplitFilters;
+function flagSetsAreValid(log, method, flagSets, flagSetsInConfig) {
+    var toReturn = [];
+    if (flagSets.length === 0) {
+        log.error(constants_2.ERROR_EMPTY_ARRAY, [method, 'flagSets']);
+        return toReturn;
+    }
+    var sets = (0, splits_1.validateSplits)(log, flagSets, method, 'flag sets', 'flag set');
+    toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+    if (flagSetsInConfig.length > 0) {
+        toReturn = toReturn.filter(function (flagSet) {
+            if (flagSetsInConfig.indexOf(flagSet) > -1) {
+                return true;
+            }
+            log.warn(constants_2.WARN_FLAGSET_NOT_CONFIGURED, [flagSet]);
+            return false;
+        });
+    }
+    return toReturn;
+}
+exports.flagSetsAreValid = flagSetsAreValid;

package/esm/evaluator/index.js

@@ -2,6 +2,7 @@ import { Engine } from './Engine';
 import { thenable } from '../utils/promise/thenable';
 import * as LabelsConstants from '../utils/labels';
 import { CONTROL } from '../utils/constants';
+import { setToArray } from '../utils/lang/sets';
 var treatmentException = {
     treatment: CONTROL,
     label: LabelsConstants.EXCEPTION,
@@ -49,6 +50,21 @@ export function evaluateFeatures(log, key, splitNames, attributes, storage) {
         }) :
         getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
+export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage) {
+    var storedFlagNames;
+    // get features by flag sets
+    try {
+        storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
+    }
+    catch (e) {
+        // return empty evaluations
+        return {};
+    }
+    // evaluate related features
+    return thenable(storedFlagNames) ?
+        storedFlagNames.then(function (splitNames) { return evaluateFeatures(log, key, setToArray(splitNames), attributes, storage); }) :
+        evaluateFeatures(log, key, setToArray(storedFlagNames), attributes, storage);
+}
 function getEvaluation(log, splitJSON, key, attributes, storage) {
     var evaluation = {
         treatment: CONTROL,

package/esm/logger/constants.js

@@ -95,6 +95,9 @@ export var WARN_SPLITS_FILTER_EMPTY = 221;
 export var WARN_SDK_KEY = 222;
 export var STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export var STREAMING_PARSING_SPLIT_UPDATE = 224;
+export var WARN_SPLITS_FILTER_INVALID_SET = 225;
+export var WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export var WARN_FLAGSET_NOT_CONFIGURED = 227;
 export var ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export var ERROR_LOGLEVEL_INVALID = 301;
 export var ERROR_CLIENT_LISTENER = 302;
@@ -122,6 +125,8 @@ export var ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export var ERROR_STORAGE_INVALID = 324;
 export var ERROR_NOT_BOOLEAN = 325;
 export var ERROR_MIN_CONFIG_PARAM = 326;
+export var ERROR_TOO_MANY_SETS = 327;
+export var ERROR_SETS_FILTER_EXCLUSIVE = 328;
 // Log prefixes (a.k.a. tags or categories)
 export var LOG_PREFIX_SETTINGS = 'settings';
 export var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';

package/esm/logger/messages/error.js

@@ -33,4 +33,6 @@ export var codesError = [
     [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
     [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],
     [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
+    [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the amount of flag sets provided are big causing uri length error.'],
+    [c.ERROR_SETS_FILTER_EXCLUSIVE, c.LOG_PREFIX_SETTINGS + ': the Set filter is exclusive and cannot be used simultaneously with names or prefix filters. Ignoring names and prefixes.'],
 ];

package/esm/logger/messages/warn.js

@@ -26,9 +26,11 @@ export var codesWarn = codesError.concat([
     // initialization / settings validation
     [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS + ': %s integration item(s) at settings is invalid. %s'],
     [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS + ': feature flag filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],
-    [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'],
+    [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("bySet", "byName" or "byPrefix") and a list of "values".'],
     [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
     [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
     [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
     [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
+    [c.WARN_SPLITS_FILTER_INVALID_SET, c.LOG_PREFIX_SETTINGS + ': you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
+    [c.WARN_SPLITS_FILTER_LOWERCASE_SET, c.LOG_PREFIX_SETTINGS + ': flag set %s should be all lowercase - converting string to lowercase.'],
 ]);

package/esm/myLogger.js

@@ -0,0 +1,31 @@
+// get the Console class
+// const { Console } = require('console');
+// get fs module for creating write streams
+var fs = require('fs');
+var pjson = require('../package.json');
+//@ts-ignore
+var pad = function (value) { return ('00' + value).slice(-2); };
+var getDate = function () {
+    var date = new Date();
+    return date.getFullYear() + "-" + pad(date.getMonth() + 1) + "-" + pad(date.getDate()) + "_" + pad(date.getHours()) + ":" + pad(date.getMinutes()) + ":" + pad(date.getSeconds());
+};
+//@ts-ignore
+var logToFile = function (file, msg) {
+    //@ts-ignore
+    fs.appendFileSync(file, msg + "\n", function (err) {
+        if (err) {
+            return console.log(err);
+        }
+    });
+};
+// make a new logger
+var version = pjson.version.replace('.', '').replace('.', '');
+var filePath = "logs/" + version + "_" + getDate();
+export var myLogger = {
+    //@ts-ignore
+    log: function (msg) { return logToFile(filePath, msg); },
+    //@ts-ignore
+    logCsv: function (msg) { return logToFile(filePath + ".csv", msg); },
+    //@ts-ignore
+    logToFile: function (file, msg) { return logToFile("logs/" + file, msg); },
+};

package/esm/sdkClient/client.js

@@ -1,10 +1,10 @@
-import { evaluateFeature, evaluateFeatures } from '../evaluator';
+import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET } from '../utils/constants';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
 var treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
@@ -64,6 +64,35 @@ export function clientFactory(params) {
     function getTreatmentsWithConfig(key, featureFlagNames, attributes) {
         return getTreatments(key, featureFlagNames, attributes, true);
     }
+    function getTreatmentsByFlagSets(key, flagSetNames, attributes, withConfig, method) {
+        if (withConfig === void 0) { withConfig = false; }
+        if (method === void 0) { method = TREATMENTS_BY_FLAGSETS; }
+        var stopTelemetryTracker = telemetryTracker.trackEval(method);
+        var wrapUp = function (evaluationResults) {
+            var queue = [];
+            var treatments = {};
+            var evaluations = evaluationResults;
+            Object.keys(evaluations).forEach(function (featureFlagName) {
+                treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, "getTreatmentsByFlagSets" + (withConfig ? 'WithConfig' : ''), queue);
+            });
+            impressionsTracker.track(queue, attributes);
+            stopTelemetryTracker(queue[0] && queue[0].label);
+            return treatments;
+        };
+        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage) :
+            isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
+        return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
+    }
+    function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes) {
+        return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS);
+    }
+    function getTreatmentsByFlagSet(key, flagSetName, attributes) {
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET);
+    }
+    function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes) {
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET);
+    }
     // Internal function
     function processEvaluation(evaluation, featureFlagName, key, attributes, withConfig, invokingMethodName, queue) {
         var matchingKey = getMatching(key);
@@ -122,6 +151,10 @@ export function clientFactory(params) {
         getTreatmentWithConfig: getTreatmentWithConfig,
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
+        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
+        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
+        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
+        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
         track: track,
         isClientSide: false
     };

package/esm/sdkClient/clientAttributesDecoration.js

@@ -11,6 +11,10 @@ export function clientAttributesDecoration(log, client) {
     var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
     var clientGetTreatments = client.getTreatments;
     var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+    var clientGetTreatmentsByFlagSets = client.getTreatmentsByFlagSets;
+    var clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
+    var clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
+    var clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
     var clientTrack = client.track;
     function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
         return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
@@ -24,6 +28,18 @@ export function clientAttributesDecoration(log, client) {
     function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
         return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
     }
+    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
+        return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
+        return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
+        return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
+        return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
+    }
     function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
         return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
     }
@@ -39,6 +55,10 @@ export function clientAttributesDecoration(log, client) {
         getTreatmentWithConfig: getTreatmentWithConfig,
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
+        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
+        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
+        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
+        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
         track: track,
         /**
          * Add an attribute to client's in memory attributes storage

package/esm/sdkClient/clientCS.js

@@ -15,6 +15,10 @@ export function clientCSDecorator(log, client, key, trafficType) {
         getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
         getTreatments: clientCS.getTreatments.bind(clientCS, key),
         getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
+        getTreatmentsByFlagSets: clientCS.getTreatmentsByFlagSets.bind(clientCS, key),
+        getTreatmentsWithConfigByFlagSets: clientCS.getTreatmentsWithConfigByFlagSets.bind(clientCS, key),
+        getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
+        getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
         // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
         track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
         isClientSide: true