Refactor splits cache: replace add/removeSplits with update method

src/logger/constants.ts

@@ -20,9 +20,7 @@ export const RETRIEVE_CLIENT_EXISTING = 28;
 export const RETRIEVE_MANAGER = 29;
 export const SYNC_OFFLINE_DATA = 30;
 export const SYNC_SPLITS_FETCH = 31;
-export const SYNC_SPLITS_NEW = 32;
-export const SYNC_SPLITS_REMOVED = 33;
-export const SYNC_SPLITS_SEGMENTS = 34;
+export const SYNC_SPLITS_UPDATE = 32;
 export const STREAMING_NEW_MESSAGE = 35;
 export const SYNC_TASK_START = 36;
 export const SYNC_TASK_EXECUTE = 37;

src/logger/messages/debug.ts

@@ -21,9 +21,7 @@ export const codesDebug: [number, string][] = codesInfo.concat([
   // synchronizer
   [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Feature flags data: \n%s'],
   [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s'],
-  [c.SYNC_SPLITS_NEW, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s'],
-  [c.SYNC_SPLITS_REMOVED, c.LOG_PREFIX_SYNC_SPLITS + 'Removed feature flags %s'],
-  [c.SYNC_SPLITS_SEGMENTS, c.LOG_PREFIX_SYNC_SPLITS + 'Segment names collected %s'],
+  [c.SYNC_SPLITS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s. Removed feature flags %s. Segment names collected %s'],
   [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],
   [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + ': Starting %s. Running each %s millis'],
   [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + ': Running %s'],

src/sdkManager/__tests__/index.asyncCache.spec.ts

@@ -33,7 +33,7 @@ describe('Manager with async cache', () => {
     const cache = new SplitsCacheInRedis(loggerMock, keys, connection);
     const manager = sdkManagerFactory({ mode: 'consumer', log: loggerMock }, cache, sdkReadinessManagerMock);
     await cache.clear();
-    await cache.addSplit(splitObject.name, splitObject as any);
+    await cache.addSplit(splitObject as any);
 
     /** List all splits */
     const views = await manager.splits();

src/sdkManager/__tests__/index.syncCache.spec.ts

@@ -19,7 +19,7 @@ describe('Manager with sync cache (In Memory)', () => {
   /** Setup: create manager */
   const cache = new SplitsCacheInMemory();
   const manager = sdkManagerFactory({ mode: 'standalone', log: loggerMock }, cache, sdkReadinessManagerMock);
-  cache.addSplit(splitObject.name, splitObject as any);
+  cache.addSplit(splitObject as any);
 
   test('List all splits', () => {
 

src/storages/AbstractSplitsCacheAsync.ts

@@ -8,12 +8,22 @@ import { objectAssign } from '../utils/lang/objectAssign';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  abstract addSplit(name: string, split: ISplit): Promise<boolean>
-  abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>
-  abstract removeSplits(names: string[]): Promise<boolean[] | void>
+  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
+  protected abstract addSplit(split: ISplit): Promise<boolean>
+  protected abstract removeSplit(name: string): Promise<boolean>
+
+  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): Promise<boolean> {
+    return Promise.all([
+      this.setChangeNumber(changeNumber),
+      Promise.all(addedFFs.map(addedFF => this.addSplit(addedFF))),
+      Promise.all(removedFFs.map(removedFF => this.removeSplit(removedFF.name)))
+    ]).then(([, added, removed]) => {
+      return added.some(result => result) || removed.some(result => result);
+    });
+  }
+
   abstract getSplit(name: string): Promise<ISplit | null>
   abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
-  abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
   abstract getChangeNumber(): Promise<number>
   abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
@@ -52,7 +62,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
         newSplit.defaultTreatment = defaultTreatment;
         newSplit.changeNumber = changeNumber;
 
-        return this.addSplit(name, newSplit);
+        return this.addSplit(newSplit);
       }
       return false;
     }).catch(() => false);

src/storages/AbstractSplitsCacheSync.ts

@@ -9,16 +9,14 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  abstract addSplit(name: string, split: ISplit): boolean
-
-  addSplits(entries: [string, ISplit][]): boolean[] {
-    return entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1]));
-  }
-
-  abstract removeSplit(name: string): boolean
-
-  removeSplits(names: string[]): boolean[] {
-    return names.map(name => this.removeSplit(name));
+  protected abstract setChangeNumber(changeNumber: number): boolean | void
+  protected abstract addSplit(split: ISplit): boolean
+  protected abstract removeSplit(name: string): boolean
+
+  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): boolean {
+    this.setChangeNumber(changeNumber);
+    const updated = addedFFs.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return removedFFs.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null
@@ -31,8 +29,6 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean | void
-
   abstract getChangeNumber(): number
 
   getAll(): ISplit[] {
@@ -71,7 +67,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
       newSplit.defaultTreatment = defaultTreatment;
       newSplit.changeNumber = changeNumber;
 
-      return this.addSplit(name, newSplit);
+      return this.addSplit(newSplit);
     }
     return false;
   }

src/storages/__tests__/testUtils.ts

@@ -23,9 +23,9 @@ export function assertSyncRecorderCacheInterface(cache: IEventsCacheSync | IImpr
 // Split mocks
 
 //@ts-ignore
-export const splitWithUserTT: ISplit = { trafficTypeName: 'user_tt', conditions: [] };
+export const splitWithUserTT: ISplit = { name: 'user_ff', trafficTypeName: 'user_tt', conditions: [] };
 //@ts-ignore
-export const splitWithAccountTT: ISplit = { trafficTypeName: 'account_tt', conditions: [] };
+export const splitWithAccountTT: ISplit = { name: 'account_ff', trafficTypeName: 'account_tt', conditions: [] };
 //@ts-ignore
 export const splitWithAccountTTAndUsesSegments: ISplit = { trafficTypeName: 'account_tt', conditions: [{ matcherGroup: { matchers: [{ matcherType: 'IN_SEGMENT', userDefinedSegmentMatcherData: { segmentName: 'employees' } }] } }] };
 //@ts-ignore

src/storages/dataLoader.ts

@@ -35,10 +35,9 @@ export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
-    storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
+    storage.splits.update(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])), [], since);
 
     // add mySegments data
     let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];

src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -96,8 +96,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
-  addSplit(name: string, split: ISplit) {
+  addSplit(split: ISplit) {
     try {
+      const name = split.name;
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;