Merge branch 'inlocalstorage_storageAdapter' into inlocalstorage_sessionStorage

Author: EmilianoSanchez

src/storages/AbstractMySegmentsCacheSync.ts

@@ -49,10 +49,12 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    this.setChangeNumber(segmentsData.cn);
+
     const { added, removed } = segmentsData as MySegmentsData;
-    let isDiff = false;
 
     if (added && removed) {
+      let isDiff = false;
 
       added.forEach(segment => {
         isDiff = this.addSegment(segment) || isDiff;
@@ -61,40 +63,32 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
       removed.forEach(segment => {
         isDiff = this.removeSegment(segment) || isDiff;
       });
-    } else {
 
-      const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-      const storedSegmentKeys = this.getRegisteredSegments().sort();
+      return isDiff;
+    }
 
-      // Extreme fast => everything is empty
-      if (!names.length && !storedSegmentKeys.length) {
-        isDiff = false;
-      } else {
+    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+    const storedSegmentKeys = this.getRegisteredSegments().sort();
 
-        let index = 0;
+    // Extreme fast => everything is empty
+    if (!names.length && !storedSegmentKeys.length) return false;
 
-        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
+    let index = 0;
 
-        // Quick path => no changes
-        if (index === names.length && index === storedSegmentKeys.length) {
-          isDiff = false;
-        } else {
+    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
 
-          // Slowest path => add and/or remove segments
-          for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeSegment(storedSegmentKeys[removeIndex]);
-          }
+    // Quick path => no changes
+    if (index === names.length && index === storedSegmentKeys.length) return false;
 
-          for (let addIndex = index; addIndex < names.length; addIndex++) {
-            this.addSegment(names[addIndex]);
-          }
+    // Slowest path => add and/or remove segments
+    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+      this.removeSegment(storedSegmentKeys[removeIndex]);
+    }
 
-          isDiff = true;
-        }
-      }
+    for (let addIndex = index; addIndex < names.length; addIndex++) {
+      this.addSegment(names[addIndex]);
     }
 
-    this.setChangeNumber(segmentsData.cn);
-    return isDiff;
+    return true;
   }
 }

src/storages/AbstractSplitsCacheSync.ts

@@ -14,10 +14,9 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   protected abstract setChangeNumber(changeNumber: number): boolean | void
 
   update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
-    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    return updated;
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null

src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -4,6 +4,8 @@ import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
 import { StorageAdapter } from '../types';
+import { IMySegmentsResponse } from '../../dtos/types';
+import { MySegmentsData } from '../../sync/polling/types';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
@@ -19,6 +21,12 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    const result = super.resetSegments(segmentsData);
+    if (this.storage.save) this.storage.save();
+    return result;
+  }
+
   protected addSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 

src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -26,9 +26,10 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    this.setChangeNumber(changeNumber);
     let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
     updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
-    this.setChangeNumber(changeNumber);
+    if (this.storage.save) this.storage.save();
     return updated;
   }
 

src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -79,6 +79,12 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+    const result = super.update(toAdd, toRemove, changeNumber);
+    if (this.storage.save) this.storage.save();
+    return result;
+  }
+
   addSplit(split: ISplit) {
     try {
       const name = split.name;

src/storages/inLocalStorage/__tests__/storageAdapter.spec.ts

@@ -41,25 +41,22 @@ test.each([
   expect(storage.getItem('key1')).toBe(null);
   expect(storage.length).toBe(1);
 
-  // Until a till key is set/removed, changes should not be saved/persisted
+  // Until `save` is called, changes should not be saved/persisted
   await storage.whenSaved();
   expect(wrapper.setItem).not.toHaveBeenCalled();
 
-  // When setting a till key, changes should be saved/persisted immediately
   storage.setItem('.till', '1');
   expect(storage.length).toBe(2);
   expect(storage.key(0)).toBe('key2');
   expect(storage.key(1)).toBe('.till');
 
+  // When `save` is called, changes should be saved/persisted immediately
+  storage.save();
   await storage.whenSaved();
   expect(wrapper.setItem).toHaveBeenCalledWith('prefix', JSON.stringify({ key2: 'value2', '.till': '1' }));
 
-  // When removing a till key, changes should be saved/persisted immediately
-  storage.removeItem('.till');
+  expect(wrapper.setItem).toHaveBeenCalledTimes(1);
 
   await storage.whenSaved();
-  expect(wrapper.setItem).toHaveBeenCalledWith('prefix', JSON.stringify({ key2: 'value2' }));
-
-  await storage.whenSaved();
-  expect(wrapper.setItem).toHaveBeenCalledTimes(2);
+  expect(wrapper.setItem).toHaveBeenCalledTimes(1);
 });

src/storages/inLocalStorage/storageAdapter.ts

@@ -3,9 +3,6 @@ import SplitIO from '../../../types/splitio';
 import { LOG_PREFIX } from './constants';
 import { StorageAdapter } from '../types';
 
-function isTillKey(key: string) {
-  return key.endsWith('.till');
-}
 
 export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.SyncStorageWrapper | SplitIO.AsyncStorageWrapper): Required<StorageAdapter> {
   let keys: string[] = [];
@@ -14,14 +11,6 @@ export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.Sy
   let loadPromise: Promise<void> | undefined;
   let savePromise = Promise.resolve();
 
-  function _save() {
-    return savePromise = savePromise.then(() => {
-      return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
-    }).catch((e) => {
-      log.error(LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
-    });
-  }
-
   return {
     load() {
       return loadPromise || (loadPromise = Promise.resolve().then(() => {
@@ -33,32 +22,41 @@ export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.Sy
         log.error(LOG_PREFIX + 'Rejected promise calling wrapper `getItem` method, with error: ' + e);
       }));
     },
+
+    save() {
+      return savePromise = savePromise.then(() => {
+        return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
+      }).catch((e) => {
+        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
+      });
+    },
+
     whenSaved() {
       return savePromise;
     },
 
     get length() {
       return keys.length;
     },
+
     getItem(key: string) {
       return cache[key] || null;
     },
+
     key(index: number) {
       return keys[index] || null;
     },
+
     removeItem(key: string) {
       const index = keys.indexOf(key);
       if (index === -1) return;
       keys.splice(index, 1);
       delete cache[key];
-
-      if (isTillKey(key)) _save();
     },
+
     setItem(key: string, value: string) {
       if (keys.indexOf(key) === -1) keys.push(key);
       cache[key] = value;
-
-      if (isTillKey(key)) _save();
     }
   };
 }

src/storages/inLocalStorage/validateCache.ts

@@ -87,6 +87,9 @@ export function validateCache(options: SplitIO.InLocalStorageOptions, storage: S
         settings.log.error(LOG_PREFIX + e);
       }
 
+      // Persist clear
+      if (storage.save) storage.save();
+
       return false;
     }
 

src/storages/types.ts

@@ -11,6 +11,7 @@ import { ISettings } from '../types';
 export interface StorageAdapter {
   // Methods to support async storages
   load?: () => Promise<void>;
+  save?: () => Promise<void>;
   whenSaved?: () => Promise<void>;
   // Methods based on https://developer.mozilla.org/en-US/docs/Web/API/Storage
   readonly length: number;