@splitsoftware/splitio-commons 1.12.1-rc.4 → 1.12.1-rc.5

package/src/sdkClient/clientInputValidation.ts

@@ -16,8 +16,8 @@ import { CONTROL, CONTROL_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, GET_TREATM
 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';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
 
 /**
  * Decorator that validates the input before actually executing the client methods.
@@ -25,8 +25,8 @@ import { flagSetsAreValid } from '../utils/settingsValidation/splitFilters';
  */
 export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient {
 
-  const log = settings.log;
-  const isSync = isStorageSync(settings);
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   /**
    * Avoid repeating this validations code
@@ -42,7 +42,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
     if (maybeFlagSetNameOrNames) {
-      flagSetOrFlagSets = flagSetsAreValid(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
+      flagSetOrFlagSets = validateFlagSets(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
     }
 
     validateIfOperational(log, readinessManager, methodName, splitOrSplits);
@@ -59,7 +59,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function wrapResult<T>(value: T): MaybeThenable<T> {
-    return isSync ? value : Promise.resolve(value);
+    return isAsync ? Promise.resolve(value) : value;
   }
 
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
@@ -159,7 +159,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
       return client.track(key, tt, event, eventValue, properties, size);
     } else {
-      return isSync ? false : Promise.resolve(false);
+      return isAsync ? Promise.resolve(false) : false;
     }
   }
 

package/src/sdkManager/index.ts

@@ -6,7 +6,7 @@ import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
 import { ISettings, SplitIO } from '../types';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 
 function collectTreatments(splitObject: ISplit) {
@@ -51,8 +51,8 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
   { readinessManager, sdkStatus }: ISdkReadinessManager,
 ): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
 
-  const log = settings.log;
-  const isSync = isStorageSync(settings);
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -64,7 +64,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
       split(featureFlagName: string) {
         const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-          return isSync ? null : Promise.resolve(null);
+          return isAsync ? Promise.resolve(null) : null;
         }
 
         const split = splits.getSplit(splitName);
@@ -85,7 +85,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       splits() {
         if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-          return isSync ? [] : Promise.resolve([]);
+          return isAsync ? Promise.resolve([]) : [];
         }
         const currentSplits = splits.getAll();
 
@@ -98,7 +98,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       names() {
         if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-          return isSync ? [] : Promise.resolve([]);
+          return isAsync ? Promise.resolve([]) : [];
         }
         const splitNames = splits.getSplitNames();
 

package/src/storages/KeyBuilder.ts

@@ -1,4 +1,6 @@
+import { ISettings } from '../types';
 import { startsWith } from '../utils/lang';
+import { hash } from '../utils/murmur3/murmur3';
 
 const everythingAtTheEnd = /[^.]+$/;
 
@@ -10,7 +12,7 @@ export function validatePrefix(prefix: unknown) {
 
 export class KeyBuilder {
 
-  protected readonly prefix: string;
+  readonly prefix: string;
 
   constructor(prefix: string = DEFAULT_PREFIX) {
     this.prefix = prefix;
@@ -73,4 +75,15 @@ export class KeyBuilder {
     }
   }
 
+  buildHashKey() {
+    return `${this.prefix}.hash`;
+  }
+}
+
+/**
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
+ * The hash is in hexadecimal format (8 characters max, 32 bits).
+ */
+export function getStorageHash(settings: ISettings) {
+  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}`).toString(16);
 }

package/src/storages/KeyBuilderCS.ts

@@ -9,7 +9,7 @@ export class KeyBuilderCS extends KeyBuilder {
   constructor(prefix: string, matchingKey: string) {
     super(prefix);
     this.matchingKey = matchingKey;
-    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType)\\.`);
+    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.`);
   }
 
   /**
@@ -45,8 +45,4 @@ export class KeyBuilderCS extends KeyBuilder {
   isSplitsCacheKey(key: string) {
     return this.regexSplitsCacheKey.test(key);
   }
-
-  buildSplitsFilterQueryKey() {
-    return `${this.prefix}.splits.filterQuery`;
-  }
 }

package/src/storages/KeyBuilderSS.ts

@@ -16,10 +16,10 @@ export const METHOD_NAMES: Record<Method, string> = {
 
 export class KeyBuilderSS extends KeyBuilder {
 
-  latencyPrefix: string;
-  exceptionPrefix: string;
-  initPrefix: string;
-  private versionablePrefix: string;
+  readonly latencyPrefix: string;
+  readonly exceptionPrefix: string;
+  readonly initPrefix: string;
+  private readonly versionablePrefix: string;
 
   constructor(prefix: string, metadata: IMetadata) {
     super(prefix);

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,10 +1,12 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISet, _Set, setToArray } from '../../utils/lang/sets';
+import { ISettings } from '../../types';
+import { getStorageHash } from '../KeyBuilder';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -12,7 +14,8 @@ import { ISet, _Set, setToArray } from '../../utils/lang/sets';
 export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
-  private readonly splitFiltersValidation: ISplitFiltersValidation;
+  private readonly log: ILogger;
+  private readonly storageHash: string;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
   private updateNewFilter?: boolean;
@@ -22,11 +25,12 @@ 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: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, expirationTimestamp?: number) {
     super();
     this.keys = keys;
-    this.splitFiltersValidation = splitFiltersValidation;
-    this.flagSetsFilter = this.splitFiltersValidation.groupedFilters.bySet;
+    this.log = settings.log;
+    this.storageHash = getStorageHash(settings);
+    this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
 
     this._checkExpiration(expirationTimestamp);
 
@@ -142,12 +146,10 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
     // when using a new split query, we must update it at the store
     if (this.updateNewFilter) {
-      this.log.info(LOG_PREFIX + 'Split filter query was modified. Updating cache.');
-      const queryKey = this.keys.buildSplitsFilterQueryKey();
-      const queryString = this.splitFiltersValidation.queryString;
+      this.log.info(LOG_PREFIX + 'SDK key or feature flag filter criteria was modified. Updating cache.');
+      const storageHashKey = this.keys.buildHashKey();
       try {
-        if (queryString) localStorage.setItem(queryKey, queryString);
-        else localStorage.removeItem(queryKey);
+        localStorage.setItem(storageHashKey, this.storageHash);
       } catch (e) {
         this.log.error(LOG_PREFIX + e);
       }
@@ -237,12 +239,12 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
+  // @TODO eventually remove `_checkFilterQuery`. Cache should be cleared at the storage level, reusing same logic than PluggableStorage
   private _checkFilterQuery() {
-    const { queryString } = this.splitFiltersValidation;
-    const queryKey = this.keys.buildSplitsFilterQueryKey();
-    const currentQueryString = localStorage.getItem(queryKey);
+    const storageHashKey = this.keys.buildHashKey();
+    const storageHash = localStorage.getItem(storageHashKey);
 
-    if (currentQueryString !== queryString) {
+    if (storageHash !== this.storageHash) {
       try {
         // mark cache to update the new query filter on first successful splits fetch
         this.updateNewFilter = true;

package/src/storages/inLocalStorage/index.ts

@@ -41,7 +41,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
     const keys = new KeyBuilderCS(prefix, matchingKey as string);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    const splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+    const splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
     const segments = new MySegmentsCacheInLocal(log, keys);
 
     return {

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnListDifference } from '../../utils/lang/sets';
+import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 
 /**
@@ -60,9 +60,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
-    const removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+    const removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
 
-    let addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+    let addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
     if (this.flagSetsFilter.length > 0) {
       addToFlagSets = addToFlagSets.filter(flagSet => {
         return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);

package/src/storages/inRedis/index.ts

@@ -45,7 +45,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
     });
 
     return {
-      splits: new SplitsCacheInRedis(log, keys, redisClient),
+      splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -5,7 +5,7 @@ import { ILogger } from '../../logger/types';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnListDifference } from '../../utils/lang/sets';
+import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -44,9 +44,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   }
 
   private _updateFlagSets(featureFlagName: string, flagSetsOfRemovedFlag?: string[], flagSetsOfAddedFlag?: string[]) {
-    const removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+    const removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
 
-    let addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+    let addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
     if (this.flagSetsFilter.length > 0) {
       addToFlagSets = addToFlagSets.filter(flagSet => {
         return this.flagSetsFilter.some(filterFlagSet => filterFlagSet === flagSet);

package/src/storages/pluggable/index.ts

@@ -7,7 +7,7 @@ import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
-import { validatePrefix } from '../KeyBuilder';
+import { getStorageHash, validatePrefix } from '../KeyBuilder';
 import { CONSUMER_PARTIAL_MODE, DEBUG, NONE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
@@ -90,13 +90,23 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
     // Connects to wrapper and emits SDK_READY event on main client
     const connectPromise = wrapper.connect().then(() => {
-      onReadyCb();
-
-      // Start periodic flush of async storages if not running synchronizer (producer mode)
-      if (!isSyncronizer) {
+      if (isSyncronizer) {
+        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+        return wrapper.get(keys.buildHashKey()).then((hash) => {
+          const currentHash = getStorageHash(settings);
+          if (hash !== currentHash) {
+            return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
+              return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
+            }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
+          }
+        }).then(onReadyCb);
+      } else {
+        // Start periodic flush of async storages if not running synchronizer (producer mode)
         if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
         if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
         if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
+
+        onReadyCb();
       }
     }).catch((e) => {
       e = e || new Error('Error connecting wrapper');

package/src/storages/types.ts

@@ -457,7 +457,7 @@ export interface IStorageBase<
   TEventsCache extends IEventsCacheBase,
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase
-  > {
+> {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
@@ -477,7 +477,7 @@ export interface IStorageSync extends IStorageBase<
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
-  > { }
+> { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
@@ -487,7 +487,7 @@ export interface IStorageAsync extends IStorageBase<
   IEventsCacheAsync | IEventsCacheSync,
   ITelemetryCacheAsync | ITelemetryCacheSync,
   IUniqueKeysCacheBase
-  > { }
+> { }
 
 /** StorageFactory */
 

package/src/trackers/eventTracker.ts

@@ -5,7 +5,7 @@ import { IEventsHandler, IEventTracker } from './types';
 import { ISettings, SplitIO } from '../types';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
 import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
-import { isStorageSync } from './impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
@@ -20,8 +20,8 @@ export function eventTrackerFactory(
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
 
-  const log = settings.log;
-  const isSync = isStorageSync(settings);
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   function queueEventsCallback(eventData: SplitIO.EventData, tracked: boolean) {
     const { eventTypeId, trafficTypeName, key, value, timestamp, properties } = eventData;
@@ -50,7 +50,7 @@ export function eventTrackerFactory(
   return {
     track(eventData: SplitIO.EventData, size?: number) {
       if (settings.userConsent === CONSENT_DECLINED) {
-        return isSync ? false : Promise.resolve(false);
+        return isAsync ? Promise.resolve(false) : false;
       }
 
       const tracked = eventsCache.track(eventData, size);

package/src/utils/lang/sets.ts

@@ -120,7 +120,7 @@ export function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T> {
   return result;
 }
 
-export function returnListDifference<T>(list: T[] = [], list2: T[] = []): T[] {
+export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
   const result = new _Set(list);
   list2.forEach(item => {
     result.delete(item);

package/src/utils/murmur3/murmur3.ts

@@ -66,7 +66,6 @@ function hash32(key?: string, seed?: number) {
 }
 
 export function hash(str: string, seed?: number): number {
-
   return hash32(UTF16ToUTF8(str), seed as number >>> 0);
 }
 

package/src/utils/settingsValidation/index.ts

@@ -1,5 +1,5 @@
 import { merge, get } from '../lang';
-import { mode } from './mode';
+import { validateMode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
@@ -146,7 +146,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
 
   // ensure a valid SDK mode
   // @ts-ignore, modify readonly prop
-  withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);
+  withDefaults.mode = validateMode(withDefaults.core.authorizationKey, withDefaults.mode);
 
   // ensure a valid Storage based on mode defined.
   // @ts-ignore, modify readonly prop

package/src/utils/settingsValidation/mode.ts

@@ -1,6 +1,6 @@
 import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 
-export function mode(key: string, mode: string) {
+export function validateMode(key: string, mode: string) {
   // Leaving the comparison as is, in case we change the mode name but not the setting.
   if (key === 'localhost') return LOCALHOST_MODE;
 
@@ -8,3 +8,10 @@ export function mode(key: string, mode: string) {
 
   return mode;
 }
+
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isConsumerMode(mode: string) {
+  return CONSUMER_MODE === mode || CONSUMER_PARTIAL_MODE === mode;
+}

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,11 +1,11 @@
-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_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 { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_LOWERCASE_FLAGSET, WARN_INVALID_FLAGSET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
+import { isConsumerMode } from './mode';
 
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
@@ -54,7 +54,7 @@ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values
   if (result) {
 
     if (type === 'bySet') {
-      result = sanitizeFlagSets(log, result);
+      result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
     }
 
     // check max length
@@ -88,7 +88,7 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
 }
 
 /**
- * Sanitizes set names list taking in account:
+ * Sanitizes set names list taking into 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
@@ -98,20 +98,21 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
  *
  * @param {ILogger} log
  * @param {string[]} flagSets
+ * @param {string} method
  * @returns sanitized list of set names
  */
-function sanitizeFlagSets(log: ILogger, flagSets: string[]) {
+function sanitizeFlagSets(log: ILogger, flagSets: string[], method: string) {
   let sanitizedSets = flagSets
     .map(flagSet => {
       if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
-        log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
+        log.warn(WARN_LOWERCASE_FLAGSET, [method, 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]);
+        log.warn(WARN_INVALID_FLAGSET, [method, flagSet, VALID_FLAGSET_REGEX, flagSet]);
         return false;
       }
       if (typeof flagSet !== 'string') return false;
@@ -148,7 +149,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   // 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) {
+  if (isConsumerMode(mode)) {
     log.warn(WARN_SPLITS_FILTER_IGNORED);
     return res;
   }
@@ -188,9 +189,9 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   return res;
 }
 
-export function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] {
+export function validateFlagSets(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) : [];
+  let toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
   if (flagSetsInConfig.length > 0) {
     toReturn = toReturn.filter(flagSet => {
       if (flagSetsInConfig.indexOf(flagSet) > -1) {

package/types/logger/constants.d.ts

@@ -95,8 +95,8 @@ 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_INVALID_FLAGSET = 225;
+export declare const WARN_LOWERCASE_FLAGSET = 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;

package/types/storages/AbstractSplitsCache.d.ts

@@ -0,0 +1,46 @@
+import { ISplit, MaybeThenable } from '../dtos/types';
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+export declare abstract class AbstractSplitsCache {
+    /**
+     * Check if the splits information is already stored in cache. This data can be preloaded.
+     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+     */
+    checkCache(): boolean;
+    protected abstract addSplit(name: string, split: ISplit): MaybeThenable<boolean>;
+    /**
+     * Add a list of splits.
+     * The returned promise is resolved when the operation success or rejected if it fails (e.g., wrapper operation fails).
+     */
+    protected addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
+    protected abstract removeSplit(name: string): MaybeThenable<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.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    protected removeSplits(names: string[]): Promise<boolean[]>;
+    protected abstract setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
+    /**
+     * Updates the cache with the provided changeNumber, feature flags to add and feature flags to remove.
+     *
+     * @returns {Promise<boolean>} a promise that resolved once the operation is performed successfully. The fulfillment value is `true` if at least one feature flag was added, modified or removed; or `false` if there was no change.
+     * The promise will reject if some storage operation rejects.
+     */
+    update(changeNumber: number, toAdd: [string, ISplit][], toRemove?: string[]): Promise<boolean>;
+    abstract getSplit(name: string): MaybeThenable<ISplit | null>;
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @param {string} name
+     * @param {string} defaultTreatment
+     * @param {number} changeNumber
+     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
+     * 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.
+     * The promise will never be rejected.
+     */
+    killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
+}

package/types/storages/KeyBuilder.d.ts

@@ -1,6 +1,7 @@
+import { ISettings } from '../types';
 export declare function validatePrefix(prefix: unknown): string;
 export declare class KeyBuilder {
-    protected readonly prefix: string;
+    readonly prefix: string;
     constructor(prefix?: string);
     buildTrafficTypeKey(trafficType: string): string;
     buildFlagSetKey(flagSet: string): string;
@@ -12,4 +13,10 @@ export declare class KeyBuilder {
     buildSegmentNameKey(segmentName: string): string;
     buildSegmentTillKey(segmentName: string): string;
     extractKey(builtKey: string): string;
+    buildHashKey(): string;
 }
+/**
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
+ * The hash is in hexadecimal format (8 characters max, 32 bits).
+ */
+export declare function getStorageHash(settings: ISettings): string;

package/types/storages/KeyBuilderCS.d.ts

@@ -12,5 +12,4 @@ export declare class KeyBuilderCS extends KeyBuilder {
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
-    buildSplitsFilterQueryKey(): string;
 }

package/types/storages/KeyBuilderSS.d.ts

@@ -3,10 +3,10 @@ import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
 export declare const METHOD_NAMES: Record<Method, string>;
 export declare class KeyBuilderSS extends KeyBuilder {
-    latencyPrefix: string;
-    exceptionPrefix: string;
-    initPrefix: string;
-    private versionablePrefix;
+    readonly latencyPrefix: string;
+    readonly exceptionPrefix: string;
+    readonly initPrefix: string;
+    private readonly versionablePrefix;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;