@splitsoftware/splitio-commons 1.11.0 → 1.12.1-rc.1

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -2,10 +2,10 @@ import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet } from '../../utils/lang/sets';
+import { ISet, _Set, returnListDifference } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -15,6 +15,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   private readonly log: ILogger;
   private readonly keys: KeyBuilder;
   private readonly wrapper: IPluggableStorageWrapper;
+  private readonly flagSetsFilter: string[];
 
   /**
    * Create a SplitsCache that uses a storage wrapper.
@@ -22,11 +23,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * @param keys  Key builder.
    * @param wrapper  Adapted wrapper storage.
    */
-  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper) {
+  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation) {
     super();
     this.log = log;
     this.keys = keys;
     this.wrapper = wrapper;
+    this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
   }
 
   private _decrementCounts(split: ISplit) {
@@ -41,6 +43,24 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     return this.wrapper.incr(ttKey);
   }
 
+  private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
+    const removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+
+    let addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+    if (this.flagSetsFilter.length > 0) {
+      addToFlagSets = addToFlagSets.filter(flagSet => {
+        return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);
+      });
+    }
+
+    const items = [featureFlagName];
+
+    return Promise.all([
+      ...removeFromFlagSets.map(flagSetName => this.wrapper.removeItems(this.keys.buildFlagSetKey(flagSetName), items)),
+      ...addToFlagSets.map(flagSetName => this.wrapper.addItems(this.keys.buildFlagSetKey(flagSetName), items))
+    ]);
+  }
+
   /**
    * Add a given split.
    * The returned promise is resolved when the operation success
@@ -67,7 +87,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
         return this._incrementCounts(split).then(() => {
           if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
         });
-      });
+      }).then(() => this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets));
     }).then(() => true);
   }
 
@@ -88,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        this._decrementCounts(split);
+        return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
+    }).then(() => {
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
   }
@@ -158,12 +179,13 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   /**
    * 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
+   * or rejected if any wrapper operation fails.
   */
-  getNamesByFlagSets(): Promise<ISet<string>> {
-    this.log.error(LOG_PREFIX + 'ByFlagSet/s evaluations are not supported with pluggable storage yet.');
-    return Promise.reject();
+  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+    return Promise.all(flagSets.map(flagSet => {
+      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
+      return this.wrapper.getItems(flagSetKey);
+    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
   }
 
   /**

package/src/storages/pluggable/index.ts

@@ -105,7 +105,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     });
 
     return {
-      splits: new SplitsCachePluggable(log, keys, wrapper),
+      splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/types.ts

@@ -44,10 +44,10 @@ export interface IPluggableStorageWrapper {
    *
    * @function del
    * @param {string} key Item to delete
-   * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
+   * @returns {Promise<boolean>} A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
    * The promise rejects if the operation fails, for example, if there is a connection error.
    */
-  del: (key: string) => Promise<boolean | void>
+  del: (key: string) => Promise<boolean>
   /**
    * Returns all keys matching the given prefix.
    *
@@ -210,7 +210,7 @@ export interface ISplitsCacheBase {
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
   checkCache(): MaybeThenable<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
-  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>
+  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -227,7 +227,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   clear(): void,
   checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
-  getNamesByFlagSets(flagSets: string[]): ISet<string>
+  getNamesByFlagSets(flagSets: string[]): ISet<string>[]
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -244,7 +244,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
+  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>
 }
 
 /** Segments cache */

package/src/types.ts

@@ -197,8 +197,6 @@ interface ISharedSettings {
      * List of feature flag filters. These filters are used to fetch a subset of the feature flag definitions in your environment, in order to reduce the delay of the SDK to be ready.
      * This configuration is only meaningful when the SDK is working in "standalone" mode.
      *
-     * At the moment, only one type of feature flag filter is supported: by name.
-     *
      * Example:
      *  `splitFilter: [
      *    { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'

package/src/utils/lang/sets.ts

@@ -114,8 +114,16 @@ 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 => {
+  set2.forEach(value => {
     result.add(value);
   });
   return result;
 }
+
+export function returnListDifference<T>(list: T[] = [], list2: T[] = []): T[] {
+  const result = new _Set(list);
+  list2.forEach(item => {
+    result.delete(item);
+  });
+  return setToArray(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);
+  const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
   withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
 

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,8 +1,9 @@
+import { CONSUMER_MODE, CONSUMER_PARTIAL_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_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 { 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, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
 
@@ -102,15 +103,15 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
 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]);
+      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]);
+      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;
@@ -128,6 +129,7 @@ function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: Split
  *
  * @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.
@@ -135,7 +137,7 @@ function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: Split
  *
  * @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): ISplitFiltersValidation {
+export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation {
   // Validation result schema
   const res = {
     validFilters: [],
@@ -145,6 +147,11 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISpl
 
   // 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 === CONSUMER_MODE || mode === CONSUMER_PARTIAL_MODE) {
+    log.warn(WARN_SPLITS_FILTER_IGNORED);
+    return res;
+  }
   // Check collection type
   if (!Array.isArray(maybeSplitFilters) || maybeSplitFilters.length === 0) {
     log.warn(WARN_SPLITS_FILTER_EMPTY);

package/types/evaluator/index.d.ts

@@ -5,4 +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>>;
+export declare function evaluateFeaturesByFlagSets(log: ILogger, key: SplitIO.SplitKey, flagSets: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync, method: string): MaybeThenable<Record<string, IEvaluationResult>>;

package/types/logger/constants.d.ts

@@ -89,6 +89,7 @@ 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;
@@ -97,6 +98,7 @@ 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 WARN_FLAGSET_WITHOUT_FLAGS = 228;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;

package/types/sdkClient/identity.d.ts

@@ -0,0 +1,6 @@
+import { SplitIO } from '../types';
+export declare function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string): string;
+export declare function parseInstanceId(instanceId: string): {
+    key: SplitIO.SplitKey;
+    trafficType?: string;
+};

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -15,7 +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 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

@@ -35,7 +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>;
+    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/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -48,7 +48,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      */
     private _checkExpiration;
     private _checkFilterQuery;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

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

@@ -22,7 +22,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

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

@@ -1,7 +1,7 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
 /**
@@ -13,9 +13,11 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     private readonly redis;
     private readonly keys;
     private redisError?;
-    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    private readonly flagSetsFilter;
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -75,10 +77,9 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     /**
      * 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
+     * or rejected if any wrapper operation fails.
     */
-    getNamesByFlagSets(): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): 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/pluggable/SplitsCachePluggable.d.ts

@@ -1,7 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
 /**
@@ -11,15 +11,17 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;
+    private readonly flagSetsFilter;
     /**
      * Create a SplitsCache that uses a storage wrapper.
      * @param log  Logger instance.
      * @param keys  Key builder.
      * @param wrapper  Adapted wrapper storage.
      */
-    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper);
+    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -37,7 +39,7 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
      * or rejected if it fails (e.g., wrapper operation fails).
      */
-    removeSplit(name: string): Promise<boolean | void>;
+    removeSplit(name: string): Promise<boolean>;
     /**
      * Remove a list of splits.
      * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
@@ -71,10 +73,9 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     /**
      * 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
+     * or rejected if any wrapper operation fails.
     */
-    getNamesByFlagSets(): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): 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/types.d.ts

@@ -41,10 +41,10 @@ export interface IPluggableStorageWrapper {
      *
      * @function del
      * @param {string} key Item to delete
-     * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
+     * @returns {Promise<boolean>} A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
      * The promise rejects if the operation fails, for example, if there is a connection error.
      */
-    del: (key: string) => Promise<boolean | void>;
+    del: (key: string) => Promise<boolean>;
     /**
      * Returns all keys matching the given prefix.
      *
@@ -193,7 +193,7 @@ export interface ISplitsCacheBase {
     clear(): MaybeThenable<boolean | void>;
     checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
-    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): boolean[];
@@ -209,7 +209,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     clear(): void;
     checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
@@ -225,7 +225,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     clear(): Promise<boolean | void>;
     checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
-    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {

package/types/types.d.ts

@@ -191,8 +191,6 @@ interface ISharedSettings {
          * List of feature flag filters. These filters are used to fetch a subset of the feature flag definitions in your environment, in order to reduce the delay of the SDK to be ready.
          * This configuration is only meaningful when the SDK is working in "standalone" mode.
          *
-         * At the moment, only one type of feature flag filter is supported: by name.
-         *
          * Example:
          *  `splitFilter: [
          *    { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'

package/types/utils/inputValidation/sdkKey.d.ts

@@ -0,0 +1,7 @@
+import { ILogger } from '../../logger/types';
+/** validates the given SDK key */
+export declare function validateApiKey(log: ILogger, maybeSdkKey: any): string | false;
+export declare const usedKeysMap: Record<string, number>;
+/** validates the given SDK key and also warns if it is in use */
+export declare function validateAndTrackApiKey(log: ILogger, maybeSdkKey: any): string | false;
+export declare function releaseApiKey(sdkKey: string): void;

package/types/utils/lang/sets.d.ts

@@ -58,4 +58,5 @@ interface ISetConstructor {
 export declare function __getSetConstructor(): ISetConstructor;
 export declare const _Set: ISetConstructor;
 export declare function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T>;
+export declare function returnListDifference<T>(list?: T[], list2?: T[]): T[];
 export {};

package/types/utils/settingsValidation/splitFilters.d.ts

@@ -5,6 +5,7 @@ import { ILogger } from '../../logger/types';
  *
  * @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.
@@ -12,5 +13,5 @@ import { ILogger } from '../../logger/types';
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation;
+export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation;
 export declare function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];

package/types/myLogger.d.ts

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

package/types/sdkClient/types.d.ts

@@ -1,18 +0,0 @@
-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/inMemory/CountsCacheInMemory.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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/inRedis/CountsCacheInRedis.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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/metadataBuilder.d.ts

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

package/types/sync/offline/LocalhostFromFile.d.ts

@@ -1,2 +0,0 @@
-import { SplitIO } from '../../types';
-export declare function LocalhostFromFile(): SplitIO.LocalhostFactory;

package/types/sync/offline/splitsParser/splitsParserFromFile.d.ts

@@ -1,2 +0,0 @@
-import { ISplitsParser } from './types';
-export declare function splitsParserFromFileFactory(): ISplitsParser;

package/types/sync/submitters/eventsSyncTask.d.ts

@@ -1,8 +0,0 @@
-import { IEventsCacheSync } from '../../storages/types';
-import { IPostEventsBulk } from '../../services/types';
-import { ISyncTask, ITimeTracker } from '../types';
-import { ILogger } from '../../logger/types';
-/**
- * Sync task that periodically posts tracked events
- */
-export declare function eventsSyncTaskFactory(log: ILogger, postEventsBulk: IPostEventsBulk, eventsCache: IEventsCacheSync, eventsPushRate: number, eventsFirstPushWindow: number, latencyTracker?: ITimeTracker): ISyncTask;

package/types/sync/submitters/impressionCountsSubmitterInRedis.d.ts

@@ -1,5 +0,0 @@
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Submitter that periodically posts impression counts
- */
-export declare function impressionCountsSubmitterInRedisFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

package/types/sync/submitters/impressionCountsSyncTask.d.ts

@@ -1,13 +0,0 @@
-import { ISyncTask, ITimeTracker } from '../types';
-import { IPostTestImpressionsCount } from '../../services/types';
-import { IImpressionCountsCacheSync } from '../../storages/types';
-import { ImpressionCountsPayload } from './types';
-import { ILogger } from '../../logger/types';
-/**
- * Converts `impressionCounts` data from cache into request payload.
- */
-export declare function fromImpressionCountsCollector(impressionsCount: Record<string, number>): ImpressionCountsPayload;
-/**
- * Sync task that periodically posts impression counts
- */
-export declare function impressionCountsSyncTaskFactory(log: ILogger, postTestImpressionsCount: IPostTestImpressionsCount, impressionCountsCache: IImpressionCountsCacheSync, latencyTracker?: ITimeTracker): ISyncTask;