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

package/esm/utils/settingsValidation/splitFilters.js

@@ -1,9 +1,16 @@
 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_IGNORED, 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, ERROR_EMPTY_ARRAY, 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 +22,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 +44,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,6 +77,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(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.
  *
@@ -83,7 +131,7 @@ export 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)
@@ -115,8 +163,34 @@ 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 toReturn = [];
+    if (flagSets.length === 0) {
+        log.error(ERROR_EMPTY_ARRAY, [method, 'flagSets']);
+        return toReturn;
+    }
+    var sets = 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(WARN_FLAGSET_NOT_CONFIGURED, [flagSet]);
+            return false;
+        });
+    }
+    return toReturn;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.9.1",
+  "version": "1.9.2-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

@@ -27,10 +27,12 @@ export const codesWarn: [number, string][] = 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/src/myLogger.ts

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

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,28 @@ 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[] | undefined) {
     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);
 
-    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 +107,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 +167,10 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     getTreatmentWithConfig,
     getTreatments,
     getTreatmentsWithConfig,
+    getTreatmentsByFlagSets,
+    getTreatmentsWithConfigByFlagSets,
+    getTreatmentsByFlagSet,
+    getTreatmentsWithConfigByFlagSet,
     track
   } as TClient;
 }

package/src/sdkManager/index.ts

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

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