Implement basic storageAdapter to support async storages with getItem and setItem methods

Author: EmilianoSanchez

src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,17 +1,17 @@
+import { StorageAdapter } from '.';
 import { ILogger } from '../../logger/types';
 import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
-import SplitIO from '../../../types/splitio';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
-  private readonly localStorage: SplitIO.Storage;
+  private readonly localStorage: StorageAdapter;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder, localStorage: SplitIO.Storage) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder, localStorage: StorageAdapter) {
     super();
     this.log = log;
     this.keys = keys;

src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -7,15 +7,15 @@ import { usesSegments } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { IRBSegmentsCacheSync } from '../types';
 import { LOG_PREFIX } from './constants';
-import SplitIO from '../../../types/splitio';
+import { StorageAdapter } from '.';
 
 export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
-  private readonly localStorage: SplitIO.Storage;
+  private readonly localStorage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS, localStorage: SplitIO.Storage) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, localStorage: StorageAdapter) {
     this.keys = keys;
     this.log = settings.log;
     this.localStorage = localStorage;

src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -6,7 +6,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISettings } from '../../types';
 import { setToArray } from '../../utils/lang/sets';
-import SplitIO from '../../../types/splitio';
+import { StorageAdapter } from '.';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -17,9 +17,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private readonly log: ILogger;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
-  private readonly localStorage: SplitIO.Storage;
+  private readonly localStorage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS, localStorage: SplitIO.Storage) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, localStorage: StorageAdapter) {
     super();
     this.keys = keys;
     this.log = settings.log;

src/storages/inLocalStorage/index.ts

@@ -18,9 +18,67 @@ import { validateCache } from './validateCache';
 import { ILogger } from '../../logger/types';
 import SplitIO from '../../../types/splitio';
 
-function validateStorage(log: ILogger, storage?: SplitIO.Storage) {
+export interface StorageAdapter {
+  // Methods to support async storages
+  load?: () => Promise<void>;
+  save?: () => Promise<void>;
+  // Methods based on https://developer.mozilla.org/en-US/docs/Web/API/Storage
+  readonly length: number;
+  getItem(key: string): string | null;
+  key(index: number): string | null;
+  removeItem(key: string): void;
+  setItem(key: string, value: string): void;
+}
+
+function isTillKey(key: string) {
+  return key.endsWith('.till');
+}
+
+function storageAdapter(log: ILogger, prefix: string, storage: SplitIO.Storage): StorageAdapter {
+  let cache: Record<string, string> = {};
+
+  let connectPromise: Promise<void> | undefined;
+  let disconnectPromise = Promise.resolve();
+
+  return {
+    load() {
+      return connectPromise || (connectPromise = storage.getItem(prefix).then((storedCache) => {
+        cache = JSON.parse(storedCache || '{}');
+      }).catch((e) => {
+        log.error(LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
+      }));
+    },
+    save() {
+      return disconnectPromise = disconnectPromise.then(() => {
+        return storage.setItem(prefix, JSON.stringify(cache)).catch((e) => {
+          log.error(LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
+        });
+      });
+    },
+
+    get length() {
+      return Object.keys(cache).length;
+    },
+    getItem(key: string) {
+      return cache[key] || null;
+    },
+    key(index: number) {
+      return Object.keys(cache)[index] || null;
+    },
+    removeItem(key: string) {
+      delete cache[key];
+      if (isTillKey(key)) this.save!();
+    },
+    setItem(key: string, value: string) {
+      cache[key] = value;
+      if (isTillKey(key)) this.save!();
+    }
+  };
+}
+
+function validateStorage(log: ILogger, prefix: string, storage?: SplitIO.Storage): StorageAdapter | undefined {
   if (storage) {
-    if (isStorageValid(storage)) return storage;
+    if (isStorageValid(storage)) return storageAdapter(log, prefix, storage);
     log.warn(LOG_PREFIX + 'Invalid storage provided. Falling back to LocalStorage API');
   }
 
@@ -39,7 +97,7 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
   function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
     const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
 
-    const storage = validateStorage(log, options.storage);
+    const storage = validateStorage(log, prefix, options.storage);
     if (!storage) return InMemoryStorageCSFactory(params);
 
     const matchingKey = getMatching(settings.core.key);
@@ -67,8 +125,7 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       },
 
       destroy() {
-        // @TODO return `storageWrapper.disconnect()`
-        return Promise.resolve();
+        return storage.save && storage.save();
       },
 
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).

src/storages/inLocalStorage/validateCache.ts

@@ -7,6 +7,7 @@ import type { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import SplitIO from '../../../types/splitio';
+import { StorageAdapter } from '.';
 
 const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
 const MILLIS_IN_A_DAY = 86400000;
@@ -16,7 +17,7 @@ const MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: SplitIO.Storage, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
+function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
   const { log } = settings;
 
   // Check expiration
@@ -67,9 +68,9 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: Spl
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-export function validateCache(options: SplitIO.InLocalStorageOptions, storage: SplitIO.Storage, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<boolean> {
+export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<boolean> {
 
-  return Promise.resolve().then(() => {
+  return Promise.resolve(storage.load && storage.load()).then(() => {
     const currentTimestamp = Date.now();
     const isThereCache = splits.getChangeNumber() > -1;
 

types/splitio.d.ts

@@ -451,50 +451,17 @@ declare namespace SplitIO {
 
   interface Storage {
     /**
-     * Returns the number of key/value pairs.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Storage/length)
-     */
-    readonly length: number;
-    /**
-     * Removes all key/value pairs, if there are any.
-     *
-     * Dispatches a storage event on Window objects holding an equivalent Storage object.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Storage/clear)
-     */
-    clear(): void;
-    /**
-     * Returns the current value associated with the given key, or null if the given key does not exist.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Storage/getItem)
-     */
-    getItem(key: string): string | null;
-    /**
-     * Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Storage/key)
+     * Returns a promise that resolves to the current value associated with the given key, or null if the given key does not exist.
      */
-    key(index: number): string | null;
+    getItem(key: string): Promise<string | null>;
     /**
-     * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
-     *
-     * Dispatches a storage event on Window objects holding an equivalent Storage object.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Storage/removeItem)
-     */
-    removeItem(key: string): void;
-    /**
-     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
-     *
-     * Throws a "QuotaExceededError" DOMException exception if the new value couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site, or if the quota has been exceeded.)
-     *
-     * Dispatches a storage event on Window objects holding an equivalent Storage object.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Storage/setItem)
+     * Returns a promise that resolves when the value of the pair identified by key is set to value, creating a new key/value pair if none existed for key previously.
      */
-    setItem(key: string, value: string): void;
-    [name: string]: any;
+    setItem(key: string, value: string): Promise<void>;
+    // /**
+    //  * Returns a promise that resolves when the key/value pair with the given key is removed, if a key/value pair with the given key exists.
+    //  */
+    // removeItem(key: string): Promise<void>;
   }
 
   /**