@splitsoftware/splitio-commons 2.1.0-rc.2 → 2.1.1-rc.0

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -0,0 +1,68 @@
+import { IRBSegment } from '../../dtos/types';
+import { setToArray } from '../../utils/lang/sets';
+import { usesSegments } from '../AbstractSplitsCacheSync';
+import { IRBSegmentsCacheSync } from '../types';
+
+export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
+
+  private cache: Record<string, IRBSegment> = {};
+  private changeNumber: number = -1;
+  private segmentsCount: number = 0;
+
+  clear() {
+    this.cache = {};
+    this.changeNumber = -1;
+    this.segmentsCount = 0;
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    this.changeNumber = changeNumber;
+    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+  }
+
+  private add(rbSegment: IRBSegment): boolean {
+    const name = rbSegment.name;
+    const previous = this.get(name);
+    if (previous && usesSegments(previous)) this.segmentsCount--;
+
+    this.cache[name] = rbSegment;
+    if (usesSegments(rbSegment)) this.segmentsCount++;
+
+    return true;
+  }
+
+  private remove(name: string): boolean {
+    const rbSegment = this.get(name);
+    if (!rbSegment) return false;
+
+    delete this.cache[name];
+
+    if (usesSegments(rbSegment)) this.segmentsCount--;
+
+    return true;
+  }
+
+  private getNames(): string[] {
+    return Object.keys(this.cache);
+  }
+
+  get(name: string): IRBSegment | null {
+    return this.cache[name] || null;
+  }
+
+  contains(names: Set<string>): boolean {
+    const namesArray = setToArray(names);
+    const namesInStorage = this.getNames();
+    return namesArray.every(name => namesInStorage.indexOf(name) !== -1);
+  }
+
+  getChangeNumber(): number {
+    return this.changeNumber;
+  }
+
+  usesSegments(): boolean {
+    return this.segmentsCount > 0;
+  }
+
+}

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -26,7 +26,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.segmentsCount = 0;
   }
 
-  addSplit(name: string, split: ISplit): boolean {
+  addSplit(split: ISplit): boolean {
+    const name = split.name;
     const previousSplit = this.getSplit(name);
     if (previousSplit) { // We had this Split already
 
@@ -40,41 +41,35 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       if (usesSegments(previousSplit)) this.segmentsCount--;
     }
 
-    if (split) {
-      // Store the Split.
-      this.splitsCache[name] = split;
-      // Update TT cache
-      const ttName = split.trafficTypeName;
-      this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-      this.addToFlagSets(split);
+    // Store the Split.
+    this.splitsCache[name] = split;
+    // 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.segmentsCount++;
+    // Add to segments count for the new version of the Split
+    if (usesSegments(split)) this.segmentsCount++;
 
-      return true;
-    } else {
-      return false;
-    }
+    return true;
   }
 
   removeSplit(name: string): boolean {
     const split = this.getSplit(name);
-    if (split) {
-      // Delete the Split
-      delete this.splitsCache[name];
+    if (!split) return false;
 
-      const ttName = split.trafficTypeName;
-      this.ttCache[ttName]--; // Update tt cache
-      if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      this.removeFromFlagSets(split.name, split.sets);
+    // Delete the Split
+    delete this.splitsCache[name];
 
-      // Update the segments count.
-      if (usesSegments(split)) this.segmentsCount--;
+    const ttName = split.trafficTypeName;
+    this.ttCache[ttName]--; // Update tt cache
+    if (!this.ttCache[ttName]) delete this.ttCache[ttName];
+    this.removeFromFlagSets(split.name, split.sets);
 
-      return true;
-    } else {
-      return false;
-    }
+    // Update the segments count.
+    if (usesSegments(split)) this.segmentsCount--;
+
+    return true;
   }
 
   getSplit(name: string): ISplit | null {

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -0,0 +1,79 @@
+import { isNaNNumber } from '../../utils/lang';
+import { IRBSegmentsCacheAsync } from '../types';
+import { ILogger } from '../../logger/types';
+import { IRBSegment } from '../../dtos/types';
+import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
+import { RedisAdapter } from './RedisAdapter';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+
+export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
+
+  private readonly log: ILogger;
+  private readonly keys: KeyBuilderSS;
+  private readonly redis: RedisAdapter;
+
+  constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter) {
+    this.log = log;
+    this.keys = keys;
+    this.redis = redis;
+  }
+
+  get(name: string): Promise<IRBSegment | null> {
+    return this.redis.get(this.keys.buildRBSegmentKey(name))
+      .then(maybeRBSegment => maybeRBSegment && JSON.parse(maybeRBSegment));
+  }
+
+  private getNames(): Promise<string[]> {
+    return this.redis.keys(this.keys.searchPatternForRBSegmentKeys()).then(
+      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+    );
+  }
+
+  contains(names: Set<string>): Promise<boolean> {
+    const namesArray = setToArray(names);
+    return this.getNames().then(namesInStorage => {
+      return namesArray.every(name => namesInStorage.includes(name));
+    });
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(toAdd.map(toAdd => {
+        const key = this.keys.buildRBSegmentKey(toAdd.name);
+        const stringifiedNewRBSegment = JSON.stringify(toAdd);
+        return this.redis.set(key, stringifiedNewRBSegment).then(() => true);
+      })),
+      Promise.all(toRemove.map(toRemove => {
+        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        return this.redis.del(key).then(status => status === 1);
+      }))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
+  setChangeNumber(changeNumber: number) {
+    return this.redis.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '').then(
+      status => status === 'OK'
+    );
+  }
+
+  getChangeNumber(): Promise<number> {
+    return this.redis.get(this.keys.buildRBSegmentsTillKey()).then((value: string | null) => {
+      const i = parseInt(value as string, 10);
+
+      return isNaNNumber(i) ? -1 : i;
+    }).catch((e) => {
+      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+      return -1;
+    });
+  }
+
+  // @TODO implement if required by DataLoader or producer mode
+  clear() {
+    return Promise.resolve();
+  }
+
+}

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -82,7 +82,8 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(name: string, split: ISplit): Promise<boolean> {
+  addSplit(split: ISplit): Promise<boolean> {
+    const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then(splitFromStorage => {
 
@@ -107,18 +108,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     }).then(() => true);
   }
 
-  /**
-   * Add a list of splits.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., redis operation fails)
-   */
-  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
-    return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
-  }
-
   /**
    * Remove a given split.
-   * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
+   * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
    * or rejected if it fails (e.g., redis operation fails).
    */
   removeSplit(name: string) {
@@ -127,19 +119,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
     }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name));
+      return this.redis.del(this.keys.buildSplitKey(name)).then(status => status === 1);
     });
   }
 
-  /**
-   * Remove a list of splits.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., redis operation fails).
-   */
-  removeSplits(names: string[]): Promise<any> {
-    return Promise.all(names.map(name => this.removeSplit(name)));
-  }
-
   /**
    * Get split definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.

package/src/storages/inRedis/constants.ts

@@ -1,4 +1,4 @@
 export const LOG_PREFIX = 'storage:redis: ';
 export const DEFAULT_CACHE_SIZE = 30000;
-export const REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
+export const REFRESH_RATE = 300000; // 300000 ms = start after 5 mins
 export const TTL_REFRESH = 3600; // 1hr

package/src/storages/inRedis/index.ts

@@ -11,6 +11,7 @@ import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 import { metadataBuilder } from '../utils';
+import { RBSegmentsCacheInRedis } from './RBSegmentsCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -50,6 +51,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
     return {
       splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+      rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       impressionCounts: impressionCountsCache,

package/src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -0,0 +1,76 @@
+import { isNaNNumber } from '../../utils/lang';
+import { KeyBuilder } from '../KeyBuilder';
+import { IPluggableStorageWrapper, IRBSegmentsCacheAsync } from '../types';
+import { ILogger } from '../../logger/types';
+import { IRBSegment } from '../../dtos/types';
+import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
+
+export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
+
+  private readonly log: ILogger;
+  private readonly keys: KeyBuilder;
+  private readonly wrapper: IPluggableStorageWrapper;
+
+  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper) {
+    this.log = log;
+    this.keys = keys;
+    this.wrapper = wrapper;
+  }
+
+  get(name: string): Promise<IRBSegment | null> {
+    return this.wrapper.get(this.keys.buildRBSegmentKey(name))
+      .then(maybeRBSegment => maybeRBSegment && JSON.parse(maybeRBSegment));
+  }
+
+  private getNames(): Promise<string[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildRBSegmentKeyPrefix()).then(
+      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
+    );
+  }
+
+  contains(names: Set<string>): Promise<boolean> {
+    const namesArray = setToArray(names);
+    return this.getNames().then(namesInStorage => {
+      return namesArray.every(name => namesInStorage.includes(name));
+    });
+  }
+
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(toAdd.map(toAdd => {
+        const key = this.keys.buildRBSegmentKey(toAdd.name);
+        const stringifiedNewRBSegment = JSON.stringify(toAdd);
+        return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
+      })),
+      Promise.all(toRemove.map(toRemove => {
+        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        return this.wrapper.del(key);
+      }))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
+  setChangeNumber(changeNumber: number) {
+    return this.wrapper.set(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+  }
+
+  getChangeNumber(): Promise<number> {
+    return this.wrapper.get(this.keys.buildRBSegmentsTillKey()).then((value) => {
+      const i = parseInt(value as string, 10);
+
+      return isNaNNumber(i) ? -1 : i;
+    }).catch((e) => {
+      this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+      return -1;
+    });
+  }
+
+  // @TODO implement if required by DataLoader or producer mode
+  clear() {
+    return Promise.resolve();
+  }
+
+}

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -66,7 +66,8 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: ISplit): Promise<boolean> {
+  addSplit(split: ISplit): Promise<boolean> {
+    const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
@@ -91,15 +92,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     }).then(() => true);
   }
 
-  /**
-   * Add a list of splits.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., wrapper operation fails)
-   */
-  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
-    return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
-  }
-
   /**
    * Remove a given split.
    * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -115,15 +107,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     });
   }
 
-  /**
-   * 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).
-   */
-  removeSplits(names: string[]): Promise<void> { // @ts-ignore
-    return Promise.all(names.map(name => this.removeSplit(name)));
-  }
-
   /**
    * Get split.
    * The returned promise is resolved with the split definition or null if it's not defined,

package/src/storages/pluggable/index.ts

@@ -20,6 +20,7 @@ import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { metadataBuilder } from '../utils';
 import { LOG_PREFIX } from '../pluggable/constants';
+import { RBSegmentsCachePluggable } from './RBSegmentsCachePluggable';
 
 const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
@@ -88,8 +89,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     // Connects to wrapper and emits SDK_READY event on main client
     const connectPromise = wrapper.connect().then(() => {
       if (isSynchronizer) {
-        // @TODO reuse InLocalStorage::validateCache logic
-        // In standalone or producer mode, clear storage if SDK key, flags filter criteria or flags spec version was modified
+        // 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) {
@@ -117,6 +117,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+      rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
       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

@@ -1,5 +1,5 @@
 import SplitIO from '../../types/splitio';
-import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
+import { MaybeThenable, ISplit, IRBSegment, IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/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 { ISettings } from '../types';
@@ -177,11 +177,9 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
-  removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): MaybeThenable<boolean>,
   getSplit(name: string): MaybeThenable<ISplit | null>,
   getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
-  setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
   getAll(): MaybeThenable<ISplit[]>,
@@ -191,42 +189,70 @@ export interface ISplitsCacheBase {
   // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   usesSegments(): MaybeThenable<boolean>,
   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>,
   getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): boolean[],
-  removeSplits(names: string[]): boolean[],
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean,
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
-  setChangeNumber(changeNumber: number): boolean | void,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
   clear(): void,
+  checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
   getNamesByFlagSets(flagSets: string[]): Set<string>[]
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
-  removeSplits(names: string[]): Promise<boolean[] | void>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean>,
   getSplit(name: string): Promise<ISplit | null>,
   getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
-  setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
   getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
+  checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
   getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
 }
 
+/** Rule-Based Segments cache */
+
+export interface IRBSegmentsCacheBase {
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): MaybeThenable<boolean>,
+  get(name: string): MaybeThenable<IRBSegment | null>,
+  getChangeNumber(): MaybeThenable<number>,
+  clear(): MaybeThenable<boolean | void>,
+  contains(names: Set<string>): MaybeThenable<boolean>,
+}
+
+export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean,
+  get(name: string): IRBSegment | null,
+  getChangeNumber(): number,
+  clear(): void,
+  contains(names: Set<string>): boolean,
+  // Used only for smart pausing in client-side standalone. Returns true if the storage contains a RBSegment using segments or large segments matchers
+  usesSegments(): boolean,
+}
+
+export interface IRBSegmentsCacheAsync extends IRBSegmentsCacheBase {
+  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean>,
+  get(name: string): Promise<IRBSegment | null>,
+  getChangeNumber(): Promise<number>,
+  clear(): Promise<boolean | void>,
+  contains(names: Set<string>): Promise<boolean>,
+}
+
 /** Segments cache */
 
 export interface ISegmentsCacheBase {
@@ -424,15 +450,17 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
  */
 
 export interface IStorageBase<
-  TSplitsCache extends ISplitsCacheBase,
-  TSegmentsCache extends ISegmentsCacheBase,
-  TImpressionsCache extends IImpressionsCacheBase,
-  TImpressionsCountCache extends IImpressionCountsCacheBase,
-  TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
-  TUniqueKeysCache extends IUniqueKeysCacheBase
+  TSplitsCache extends ISplitsCacheBase = ISplitsCacheBase,
+  TRBSegmentsCache extends IRBSegmentsCacheBase = IRBSegmentsCacheBase,
+  TSegmentsCache extends ISegmentsCacheBase = ISegmentsCacheBase,
+  TImpressionsCache extends IImpressionsCacheBase = IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheBase = IImpressionCountsCacheBase,
+  TEventsCache extends IEventsCacheBase = IEventsCacheBase,
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync = ITelemetryCacheSync | ITelemetryCacheAsync,
+  TUniqueKeysCache extends IUniqueKeysCacheBase = IUniqueKeysCacheBase
 > {
   splits: TSplitsCache,
+  rbSegments: TRBSegmentsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
   impressionCounts: TImpressionsCountCache,
@@ -445,6 +473,7 @@ export interface IStorageBase<
 
 export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
+  IRBSegmentsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
   IImpressionCountsCacheSync,
@@ -453,12 +482,12 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
-  validateCache?: () => boolean, // @TODO support async
   largeSegments?: ISegmentsCacheSync,
 }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
+  IRBSegmentsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
   IImpressionCountsCacheBase,

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -1,6 +1,6 @@
 import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
-import { IStorageSync } from '../../../storages/types';
+import { ISplitsCacheSync } from '../../../storages/types';
 import { ISplitsParser } from '../splitsParser/types';
 import { ISplit, ISplitPartial } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
@@ -15,7 +15,7 @@ import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/c
  */
 export function fromObjectUpdaterFactory(
   splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  storage: { splits: ISplitsCacheSync },
   readiness: IReadinessManager,
   settings: ISettings,
 ): () => Promise<boolean> {
@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, ISplit][] = [];
+    const splits: ISplit[] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -37,33 +37,31 @@ export function fromObjectUpdaterFactory(
     if (!loadError && splitsMock) {
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
-      forOwn(splitsMock, function (val, name) {
-        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-          name, {
-            name,
-            status: 'ACTIVE',
-            killed: false,
-            trafficAllocation: 100,
-            defaultTreatment: CONTROL,
-            conditions: val.conditions || [],
-            configurations: val.configurations,
-            trafficTypeName: val.trafficTypeName
-          }
-        ]);
+      forOwn(splitsMock, (val, name) => {
+        // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+        splits.push({
+          name,
+          status: 'ACTIVE',
+          killed: false,
+          trafficAllocation: 100,
+          defaultTreatment: CONTROL,
+          conditions: val.conditions || [],
+          configurations: val.configurations,
+          trafficTypeName: val.trafficTypeName
+        });
       });
 
       return Promise.all([
         splitsCache.clear(), // required to sync removed splits from mock
-        splitsCache.addSplits(splits)
+        splitsCache.update(splits, [], Date.now())
       ]).then(() => {
         readiness.splits.emit(SDK_SPLITS_ARRIVED);
 
         if (startingUp) {
           startingUp = false;
-          const isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-          Promise.resolve().then(() => {
+          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
             // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
             // Emits SDK_READY
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
           });
@@ -81,7 +79,7 @@ export function fromObjectUpdaterFactory(
  */
 export function fromObjectSyncTaskFactory(
   splitsParser: ISplitsParser,
-  storage: Pick<IStorageSync, 'splits' | 'validateCache'>,
+  storage: { splits: ISplitsCacheSync },
   readiness: IReadinessManager,
   settings: ISettings
 ): ISyncTask<[], boolean> {