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

package/src/types.ts

@@ -609,7 +609,12 @@ export namespace SplitIO {
      */
     configs: {
       [treatmentName: string]: string
-    }
+    },
+    /**
+     * List of sets of the feature flag.
+     * @property {string[]} sets
+     */
+    sets: string[],
     /**
      * The default treatment of the feature flag.
      * @property {string} defaultTreatment
@@ -714,7 +719,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.
    */
@@ -1064,6 +1069,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
@@ -1124,6 +1165,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
@@ -1174,6 +1255,38 @@ 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} 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(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} 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(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 {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(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 {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(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/settingsValidation/index.ts

@@ -202,7 +202,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   }
 
   // validate the `splitFilters` settings and parse splits query
-  const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
+  const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
   withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
 

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,13 +1,19 @@
-import { STANDALONE_MODE } from '../constants';
 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_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>`
 const FILTERS_METADATA = [
+  {
+    type: 'bySet' as SplitIO.SplitFilterType,
+    maxLength: 50,
+    queryParam: 'sets='
+  },
   {
     type: 'byName' as SplitIO.SplitFilterType,
     maxLength: 400,
@@ -20,6 +26,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 +51,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,12 +86,48 @@ 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.
  *
  * @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.
@@ -85,21 +135,16 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation {
+export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation {
   // Validation result schema
   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
   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);
@@ -122,9 +167,32 @@ 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[] {
+  const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
+  let 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, [method, 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/logger/constants.d.ts

@@ -89,12 +89,14 @@ export declare const WARN_NOT_EXISTENT_SPLIT = 215;
 export declare const WARN_LOWERCASE_TRAFFIC_TYPE = 216;
 export declare const WARN_NOT_EXISTENT_TT = 217;
 export declare const WARN_INTEGRATION_INVALID = 218;
-export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 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 +124,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;
+}

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

@@ -0,0 +1,20 @@
+import { ILatenciesCacheSync } from '../types';
+export declare class LatenciesCacheInMemory implements ILatenciesCacheSync {
+    private counters;
+    /**
+     * Add latencies.
+     */
+    track(metricName: string, latency: number): 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;
+}

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

@@ -1,14 +1,18 @@
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
+import { ISet } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
  */
 export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
+    private flagSetsFilter;
     private splitsCache;
     private ttCache;
     private changeNumber;
     private splitsWithSegmentsCount;
+    private flagSetsCache;
+    constructor(splitFiltersValidation?: ISplitFiltersValidation);
     clear(): void;
     addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
@@ -18,4 +22,8 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    private addToFlagSets;
+    private removeFromFlagSets;
+    private removeNames;
 }

package/types/storages/inRedis/CountsCacheInRedis.d.ts

@@ -0,0 +1,9 @@
+import { ICountsCacheAsync } from '../types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+export declare class CountsCacheInRedis implements ICountsCacheAsync {
+    private readonly redis;
+    private readonly keys;
+    constructor(keys: KeyBuilderSS, redis: Redis);
+    track(metricName: string): Promise<boolean>;
+}

package/types/storages/inRedis/LatenciesCacheInRedis.d.ts

@@ -0,0 +1,9 @@
+import { ILatenciesCacheAsync } from '../types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+export declare class LatenciesCacheInRedis implements ILatenciesCacheAsync {
+    private readonly redis;
+    private readonly keys;
+    constructor(keys: KeyBuilderSS, redis: Redis);
+    track(metricName: string, latency: number): Promise<boolean>;
+}

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -3,6 +3,7 @@ import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { ISet } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
  * Supported by Node.
@@ -71,6 +72,13 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * or rejected if redis operation fails.
      */
     getSplitNames(): Promise<string[]>;
+    /**
+     * Get list of split names related to a given flag set names list.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if wrapper operation fails.
+     * @todo this is a no-op method to be implemented
+    */
+    getNamesByFlagSets(): Promise<ISet<string>>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/types/storages/metadataBuilder.d.ts

@@ -0,0 +1,3 @@
+import { IMetadata } from '../dtos/types';
+import { ISettings } from '../types';
+export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -3,6 +3,7 @@ import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { ISet } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -67,6 +68,13 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * or rejected if wrapper operation fails.
      */
     getSplitNames(): Promise<string[]>;
+    /**
+     * Get list of split names related to a given flag set names list.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if wrapper operation fails.
+     * @todo this is a no-op method to be implemented
+    */
+    getNamesByFlagSets(): Promise<ISet<string>>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.