@splitsoftware/splitio-commons 1.10.0 → 1.10.1-rc.0

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;
+}

package/esm/utils/settingsValidation/index.js

@@ -176,7 +176,7 @@ export function settingsValidation(config, validationParams) {
         withDefaults.sync.enabled = true;
     }
     // validate the `splitFilters` settings and parse splits query
-    var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
+    var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
     // ensure a valid user consent value

package/esm/utils/settingsValidation/splitFilters.js

@@ -1,9 +1,15 @@
-import { STANDALONE_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS } from '../../logger/constants';
+import { WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_SPLITS_FILTER_LOWERCASE_SET, WARN_SPLITS_FILTER_INVALID_SET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
+import { objectAssign } from '../lang/objectAssign';
+import { find, uniq } from '../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,
@@ -15,6 +21,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
  */
@@ -35,6 +43,9 @@ function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
     var result = validateSplits(log, values, 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.");
@@ -65,12 +76,47 @@ 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(WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
+            flagSet = flagSet.toLowerCase();
+        }
+        return flagSet;
+    })
+        .filter(function (flagSet) {
+        if (!VALID_FLAGSET_REGEX.test(flagSet)) {
+            log.warn(WARN_SPLITS_FILTER_INVALID_SET, [flagSet, VALID_FLAGSET_REGEX, flagSet]);
+            return false;
+        }
+        if (typeof flagSet !== 'string')
+            return false;
+        return true;
+    });
+    return uniq(sanitizedSets);
+}
+function configuredFilter(validFilters, filterType) {
+    return 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.
  *
  * @param {ILogger} log logger
  * @param {any} maybeSplitFilters split filters configuration param provided by the user
- * @param {string} mode settings mode
  * @returns it returns an object with the following properties:
  *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.
  *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.
@@ -78,21 +124,16 @@ function queryStringBuilder(groupedFilters) {
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export function validateSplitFilters(log, maybeSplitFilters, mode) {
+export function validateSplitFilters(log, maybeSplitFilters) {
     // Validation result schema
     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)
         return res;
-    // Warn depending on the mode
-    if (mode !== STANDALONE_MODE) {
-        log.warn(WARN_SPLITS_FILTER_IGNORED, [STANDALONE_MODE]);
-        return res;
-    }
     // Check collection type
     if (!Array.isArray(maybeSplitFilters) || maybeSplitFilters.length === 0) {
         log.warn(WARN_SPLITS_FILTER_EMPTY);
@@ -115,8 +156,29 @@ export 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(ERROR_SETS_FILTER_EXCLUSIVE);
+        objectAssign(res.groupedFilters, { byName: [], byPrefix: [] });
+    }
     // build query string
     res.queryString = queryStringBuilder(res.groupedFilters);
     log.debug(SETTINGS_SPLITS_FILTER, [res.queryString]);
     return res;
 }
+export function flagSetsAreValid(log, method, flagSets, flagSetsInConfig) {
+    var sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
+    var toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+    if (flagSetsInConfig.length > 0) {
+        toReturn = toReturn.filter(function (flagSet) {
+            if (flagSetsInConfig.indexOf(flagSet) > -1) {
+                return true;
+            }
+            log.warn(WARN_FLAGSET_NOT_CONFIGURED, [method, flagSet]);
+            return false;
+        });
+    }
+    return toReturn;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.10.0",
+  "version": "1.10.1-rc.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -22,7 +22,7 @@
     "build": "npm run build:cjs && npm run build:esm",
     "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
-    "test": "jest --runInBand",
+    "test": "jest",
     "test:coverage": "jest --coverage",
     "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",

package/src/dtos/types.ts

@@ -163,7 +163,8 @@ export interface ISplit {
   trafficAllocationSeed?: number
   configurations?: {
     [treatmentName: string]: string
-  }
+  },
+  sets?: string[]
 }
 
 // Split definition used in offline mode
@@ -208,5 +209,5 @@ export interface IMetadata {
 export type ISplitFiltersValidation = {
   queryString: string | null,
   groupedFilters: Record<SplitIO.SplitFilterType, string[]>,
-  validFilters: SplitIO.SplitFilter[]
+  validFilters: SplitIO.SplitFilter[],
 };

package/src/evaluator/index.ts

@@ -7,6 +7,7 @@ import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
+import { ISet, setToArray } from '../utils/lang/sets';
 
 const treatmentException = {
   treatment: CONTROL,
@@ -87,6 +88,29 @@ export function evaluateFeatures(
     getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
+export function evaluateFeaturesByFlagSets(
+  log: ILogger,
+  key: SplitIO.SplitKey,
+  flagSets: string[],
+  attributes: SplitIO.Attributes | undefined,
+  storage: IStorageSync | IStorageAsync,
+): MaybeThenable<Record<string,IEvaluationResult>> {
+  let storedFlagNames: MaybeThenable<ISet<string>>;
+
+  // 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((splitNames) => evaluateFeatures(log, key, setToArray(splitNames), attributes, storage)) :
+    evaluateFeatures(log, key, setToArray(storedFlagNames), attributes, storage);
+}
+
 function getEvaluation(
   log: ILogger,
   splitJSON: ISplit | null,

package/src/logger/constants.ts

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

package/src/logger/messages/error.ts

@@ -34,4 +34,6 @@ export const codesError: [number, string][] = [
   [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/src/logger/messages/warn.ts

@@ -24,13 +24,16 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],
   [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
   [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split user interface.'],
+  [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: : you passed %s wich is not part of the configured FlagSetsFilter, ignoring Flag Set.'],
   // 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/src/sdkClient/client.ts

@@ -1,15 +1,16 @@
-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 { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { Method } from '../sync/submitters/types';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
@@ -81,6 +82,41 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     return getTreatments(key, featureFlagNames, attributes, true);
   }
 
+  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS) {
+    const stopTelemetryTracker = telemetryTracker.trackEval(method);
+
+    const wrapUp = (evaluationResults: Record<string,IEvaluationResult>) => {
+      const queue: ImpressionDTO[] = [];
+      const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
+      const evaluations = evaluationResults;
+      Object.keys(evaluations).forEach(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;
+    };
+
+    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage) :
+      isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
+
+    return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
+  }
+
+  function getTreatmentsWithConfigByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined) {
+    return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS);
+  }
+
+  function getTreatmentsByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
+    return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET);
+  }
+
+  function getTreatmentsWithConfigByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
+    return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET);
+  }
+
   // Internal function
   function processEvaluation(
     evaluation: IEvaluationResult,
@@ -155,6 +191,10 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     getTreatmentWithConfig,
     getTreatments,
     getTreatmentsWithConfig,
+    getTreatmentsByFlagSets,
+    getTreatmentsWithConfigByFlagSets,
+    getTreatmentsByFlagSet,
+    getTreatmentsWithConfigByFlagSet,
     track,
     isClientSide: false
   } as SplitIO.IClient | SplitIO.IAsyncClient;

package/src/sdkClient/clientAttributesDecoration.ts

@@ -16,6 +16,10 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
   const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
   const clientGetTreatments = client.getTreatments;
   const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  const clientGetTreatmentsByFlagSets = client.getTreatmentsByFlagSets;
+  const clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
+  const clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
+  const clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
   const clientTrack = client.track;
 
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
@@ -34,6 +38,22 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
     return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
   }
 
+  function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
+  }
+
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
     return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
   }
@@ -51,6 +71,10 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
     getTreatmentWithConfig: getTreatmentWithConfig,
     getTreatments: getTreatments,
     getTreatmentsWithConfig: getTreatmentsWithConfig,
+    getTreatmentsByFlagSets: getTreatmentsByFlagSets,
+    getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
+    getTreatmentsByFlagSet: getTreatmentsByFlagSet,
+    getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
     track: track,
 
     /**

package/src/sdkClient/clientCS.ts

@@ -21,6 +21,10 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     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),

package/src/sdkClient/clientInputValidation.ts

@@ -17,6 +17,7 @@ import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings, SplitIO } from '../types';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { flagSetsAreValid } from '../utils/settingsValidation/splitFilters';
 
 /**
  * Decorator that validates the input before actually executing the client methods.
@@ -30,21 +31,29 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   /**
    * Avoid repeating this validations code
    */
-  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNameOrNames: string | string[], maybeAttributes: SplitIO.Attributes | undefined, methodName: string) {
+  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNameOrNames: string | string[] | undefined, maybeAttributes: SplitIO.Attributes | undefined, methodName: string, maybeFlagSetNameOrNames?: string[]) {
     const multi = startsWith(methodName, 'getTreatments');
     const key = validateKey(log, maybeKey, methodName);
-    const splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
+    let splitOrSplits: string | string[] | false = false;
+    let flagSetOrFlagSets: string[] = [];
+    if (maybeFeatureFlagNameOrNames) {
+      splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
+    }
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
+    if (maybeFlagSetNameOrNames) {
+      flagSetOrFlagSets = flagSetsAreValid(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
+    }
 
     validateIfOperational(log, readinessManager, methodName, splitOrSplits);
 
-    const valid = isNotDestroyed && key && splitOrSplits && attributes !== false;
+    const valid = isNotDestroyed && key && (splitOrSplits || flagSetOrFlagSets.length > 0) && attributes !== false;
 
     return {
       valid,
       key,
       splitOrSplits,
+      flagSetOrFlagSets,
       attributes
     };
   }
@@ -99,6 +108,46 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     }
   }
 
+  function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSets', maybeFlagSets);
+
+    if (params.valid) {
+      return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets as string[], params.attributes as SplitIO.Attributes | undefined);
+    } else {
+      return wrapResult({});
+    }
+  }
+
+  function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSets', maybeFlagSets);
+
+    if (params.valid) {
+      return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets as string[], params.attributes as SplitIO.Attributes | undefined);
+    } else {
+      return wrapResult({});
+    }
+  }
+
+  function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSet', [maybeFlagSet]);
+
+    if (params.valid) {
+      return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets[0] as string, params.attributes as SplitIO.Attributes | undefined);
+    } else {
+      return wrapResult({});
+    }
+  }
+
+  function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSet', [maybeFlagSet]);
+
+    if (params.valid) {
+      return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets[0] as string, params.attributes as SplitIO.Attributes | undefined);
+    } else {
+      return wrapResult({});
+    }
+  }
+
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
     const key = validateKey(log, maybeKey, 'track');
     const tt = validateTrafficType(log, maybeTT, 'track');
@@ -119,6 +168,10 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     getTreatmentWithConfig,
     getTreatments,
     getTreatmentsWithConfig,
+    getTreatmentsByFlagSets,
+    getTreatmentsWithConfigByFlagSets,
+    getTreatmentsByFlagSet,
+    getTreatmentsWithConfigByFlagSet,
     track
   } as TClient;
 }

package/src/sdkManager/index.ts

@@ -32,6 +32,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
     changeNumber: splitObject.changeNumber || 0,
     treatments: collectTreatments(splitObject),
     configs: splitObject.configurations || {},
+    sets: splitObject.sets || [],
     defaultTreatment: splitObject.defaultTreatment
   };
 }

package/src/services/splitApi.ts

@@ -5,6 +5,7 @@ import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
@@ -53,7 +54,11 @@ export function splitApiFactory(
 
     fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
       const 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((err) => {
+          if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);
+          throw err;
+        });
     },
 
     fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,6 +1,7 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
+import { ISet } from '../utils/lang/sets';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -17,6 +18,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   abstract getChangeNumber(): Promise<number>
   abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
+  abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
 

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,6 +1,7 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
+import { ISet } from '../utils/lang/sets';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -78,6 +79,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return false;
   }
 
+  abstract getNamesByFlagSets(flagSets: string[]): ISet<string>
+
 }
 
 /**

package/src/storages/KeyBuilder.ts

@@ -20,6 +20,10 @@ export class KeyBuilder {
     return `${this.prefix}.trafficType.${trafficType}`;
   }
 
+  buildFlagSetKey(flagSet: string) {
+    return `${this.prefix}.flagset.${flagSet}`;
+  }
+
   buildSplitKey(splitName: string) {
     return `${this.prefix}.split.${splitName}`;
   }

package/src/storages/KeyBuilderSS.ts

@@ -7,6 +7,10 @@ export const METHOD_NAMES: Record<Method, string> = {
   ts: 'treatments',
   tc: 'treatmentWithConfig',
   tcs: 'treatmentsWithConfig',
+  tf: 'treatmentsByFlagSet',
+  tfs: 'treatmentsByFlagSets',
+  tcf: 'treatmentsWithConfigByFlagSet',
+  tcfs: 'treatmentsWithConfigByFlagSets',
   tr: 'track'
 };