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

package/src/sdkClient/clientInputValidation.ts

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

package/src/sdkManager/index.ts

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

package/src/services/splitApi.ts

@@ -5,6 +5,7 @@ import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
@@ -53,7 +54,11 @@ export function splitApiFactory(
 
     fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
       const url = `${urls.sdk}/splitChanges?since=${since}${till ? '&till=' + till : ''}${filterQueryString || ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
+        .catch((err) => {
+          if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);
+          throw err;
+        });
     },
 
     fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {

package/src/storages/AbstractSplitsCacheAsync.ts

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

package/src/storages/AbstractSplitsCacheSync.ts

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

package/src/storages/KeyBuilder.ts

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

package/src/storages/KeyBuilderSS.ts

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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,6 +4,7 @@ import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
+import { ISet, _Set, returnSetsUnion, setToArray } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -12,8 +13,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly splitFiltersValidation: ISplitFiltersValidation;
+  private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
-  private cacheReadyButNeedsToFlush: boolean = false;
   private updateNewFilter?: boolean;
 
   /**
@@ -21,10 +22,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * @param {number | undefined} expirationTimestamp
    * @param {ISplitFiltersValidation} splitFiltersValidation
    */
-  constructor(private readonly log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { byName: [], byPrefix: [] }, validFilters: [] }) {
+  constructor(private readonly log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }) {
     super();
     this.keys = keys;
     this.splitFiltersValidation = splitFiltersValidation;
+    this.flagSetsFilter = this.splitFiltersValidation.groupedFilters.bySet;
 
     this._checkExpiration(expirationTimestamp);
 
@@ -106,6 +108,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       this._incrementCounts(split);
       this._decrementCounts(previousSplit);
 
+      if (previousSplit) this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+      this.addToFlagSets(split);
+
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -119,6 +124,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       localStorage.removeItem(this.keys.buildSplitKey(name));
 
       this._decrementCounts(split);
+      if (split) this.removeFromFlagSets(split.name, split.sets);
 
       return true;
     } catch (e) {
@@ -133,11 +139,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   setChangeNumber(changeNumber: number): boolean {
-    // when cache is ready but using a new split query, we must clear all split data
-    if (this.cacheReadyButNeedsToFlush) {
-      this.clear();
-      this.cacheReadyButNeedsToFlush = false;
-    }
 
     // when using a new split query, we must update it at the store
     if (this.updateNewFilter) {
@@ -220,7 +221,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * @override
    */
   checkCache(): boolean {
-    return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;
+    return this.getChangeNumber() > -1;
   }
 
   /**
@@ -237,7 +238,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   private _checkFilterQuery() {
-    const { queryString, groupedFilters } = this.splitFiltersValidation;
+    const { queryString } = this.splitFiltersValidation;
     const queryKey = this.keys.buildSplitsFilterQueryKey();
     const currentQueryString = localStorage.getItem(queryKey);
 
@@ -246,29 +247,74 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         // mark cache to update the new query filter on first successful splits fetch
         this.updateNewFilter = true;
 
-        // if cache is ready:
-        if (this.checkCache()) {
-          // * set change number to -1, to fetch splits with -1 `since` value.
-          localStorage.setItem(this.keys.buildSplitsTillKey(), '-1');
-
-          // * remove from cache splits that doesn't match with the new filters
-          this.getSplitNames().forEach((splitName) => {
-            if (queryString && (
-              // @TODO consider redefining `groupedFilters` to expose a method like `groupedFilters::filter(splitName): boolean`
-              groupedFilters.byName.indexOf(splitName) > -1 ||
-              groupedFilters.byPrefix.some((prefix: string) => splitName.startsWith(prefix + '__'))
-            )) {
-              // * set `cacheReadyButNeedsToFlush` so that `checkCache` returns true (the storage is ready to be used) and the data is cleared before updating on first successful splits fetch
-              this.cacheReadyButNeedsToFlush = true;
-              return;
-            }
-            this.removeSplit(splitName);
-          });
-        }
+        // if there is cache, clear it
+        if (this.checkCache()) this.clear();
+
       } catch (e) {
         this.log.error(LOG_PREFIX + e);
       }
     }
     // if the filter didn't change, nothing is done
   }
+
+  getNamesByFlagSets(flagSets: string[]): ISet<string>{
+    let toReturn: ISet<string> = new _Set([]);
+    flagSets.forEach(flagSet => {
+      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
+      let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+
+      if (flagSetFromLocalStorage) {
+        const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+        toReturn = returnSetsUnion(toReturn, flagSetCache);
+      }
+    });
+    return toReturn;
+
+  }
+
+  private addToFlagSets(featureFlag: ISplit) {
+    if (!featureFlag.sets) return;
+
+    featureFlag.sets.forEach(featureFlagSet => {
+
+      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
+
+      const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
+
+      let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+      if (!flagSetFromLocalStorage) flagSetFromLocalStorage = '[]';
+
+      const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+      flagSetCache.add(featureFlag.name);
+
+      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+    });
+  }
+
+  private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
+    if (!flagSets) return;
+
+    flagSets.forEach(flagSet => {
+      this.removeNames(flagSet, featureFlagName);
+    });
+  }
+
+  private removeNames(flagSetName: string, featureFlagName: string) {
+    const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
+
+    let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+
+    if (!flagSetFromLocalStorage) return;
+
+    const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+    flagSetCache.delete(featureFlagName);
+
+    if (flagSetCache.size === 0) {
+      localStorage.removeItem(flagSetKey);
+      return;
+    }
+
+    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+  }
+
 }

package/src/storages/inLocalStorage/index.ts

@@ -54,7 +54,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
-        this.splits = new SplitsCacheInMemory();
+        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
         this.segments = new MySegmentsCacheInMemory();
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
@@ -75,7 +75,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           telemetry: this.telemetry,
 
           destroy() {
-            this.splits = new SplitsCacheInMemory();
+            this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
             this.segments = new MySegmentsCacheInMemory();
           }
         };

package/src/storages/inMemory/InMemoryStorage.ts

@@ -14,9 +14,9 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory();
+  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new SegmentsCacheInMemory();
 
   const storage = {

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -14,9 +14,9 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory();
+  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
 
   const storage = {
@@ -50,7 +50,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
 
         // Set a new splits cache to clean it for the client without affecting other clients
         destroy() {
-          this.splits = new SplitsCacheInMemory();
+          this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
           this.segments.clear();
         }
       };

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,6 +1,7 @@
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
+import { ISet, _Set, returnSetsUnion } from '../../utils/lang/sets';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -8,10 +9,17 @@ import { isFiniteNumber } from '../../utils/lang';
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
+  private flagSetsFilter: string[];
   private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private splitsWithSegmentsCount: number = 0;
+  private flagSetsCache: Record<string, ISet<string>> = {};
+
+  constructor(splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }) {
+    super();
+    this.flagSetsFilter = splitFiltersValidation.groupedFilters.bySet;
+  }
 
   clear() {
     this.splitsCache = {};
@@ -28,6 +36,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.ttCache[previousTtName]--;
       if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
 
+      this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+
       if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
         this.splitsWithSegmentsCount--;
       }
@@ -39,6 +49,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       // Update TT cache
       const ttName = split.trafficTypeName;
       this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+      this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
       if (usesSegments(split)) this.splitsWithSegmentsCount++;
@@ -58,6 +69,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       const ttName = split.trafficTypeName;
       this.ttCache[ttName]--; // Update tt cache
       if (!this.ttCache[ttName]) delete this.ttCache[ttName];
+      this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
       if (usesSegments(split)) this.splitsWithSegmentsCount--;
@@ -93,4 +105,41 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
   }
 
+  getNamesByFlagSets(flagSets: string[]): ISet<string>{
+    let toReturn: ISet<string> = new _Set([]);
+    flagSets.forEach(flagSet => {
+      const featureFlagNames = this.flagSetsCache[flagSet];
+      if (featureFlagNames) {
+        toReturn = returnSetsUnion(toReturn, featureFlagNames);
+      }
+    });
+    return toReturn;
+
+  }
+
+  private addToFlagSets(featureFlag: ISplit) {
+    if (!featureFlag.sets) return;
+    featureFlag.sets.forEach(featureFlagSet => {
+
+      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
+
+      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new _Set([]);
+
+      this.flagSetsCache[featureFlagSet].add(featureFlag.name);
+    });
+  }
+
+  private removeFromFlagSets(featureFlagName :string, flagSets: string[] | undefined) {
+    if (!flagSets) return;
+    flagSets.forEach(flagSet => {
+      this.removeNames(flagSet, featureFlagName);
+    });
+  }
+
+  private removeNames(flagSetName: string, featureFlagName: string) {
+    if (!this.flagSetsCache[flagSetName]) return;
+    this.flagSetsCache[flagSetName].delete(featureFlagName);
+    if (this.flagSetsCache[flagSetName].size === 0) delete this.flagSetsCache[flagSetName];
+  }
+
 }

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -181,7 +181,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.e = false;
   }
 
-  private streamingEvents: StreamingEvent[] = []
+  private streamingEvents: StreamingEvent[] = [];
 
   popStreamingEvents() {
     return this.streamingEvents.splice(0);

package/src/storages/inRedis/RedisAdapter.ts

@@ -33,7 +33,7 @@ interface IRedisCommand {
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
  */
 export class RedisAdapter extends ioredis {
-  private readonly log: ILogger
+  private readonly log: ILogger;
   private _options: object;
   private _notReadyCommandsQueue?: IRedisCommand[];
   private _runningCommands: ISet<Promise<any>>;

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -5,6 +5,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * Discard errors for an answer of multiple operations.
@@ -188,6 +189,17 @@ export 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
+  */
+  getNamesByFlagSets(): Promise<ISet<string>> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return new Promise(flagSets => new _Set([]));
+  }
+
   /**
    * Check traffic type existence.
    * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -5,6 +5,7 @@ import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -154,6 +155,17 @@ 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
+  */
+  getNamesByFlagSets(): Promise<ISet<string>> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return new Promise(flagSets => new _Set([]));
+  }
+
   /**
    * Check traffic type existence.
    * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/src/storages/types.ts

@@ -1,6 +1,7 @@
 import { MaybeThenable, ISplit } from '../dtos/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
+import { ISet } from '../utils/lang/sets';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -208,7 +209,8 @@ export interface ISplitsCacheBase {
   clear(): MaybeThenable<boolean | void>,
   // 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>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
+  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -224,7 +226,8 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   usesSegments(): boolean,
   clear(): void,
   checkCache(): boolean,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
+  getNamesByFlagSets(flagSets: string[]): ISet<string>
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -240,7 +243,8 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
+  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
 }
 
 /** Segments cache */

package/src/sync/polling/syncTasks/splitsSyncTask.ts

@@ -24,6 +24,7 @@ export function splitsSyncTaskFactory(
       splitChangesFetcherFactory(fetchSplitChanges),
       storage.splits,
       storage.segments,
+      settings.sync.__splitFiltersValidation,
       readiness.splits,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,