Add support for chrome.storage backed configuration store. (#63)

* bump to commons 3.0.6; add LocalStorageBackedAsyncStore (FF-1980)

* Add support for chrome.storage backed configuration store.

* comment

* chain

* Attempt to provide a unit test for configuration factory.

Author: leoromanovsky

package.json

@@ -32,6 +32,7 @@
   "devDependencies": {
     "@microsoft/api-documenter": "^7.23.9",
     "@microsoft/api-extractor": "^7.38.0",
+    "@types/chrome": "^0.0.268",
     "@types/jest": "^29.5.11",
     "@types/md5": "^2.3.2",
     "@typescript-eslint/eslint-plugin": "^5.13.0",

src/chrome.configuration-store.spec.ts

@@ -0,0 +1,62 @@
+import { ChromeStorageAsyncStore } from './chrome.configuration-store';
+
+describe('ChromeStore', () => {
+  const mockEntries: Record<string, string> = { key1: 'value1', key2: 'value2' };
+  let chromeStore: ChromeStorageAsyncStore<string>;
+  let extendedStorageLocal: chrome.storage.StorageArea;
+
+  beforeEach(() => {
+    const get = jest.fn();
+    const set = jest.fn();
+    extendedStorageLocal = {
+      set,
+      get,
+      clear: jest.fn(),
+      remove: jest.fn(),
+      getBytesInUse: jest.fn(),
+      setAccessLevel: jest.fn(),
+      onChanged: {
+        addListener: jest.fn(),
+        removeListener: jest.fn(),
+        getRules: jest.fn(),
+        hasListener: jest.fn(),
+        removeRules: jest.fn(),
+        addRules: jest.fn(),
+        hasListeners: jest.fn(),
+      },
+    };
+
+    chromeStore = new ChromeStorageAsyncStore(extendedStorageLocal);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('is always expired', async () => {
+    expect(await chromeStore.isExpired()).toBe(true);
+  });
+
+  it('should return null when no entries are found', async () => {
+    (extendedStorageLocal.get as jest.Mock).mockImplementation(() => {
+      return Promise.resolve({});
+    });
+
+    const entries = await chromeStore.getEntries();
+    expect(entries).toBeNull();
+  });
+
+  it('should be initialized after setting entries', async () => {
+    await chromeStore.setEntries(mockEntries);
+    expect(chromeStore.isInitialized()).toBe(true);
+  });
+
+  it('should get entries', async () => {
+    (extendedStorageLocal.get as jest.Mock).mockImplementation(() => {
+      return Promise.resolve({ ['eppo-configuration']: JSON.stringify(mockEntries) });
+    });
+
+    const entries = await chromeStore.getEntries();
+    expect(entries).toEqual(mockEntries);
+  });
+});

src/chrome.configuration-store.ts

@@ -0,0 +1,33 @@
+import { IAsyncStore } from '@eppo/js-client-sdk-common';
+
+export class ChromeStorageAsyncStore<T> implements IAsyncStore<T> {
+  private chromeStorageKey = 'eppo-configuration';
+  private _isInitialized = false;
+
+  constructor(private storageArea: chrome.storage.StorageArea) {}
+
+  public isInitialized(): boolean {
+    return this._isInitialized;
+  }
+
+  public isExpired(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  public async getEntries(): Promise<Record<string, T> | null> {
+    const configuration = await this.storageArea.get(this.chromeStorageKey);
+    if (configuration?.[this.chromeStorageKey]) {
+      return Promise.resolve(JSON.parse(configuration[this.chromeStorageKey]));
+    }
+    return Promise.resolve(null);
+  }
+
+  public async setEntries(entries: Record<string, T>): Promise<void> {
+    // chrome.storage.set takes a dictionary of key-value pairs,
+    // so we need to pass it an object with a single property.
+    // writes the entire configuration to a single location.
+    await this.storageArea.set({ [this.chromeStorageKey]: JSON.stringify(entries) });
+    this._isInitialized = true;
+    return Promise.resolve();
+  }
+}

src/configuration-factory.spec.ts

@@ -0,0 +1,83 @@
+import { MemoryOnlyConfigurationStore, HybridConfigurationStore } from '@eppo/js-client-sdk-common';
+
+import { ChromeStorageAsyncStore } from './chrome.configuration-store';
+import { configurationStorageFactory } from './configuration-factory';
+import { LocalStorageBackedAsyncStore } from './local-storage';
+
+describe('configurationStorageFactory', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('forces a MemoryOnlyConfigurationStore', () => {
+    const result = configurationStorageFactory({ forceMemoryOnly: true });
+    expect(result).toBeInstanceOf(MemoryOnlyConfigurationStore);
+  });
+
+  it('is a provided persistentStore', () => {
+    const mockPersistentStore = {
+      get: jest.fn(),
+      set: jest.fn(),
+      isInitialized: jest.fn().mockReturnValue(true),
+      isExpired: jest.fn().mockReturnValue(false),
+      getEntries: jest.fn().mockReturnValue({}),
+      setEntries: jest.fn(),
+    };
+    const result = configurationStorageFactory({
+      persistentStore: mockPersistentStore,
+    });
+    expect(result).toBeInstanceOf(HybridConfigurationStore);
+    expect(result.persistentStore).toBe(mockPersistentStore);
+  });
+
+  it('is a HybridConfigurationStore with a ChromeStorageAsyncStore persistentStore when chrome storage is available', () => {
+    const mockChromeStorageLocal = {
+      get: jest.fn(),
+      set: jest.fn(),
+      remove: jest.fn(),
+      clear: jest.fn(),
+      getBytesInUse: jest.fn(),
+      setAccessLevel: jest.fn(),
+      onChanged: {
+        addListener: jest.fn(),
+        removeListener: jest.fn(),
+        hasListener: jest.fn(),
+        dispatch: jest.fn(),
+        getRules: jest.fn(),
+        removeRules: jest.fn(),
+        addRules: jest.fn(),
+        hasListeners: jest.fn(),
+      },
+    };
+
+    const result = configurationStorageFactory(
+      { hasChromeStorage: true },
+      { chromeStorage: mockChromeStorageLocal },
+    );
+    expect(result).toBeInstanceOf(HybridConfigurationStore);
+    expect(result.persistentStore).toBeInstanceOf(ChromeStorageAsyncStore);
+  });
+
+  it('is a HybridConfigurationStore with a LocalStorageBackedAsyncStore persistentStore when window local storage is available', () => {
+    const mockLocalStorage = {
+      clear: jest.fn(),
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+      key: jest.fn(),
+      length: 0,
+    };
+
+    const result = configurationStorageFactory(
+      { hasWindowLocalStorage: true },
+      { windowLocalStorage: mockLocalStorage },
+    );
+    expect(result).toBeInstanceOf(HybridConfigurationStore);
+    expect(result.persistentStore).toBeInstanceOf(LocalStorageBackedAsyncStore);
+  });
+
+  it('falls back to MemoryOnlyConfigurationStore when no persistence options are available', () => {
+    const result = configurationStorageFactory({});
+    expect(result).toBeInstanceOf(MemoryOnlyConfigurationStore);
+  });
+});

src/configuration-factory.ts

@@ -7,27 +7,52 @@ import {
   MemoryStore,
 } from '@eppo/js-client-sdk-common';
 
+import { ChromeStorageAsyncStore } from './chrome.configuration-store';
 import { LocalStorageBackedAsyncStore } from './local-storage';
 
 export function configurationStorageFactory(
-  persistenceStore?: IAsyncStore<Flag>,
-  forceMemoryOnly = false,
+  {
+    hasChromeStorage = false,
+    hasWindowLocalStorage = false,
+    persistentStore = undefined,
+    forceMemoryOnly = false,
+  }: {
+    hasChromeStorage?: boolean;
+    hasWindowLocalStorage?: boolean;
+    persistentStore?: IAsyncStore<Flag>;
+    forceMemoryOnly?: boolean;
+  },
+  {
+    chromeStorage,
+    windowLocalStorage,
+  }: { chromeStorage?: chrome.storage.StorageArea; windowLocalStorage?: Storage } = {},
 ): IConfigurationStore<Flag> {
   if (forceMemoryOnly) {
     return new MemoryOnlyConfigurationStore();
-  } else if (persistenceStore) {
-    return new HybridConfigurationStore(new MemoryStore<Flag>(), persistenceStore);
-  } else if (hasWindowLocalStorage()) {
-    // fallback to window.localStorage if available
+  } else if (persistentStore) {
+    return new HybridConfigurationStore(new MemoryStore<Flag>(), persistentStore);
+  } else if (hasChromeStorage) {
+    // Chrome storage is available, use it as a fallback
     return new HybridConfigurationStore(
       new MemoryStore<Flag>(),
-      new LocalStorageBackedAsyncStore<Flag>(window.localStorage),
+      new ChromeStorageAsyncStore<Flag>(chromeStorage),
+    );
+  } else if (hasWindowLocalStorage) {
+    // window.localStorage is available, use it as a fallback
+    return new HybridConfigurationStore(
+      new MemoryStore<Flag>(),
+      new LocalStorageBackedAsyncStore<Flag>(windowLocalStorage),
     );
   }
 
+  // No persistence store available, use memory only
   return new MemoryOnlyConfigurationStore();
 }
 
+export function hasChromeStorage(): boolean {
+  return typeof chrome !== 'undefined' && !!chrome.storage;
+}
+
 export function hasWindowLocalStorage(): boolean {
   try {
     return typeof window !== 'undefined' && !!window.localStorage;

src/index.ts

@@ -8,7 +8,11 @@ import {
   IAsyncStore,
 } from '@eppo/js-client-sdk-common';
 
-import { configurationStorageFactory } from './configuration-factory';
+import {
+  configurationStorageFactory,
+  hasChromeStorage,
+  hasWindowLocalStorage,
+} from './configuration-factory';
 import { LocalStorageAssignmentCache } from './local-storage-assignment-cache';
 import { sdkName, sdkVersion } from './sdk-data';
 
@@ -83,7 +87,7 @@ export interface IClientConfig {
 export { IAssignmentLogger, IAssignmentEvent, IEppoClient } from '@eppo/js-client-sdk-common';
 
 // Instantiate the configuration store with memory-only implementation.
-const configurationStore = configurationStorageFactory(undefined, true);
+const configurationStore = configurationStorageFactory({ forceMemoryOnly: true });
 
 /**
  * Client for assigning experiment variations.
@@ -169,7 +173,17 @@ export async function init(config: IClientConfig): Promise<IEppoClient> {
 
     // Set the configuration store to the desired persistent store, if provided.
     // Otherwise the factory method will detect the current environment and instantiate the correct store.
-    const configurationStore = configurationStorageFactory(config.persistentStore, false);
+    const configurationStore = configurationStorageFactory(
+      {
+        persistentStore: config.persistentStore,
+        hasChromeStorage: hasChromeStorage(),
+        hasWindowLocalStorage: hasWindowLocalStorage(),
+      },
+      {
+        chromeStorage: hasChromeStorage() && chrome.storage.local,
+        windowLocalStorage: hasWindowLocalStorage() && window.localStorage,
+      },
+    );
     EppoJSClient.instance.setConfigurationStore(configurationStore);
 
     const requestConfiguration: FlagConfigurationRequestParameters = {

yarn.lock

@@ -909,6 +909,14 @@
   dependencies:
     "@babel/types" "^7.3.0"
 
+"@types/chrome@^0.0.268":
+  version "0.0.268"
+  resolved "https://registry.yarnpkg.com/@types/chrome/-/chrome-0.0.268.tgz#d5855546f30c83e181cadd77127a162c25b480d2"
+  integrity sha512-7N1QH9buudSJ7sI8Pe4mBHJr5oZ48s0hcanI9w3wgijAlv1OZNUZve9JR4x42dn5lJ5Sm87V1JNfnoh10EnQlA==
+  dependencies:
+    "@types/filesystem" "*"
+    "@types/har-format" "*"
+
 "@types/eslint-scope@^3.7.3":
   version "3.7.4"
   resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.4.tgz#37fc1223f0786c39627068a12e94d6e6fc61de16"
@@ -935,13 +943,30 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.51.tgz#cfd70924a25a3fd32b218e5e420e6897e1ac4f40"
   integrity sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==
 
+"@types/filesystem@*":
+  version "0.0.36"
+  resolved "https://registry.yarnpkg.com/@types/filesystem/-/filesystem-0.0.36.tgz#7227c2d76bfed1b21819db310816c7821d303857"
+  integrity sha512-vPDXOZuannb9FZdxgHnqSwAG/jvdGM8Wq+6N4D/d80z+D4HWH+bItqsZaVRQykAn6WEVeEkLm2oQigyHtgb0RA==
+  dependencies:
+    "@types/filewriter" "*"
+
+"@types/filewriter@*":
+  version "0.0.33"
+  resolved "https://registry.yarnpkg.com/@types/filewriter/-/filewriter-0.0.33.tgz#d9d611db9d9cd99ae4e458de420eeb64ad604ea8"
+  integrity sha512-xFU8ZXTw4gd358lb2jw25nxY9QAgqn2+bKKjKOYfNCzN4DKCFetK7sPtrlpg66Ywe3vWY9FNxprZawAh9wfJ3g==
+
 "@types/graceful-fs@^4.1.3":
   version "4.1.5"
   resolved "https://registry.yarnpkg.com/@types/graceful-fs/-/graceful-fs-4.1.5.tgz#21ffba0d98da4350db64891f92a9e5db3cdb4e15"
   integrity sha512-anKkLmZZ+xm4p8JWBf4hElkM4XR+EZeA2M9BAkkTldmcyDY4mbdIJnRghDJH3Ov5ooY7/UAoENtmdMSkaAd7Cw==
   dependencies:
     "@types/node" "*"
 
+"@types/har-format@*":
+  version "1.2.15"
+  resolved "https://registry.yarnpkg.com/@types/har-format/-/har-format-1.2.15.tgz#f352493638c2f89d706438a19a9eb300b493b506"
+  integrity sha512-RpQH4rXLuvTXKR0zqHq3go0RVXYv/YVqv4TnPH95VbwUxZdQlK1EtcMvQvMpDngHbt13Csh9Z4qT9AbkiQH5BA==
+
 "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1":
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz#8467d4b3c087805d63580480890791277ce35c44"