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

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -1,12 +1,13 @@
 import { _Set, setToArray, ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
-import { ISplit, ISplitChangesResponse } from '../../../dtos/types';
+import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { startsWith } from '../../../utils/lang';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -45,15 +46,36 @@ interface ISplitMutations {
   segments: string[]
 }
 
+/**
+ * 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: ISplit, filters: ISplitFiltersValidation) {
+  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter} = filters.groupedFilters;
+  if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
+
+  const namesFilterConfigured = namesFilter.length > 0;
+  const prefixFilterConfigured = prefixFilter.length > 0;
+
+  if (!namesFilterConfigured && !prefixFilterConfigured) return true;
+
+  const matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
+  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => startsWith(featureFlag.name, prefix));
+  return matchNames || matchPrefix;
+}
+
 /**
  * Given the list of splits from /splitChanges endpoint, it returns the mutations,
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeSplitsMutation(entries: ISplit[]): ISplitMutations {
+export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
-    if (split.status === 'ACTIVE') {
+    if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
       accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
@@ -90,6 +112,7 @@ export function splitChangesUpdaterFactory(
   splitChangesFetcher: ISplitChangesFetcher,
   splits: ISplitsCacheBase,
   segments: ISegmentsCacheBase,
+  splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
@@ -126,7 +149,7 @@ export function splitChangesUpdaterFactory(
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 
-          const mutation = computeSplitsMutation(splitChanges.splits);
+          const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
 
           log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
           log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);

package/src/sync/streaming/parseUtils.ts

@@ -11,6 +11,7 @@ function Uint8ArrayToString(myUint8Arr: Uint8Array) { // @ts-ignore
 
 function StringToUint8Array(myString: string) {
   const charCodes = myString.split('').map((e) => e.charCodeAt(0));
+  // eslint-disable-next-line compat/compat
   return new Uint8Array(charCodes);
 }
 

package/src/sync/submitters/telemetrySubmitter.ts

@@ -3,12 +3,13 @@ import { submitterFactory, firstPushWindowDecorator } from './submitter';
 import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
 import { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
-import { ConsentStatus, ISettings, SDKMode } from '../../types';
+import { ConsentStatus, ISettings, SDKMode, SplitIO } from '../../types';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
+import { ISplitFiltersValidation } from '../../dtos/types';
 
 const OPERATION_MODE_MAP = {
   [STANDALONE_MODE]: STANDALONE_ENUM,
@@ -38,6 +39,18 @@ function getRedundantActiveFactories() {
   }, 0);
 }
 
+function getTelemetryFlagSetsStats(splitFiltersValidation: ISplitFiltersValidation) {
+  // Group every configured flag set in an unique array called originalSets
+  let flagSetsTotal = 0;
+  splitFiltersValidation.validFilters.forEach((filter: SplitIO.SplitFilter) => {
+    if (filter.type === 'bySet') flagSetsTotal += filter.values.length;
+  });
+
+  const flagSetsValid = splitFiltersValidation.groupedFilters.bySet.length;
+  const flagSetsIgnored = flagSetsTotal - flagSetsValid;
+  return { flagSetsTotal, flagSetsIgnored };
+}
+
 export function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats {
   return {
     oM: OPERATION_MODE_MAP[mode], // @ts-ignore lower case of storage type
@@ -59,6 +72,8 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
       const { urls, scheduler } = settings;
       const isClientSide = settings.core.key !== undefined;
 
+      const { flagSetsTotal, flagSetsIgnored } = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation);
+
       return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
         rR: {
@@ -86,7 +101,9 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
         nR: telemetry.getNonReadyUsage(),
         t: telemetry.popTags(),
         i: settings.integrations && settings.integrations.map(int => 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/src/sync/submitters/types.ts

@@ -124,7 +124,11 @@ export type TREATMENTS = 'ts';
 export type TREATMENT_WITH_CONFIG = 'tc';
 export type TREATMENTS_WITH_CONFIG = 'tcs';
 export type TRACK = 'tr';
-export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
+export type TREATMENTS_BY_FLAGSET = 'tf'
+export type TREATMENTS_BY_FLAGSETS = 'tfs'
+export type TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf'
+export type TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs'
+export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK | TREATMENTS_BY_FLAGSET | TREATMENTS_BY_FLAGSETS | TREATMENTS_WITH_CONFIG_BY_FLAGSET | TREATMENTS_WITH_CONFIG_BY_FLAGSETS;
 
 export type MethodLatencies = Partial<Record<Method, Array<number>>>;
 
@@ -234,6 +238,8 @@ export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   nR: number, // SDKNotReadyUsage
   i?: Array<string>, // integrations
   uC: number, // userConsent
+  fsT: number, // flagSetsTotal
+  fsI: number, // flagSetsInvalid
 }
 
 export interface ISubmitterManager extends ISyncTask {

package/src/types.ts

@@ -610,6 +610,11 @@ export namespace SplitIO {
     configs: {
       [treatmentName: string]: string
     }
+    /**
+     * list of sets per feature flag
+     * @property {string[]} sets
+     */
+    sets?: string[]
   };
   /**
    * A promise that resolves to a feature flag view.
@@ -709,7 +714,7 @@ export namespace SplitIO {
    * SplitFilter type.
    * @typedef {string} SplitFilterType
    */
-  export type SplitFilterType = 'byName' | 'byPrefix';
+  export type SplitFilterType = 'byName' | 'byPrefix' | 'bySet';
   /**
    * Defines a feature flag filter, described by a type and list of values.
    */
@@ -1059,6 +1064,42 @@ export namespace SplitIO {
      * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfig(key: SplitKey, featureFlagNames: string[], attributes?: Attributes): TreatmentsWithConfig,
+    /**
+     * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flagSet.
+     * @function getTreatmentsByFlagSet
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} flagSet - The flagSet name we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): Treatments,
+    /**
+     * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flagSets.
+     * @function getTreatmentsWithConfigByFlagSet
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} flagSet - The flagSet name we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): TreatmentsWithConfig,
+    /**
+     * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flagSets.
+     * @function getTreatmentsByFlagSets
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} flagSets - An array of the flagSet names we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): Treatments,
+    /**
+     * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flagSets.
+     * @function getTreatmentsWithConfigByFlagSets
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} flagSets - An array of the flagSet names we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): TreatmentsWithConfig,
     /**
      * Tracks an event to be fed to the results product on Split user interface.
      * @function track
@@ -1119,6 +1160,46 @@ export namespace SplitIO {
      * @returns {AsyncTreatmentsWithConfig} TreatmentsWithConfig promise that resolves to the map of TreatmentsWithConfig objects.
      */
     getTreatmentsWithConfig(key: SplitKey, featureFlagNames: string[], attributes?: Attributes): AsyncTreatmentsWithConfig,
+    /**
+     * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the features related to the given flag set.
+     * For usage on NodeJS as we don't have only one key.
+     * @function getTreatmentsByFlagSet
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} flagSet - The flag set name we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): AsyncTreatments,
+    /**
+     * Returns a TreatmentWithConfig value, which will be (or eventually be) an object with both treatment and config string for features related to the given flag set.
+     * For usage on NodeJS as we don't have only one key.
+     * @function getTreatmentsWithConfigByFlagSet
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} flagSet - The flag set name we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): AsyncTreatmentsWithConfig,
+    /**
+     * Returns a Treatments value, which will be (or eventually be) an object map with the treatments for the feature flags related to the given flag sets.
+     * For usage on NodeJS as we don't have only one key.
+     * @function getTreatmentsByFlagSets
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): AsyncTreatments,
+    /**
+     * Returns a TreatmentWithConfig value, which will be (or eventually be) an object with both treatment and config string for the feature flags related to the given flag sets.
+     * For usage on NodeJS as we don't have only one key.
+     * @function getTreatmentsWithConfigByFlagSets
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): AsyncTreatmentsWithConfig,
     /**
      * Tracks an event to be fed to the results product on Split user interface, and returns a promise to signal when the event was successfully queued (or not).
      * @function track
@@ -1169,6 +1250,42 @@ export namespace SplitIO {
      * @returns {TreatmentsWithConfig} The map with all the TreatmentWithConfig objects
      */
     getTreatmentsWithConfig(featureFlagNames: string[], attributes?: Attributes): TreatmentsWithConfig,
+    /**
+     * Returns a Treatments value, which is an object map with the treatments for the feature flags related to the given flag set.
+     * @function getTreatmentsByFlagSet
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} flagSet - The flag set name we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): Treatments,
+    /**
+     * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag set.
+     * @function getTreatmentsWithConfigByFlagSet
+     * @param {string} key - The string key representing the consumer.
+     * @param {string} flagSet - The flag set name we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfigByFlagSet(key: SplitKey, flagSet: string, attributes?: Attributes): TreatmentsWithConfig,
+    /**
+     * Returns a Returns a Treatments value, which is an object with both treatment and config string for to the feature flags related to the given flag sets.
+     * @function getTreatmentsByFlagSets
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): Treatments,
+    /**
+     * Returns a TreatmentsWithConfig value, which is an object map with the TreatmentWithConfig (an object with both treatment and config string) for the feature flags related to the given flag sets.
+     * @function getTreatmentsWithConfigByFlagSets
+     * @param {string} key - The string key representing the consumer.
+     * @param {Array<string>} flagSets - An array of the flag set names we want to get the treatments.
+     * @param {Attributes=} attributes - An object of type Attributes defining the attributes for the given key.
+     * @returns {Treatments} The map with all the TreatmentWithConfig objects
+     */
+    getTreatmentsWithConfigByFlagSets(key: SplitKey, flagSets: string[], attributes?: Attributes): TreatmentsWithConfig,
     /**
      * Tracks an event to be fed to the results product on Split user interface.
      * @function track

package/src/utils/constants/index.ts

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

package/src/utils/lang/sets.ts

@@ -111,3 +111,11 @@ export function __getSetConstructor(): ISetConstructor {
 }
 
 export const _Set = __getSetConstructor();
+
+export function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T> {
+  const result = new _Set(setToArray(set));
+  set2.forEach( value => {
+    result.add(value);
+  });
+  return result;
+}

package/src/utils/redis/RedisMock.ts

@@ -13,7 +13,7 @@ const PIPELINE_METHODS = ['rpush', 'hincrby'];
 
 export class RedisMock {
 
-  private pipelineMethods: any = { exec: jest.fn(asyncFunction) }
+  private pipelineMethods: any = { exec: jest.fn(asyncFunction) };
 
   constructor() {
     IDENTITY_METHODS.forEach(method => {

package/src/utils/settingsValidation/splitFilters.ts

@@ -3,11 +3,18 @@ import { validateSplits } from '../inputValidation/splits';
 import { ISplitFiltersValidation } from '../../dtos/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
-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>`
 const FILTERS_METADATA = [
+  {
+    type: 'bySet' as SplitIO.SplitFilterType,
+    maxLength: 50,
+    queryParam: 'sets='
+  },
   {
     type: 'byName' as SplitIO.SplitFilterType,
     maxLength: 400,
@@ -20,6 +27,9 @@ const FILTERS_METADATA = [
   }
 ];
 
+const VALID_FLAGSET_REGEX = /^[a-z0-9][_a-z0-9]{0,49}$/;
+const CAPITAL_LETTERS_REGEX = /[A-Z]/;
+
 /**
  * Validates that the given value is a valid filter type
  */
@@ -42,6 +52,11 @@ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values
   let 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.`);
 
@@ -72,6 +87,43 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
   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: ILogger, flagSets: string[]) {
+  let sanitizedSets = flagSets
+    .map(flagSet => {
+      if (CAPITAL_LETTERS_REGEX.test(flagSet)){
+        log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET,[flagSet]);
+        flagSet = flagSet.toLowerCase();
+      }
+      return flagSet;
+    })
+    .filter(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: SplitIO.SplitFilter[], filterType: SplitIO.SplitFilterType) {
+  return find(validFilters, (filter: SplitIO.SplitFilter) => filter.type === filterType && filter.values.length > 0);
+}
+
 /**
  * Validates `splitFilters` configuration object and parses it into a query string for filtering splits on `/splitChanges` fetch.
  *
@@ -90,7 +142,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   const res = {
     validFilters: [],
     queryString: null,
-    groupedFilters: { byName: [], byPrefix: [] }
+    groupedFilters: { bySet: [], byName: [], byPrefix: [] },
   } as ISplitFiltersValidation;
 
   // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
@@ -122,9 +174,37 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
     if (res.groupedFilters[type].length > 0) res.groupedFilters[type] = validateSplitFilter(log, type, res.groupedFilters[type], maxLength);
   });
 
+  const 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: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] {
+  let toReturn: string[] = [];
+  if (flagSets.length === 0) {
+    log.error(ERROR_EMPTY_ARRAY, [method, 'flagSets']);
+    return toReturn;
+  }
+  const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
+  toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+  if (flagSetsInConfig.length > 0) {
+    toReturn = toReturn.filter(flagSet => {
+      if (flagSetsInConfig.indexOf(flagSet) > -1) {
+        return true;
+      }
+      log.warn(WARN_FLAGSET_NOT_CONFIGURED, [flagSet]);
+      return false;
+    });
+  }
+
+  return toReturn;
+}

package/types/dtos/types.d.ts

@@ -132,6 +132,7 @@ export interface ISplit {
     configurations?: {
         [treatmentName: string]: string;
     };
+    sets?: string[];
 }
 export declare type ISplitPartial = Pick<ISplit, 'conditions' | 'configurations' | 'trafficTypeName'>;
 /** Interface of the parsed JSON response of `/splitChanges` */

package/types/evaluator/index.d.ts

@@ -5,3 +5,4 @@ import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 export declare function evaluateFeature(log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<IEvaluationResult>;
 export declare function evaluateFeatures(log: ILogger, key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;
+export declare function evaluateFeaturesByFlagSets(log: ILogger, key: SplitIO.SplitKey, flagSets: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;

package/types/listeners/browser.d.ts

@@ -23,7 +23,6 @@ export declare class BrowserSignalListener implements ISignalListener {
      * Called when client is destroyed, it removes event listeners.
      */
     stop(): void;
-    stopSync(): void;
     /**
      * flushData method.
      * Called when pagehide event is triggered. It flushed remaining impressions and events to the backend,

package/types/logger/constants.d.ts

@@ -95,6 +95,9 @@ export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
 export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
+export declare const WARN_SPLITS_FILTER_INVALID_SET = 225;
+export declare const WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export declare const WARN_FLAGSET_NOT_CONFIGURED = 227;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;
@@ -122,6 +125,8 @@ export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const ERROR_STORAGE_INVALID = 324;
 export declare const ERROR_NOT_BOOLEAN = 325;
 export declare const ERROR_MIN_CONFIG_PARAM = 326;
+export declare const ERROR_TOO_MANY_SETS = 327;
+export declare const ERROR_SETS_FILTER_EXCLUSIVE = 328;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/myLogger.d.ts

@@ -0,0 +1,5 @@
+export declare const myLogger: {
+    log: (msg: any) => void;
+    logCsv: (msg: any) => void;
+    logToFile: (file: any, msg: any) => void;
+};

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -8,6 +8,10 @@ export declare function clientAttributesDecoration<TClient extends SplitIO.IClie
     getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
     getTreatments: (maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
     getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    getTreatmentsByFlagSets: (maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfigByFlagSets: (maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    getTreatmentsByFlagSet: (maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfigByFlagSet: (maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
     track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => boolean | Promise<boolean>;
     /**
      * Add an attribute to client's in memory attributes storage

package/types/sdkClient/types.d.ts

@@ -0,0 +1,18 @@
+import { ISignalListener } from '../listeners/types';
+import { ISdkReadinessManager } from '../readiness/types';
+import { IStorageAsync, IStorageSync } from '../storages/types';
+import { ISyncManager } from '../sync/types';
+import { IEventTracker, IImpressionsTracker } from '../trackers/types';
+import { ISettings } from '../types';
+export interface IClientFactoryParams {
+    storage: IStorageSync | IStorageAsync;
+    sdkReadinessManager: ISdkReadinessManager;
+    settings: ISettings;
+    impressionsTracker: IImpressionsTracker;
+    eventTracker: IEventTracker;
+}
+export interface ISdkClientFactoryParams extends IClientFactoryParams {
+    signalListener?: ISignalListener;
+    syncManager?: ISyncManager;
+    sharedClient?: boolean;
+}

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
+import { ISet } from '../utils/lang/sets';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
@@ -14,6 +15,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     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>;
     usesSegments(): Promise<boolean>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
+import { ISet } from '../utils/lang/sets';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -34,6 +35,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      */
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
+    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>;
 }
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).

package/types/storages/KeyBuilder.d.ts

@@ -3,6 +3,7 @@ export declare class KeyBuilder {
     protected readonly prefix: string;
     constructor(prefix?: string);
     buildTrafficTypeKey(trafficType: string): string;
+    buildFlagSetKey(flagSet: string): string;
     buildSplitKey(splitName: string): string;
     buildSplitsTillKey(): string;
     isSplitKey(key: string): boolean;

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -2,6 +2,7 @@ import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
+import { ISet } from '../../utils/lang/sets';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -9,8 +10,8 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     private readonly log;
     private readonly keys;
     private readonly splitFiltersValidation;
+    private readonly flagSetsFilter;
     private hasSync?;
-    private cacheReadyButNeedsToFlush;
     private updateNewFilter?;
     /**
      * @param {KeyBuilderCS} keys
@@ -47,4 +48,8 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      */
     private _checkExpiration;
     private _checkFilterQuery;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    private addToFlagSets;
+    private removeFromFlagSets;
+    private removeNames;
 }

package/types/storages/inMemory/CountsCacheInMemory.d.ts

@@ -0,0 +1,20 @@
+import { ICountsCacheSync } from '../types';
+export declare class CountsCacheInMemory implements ICountsCacheSync {
+    private counters;
+    /**
+     * Add counts.
+     */
+    track(metricName: string): boolean;
+    /**
+     * Clear the collector
+     */
+    clear(): void;
+    /**
+     * Get the collected data, used as payload for posting.
+     */
+    state(): Record<string, number>;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+}