@featbit/js-client-sdk 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featbit/js-client-sdk",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "https://github.com/featbit/featbit-js-client-sdk",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",

package/src/Configuration.ts

@@ -16,7 +16,6 @@ import { NullBootstrapProvider } from "./bootstrap/NullBootstrapProvider";
 import { EmptyString } from "./constants";
 import { DataSyncModeEnum } from "./data-sync/DataSyncMode";
 import { IUser } from "./options/IUser";
-import LocalStorageStore from "./platform/browser/LocalStorageStore";
 import { JsonBootstrapProvider } from "./bootstrap";
 
 // Once things are internal to the implementation of the SDK we can depend on
@@ -63,7 +62,7 @@ export const defaultValues: IValidatedOptions = {
   maxEventsInQueue: 10000,
   pollingInterval: 30000,
   offline: false,
-  store: (options: IOptions) => new LocalStorageStore(options),
+  store: (options: IOptions) => new InMemoryStore(),
   bootstrap: undefined,
   user: undefined,
 };

package/src/FbClientCore.ts

@@ -63,8 +63,6 @@ export class FbClientCore implements IFbClientCore {
 
   private initializedPromise?: Promise<IFbClientCore>;
 
-  private logger?: ILogger;
-
   private config: Configuration;
 
   private dataSourceUpdates?: DataSourceUpdates;
@@ -75,6 +73,8 @@ export class FbClientCore implements IFbClientCore {
 
   private onReady: () => void;
 
+  logger?: ILogger;
+
   constructor(
     private options: IOptions,
     private platform: IPlatform,
@@ -104,7 +104,7 @@ export class FbClientCore implements IFbClientCore {
   private async init(platform: IPlatform, onUpdate: (keys: string[]) => void, hasEventListeners: () => boolean) {
     const clientContext = new ClientContext(this.config.sdkKey, this.config, platform);
     this.store = this.config.storeFactory(clientContext);
-    this.store.identify(this.config.user);
+    await this.store.identify(this.config.user);
     this.dataSourceUpdates = new DataSourceUpdates(this.store, hasEventListeners, onUpdate);
     this.evaluator = new Evaluator(this.store);
 

package/src/data-sources/DataSourceUpdates.ts

@@ -27,24 +27,22 @@ export default class DataSourceUpdates implements IDataSourceUpdates {
     }
 
     const checkForChanges = this.hasEventListeners();
-    const doInit = (oldData?: IStoreDataStorage) => {
-      this.store.init(allData, () => {
-        // Defer change events so they execute after the callback.
-        Promise.resolve().then(() => {
-          if (checkForChanges) {
-            const updatedKeys = Object.keys(allData)
-              .flatMap((namespace) => {
-                const oldDataForKind = oldData?.[namespace] || {};
-                const newDataForKind = allData[namespace];
-                const mergedData = {...oldDataForKind, ...newDataForKind};
-                return Object.keys(mergedData)
-                  .filter((key: string) => this.isUpdated(oldDataForKind && oldDataForKind[key], newDataForKind && newDataForKind[key]));
-              });
-            updatedKeys.length > 0 && this.onChange(updatedKeys);
-          }
-        });
-        callback?.();
+    const doInit = async (oldData?: IStoreDataStorage) => {
+      await this.store.init(allData);
+      Promise.resolve().then(() => {
+        if (checkForChanges) {
+          const updatedKeys = Object.keys(allData)
+            .flatMap((namespace) => {
+              const oldDataForKind = oldData?.[namespace] || {};
+              const newDataForKind = allData[namespace];
+              const mergedData = {...oldDataForKind, ...newDataForKind};
+              return Object.keys(mergedData)
+                .filter((key: string) => this.isUpdated(oldDataForKind && oldDataForKind[key], newDataForKind && newDataForKind[key]));
+            });
+          updatedKeys.length > 0 && this.onChange(updatedKeys);
+        }
       });
+      callback?.();
     };
 
     if (checkForChanges) {
@@ -67,17 +65,15 @@ export default class DataSourceUpdates implements IDataSourceUpdates {
 
     const {key} = data;
     const checkForChanges = this.hasEventListeners();
-    const doUpsert = (oldItem?: IStoreItem) => {
-      this.store.upsert(kind, data, () => {
-        // Defer change events so they execute after the callback.
-        Promise.resolve().then(() => {
-          if (checkForChanges && this.isUpdated(oldItem, data[key])) {
-            this.onChange([key]);
-          }
-        });
-
-        callback?.();
+    const doUpsert = async (oldItem?: IStoreItem) => {
+      await this.store.upsert(kind, data);
+      Promise.resolve().then(() => {
+        if (checkForChanges && this.isUpdated(oldItem, data[key])) {
+          this.onChange([key]);
+        }
       });
+
+      callback?.();
     };
     if (checkForChanges) {
       const item = this.store.get(kind, key);

package/src/index.ts

@@ -18,4 +18,5 @@ export * from './IContextProperty';
 export * from './IDataKind';
 export * from './IFbClient';
 export * from './IVersionedData';
+export * from './FbClientCore';
 

package/src/logging/SafeLogger.ts

@@ -18,7 +18,7 @@ const loggerRequirements = {
  * message to the SDK's default logger, and we can at least partly guard against the latter by
  * checking for the presence of required methods at configuration time.
  */
-export default class SafeLogger implements ILogger {
+export class SafeLogger implements ILogger {
   private logger: ILogger;
 
   private fallback: ILogger;

package/src/platform/IInfo.ts

@@ -1,3 +1,18 @@
+export interface IFbDevice {
+  manufacturer?: string;
+  model?: string;
+  storageBytes?: string;
+  memoryBytes?: string;
+  os?: {
+    /**
+     * The family of operating system.
+     */
+    family?: string;
+    name?: string;
+    version?: string;
+  };
+}
+
 /**
  * Information about the platform of the SDK and the environment it is executing.
  */
@@ -31,6 +46,12 @@ export interface IPlatformData {
    * Any additional attributes associated with the platform.
    */
   additional?: Record<string, string>;
+
+  /**
+   * Device hardware information. Should be populated when available. Not all
+   * platforms will have this data.
+   */
+  fbDevice?: IFbDevice;
 }
 
 export interface ISdkData {

package/src/platform/IStore.ts

@@ -24,7 +24,7 @@ export interface IStore {
    *   The current user. The actual type of this parameter is
    *   {@link IUser}.
    */
-  identify(user: IUser): void;
+  identify(user: IUser): Promise<void>;
 
   /**
    * Get the current user of the store.
@@ -66,11 +66,8 @@ export interface IStore {
    *   An object in which each key is the "namespace" of a collection (e.g. `"features"`) and
    *   the value is an object that maps keys to entities. The actual type of this parameter is
    *   `interfaces.FullDataSet<VersionedData>`.
-   *
-   * @param callback
-   *   Will be called when the store has been initialized.
    */
-  init(allData: IStoreDataStorage, callback: () => void): void;
+  init(allData: IStoreDataStorage): Promise<void>;
 
   /**
    * Add an entity or update an existing entity.
@@ -84,11 +81,8 @@ export interface IStore {
    *   should check the `version` property of this object, and should *not* overwrite any
    *   existing data if the existing `version` is greater than or equal to that value.
    *   The actual type of this parameter is {@link IKeyedStoreItem}.
-   *
-   * @param callback
-   *   Will be called after the upsert operation is complete.
    */
-  upsert(kind: IDataKind, data: IKeyedStoreItem, callback: () => void): void;
+  upsert(kind: IDataKind, data: IKeyedStoreItem): Promise<void>;
 
   /**
    * Tests whether the store is initialized.

package/src/platform/browser/BrowserPlatform.ts

@@ -3,7 +3,7 @@ import { IInfo } from "../IInfo";
 import { IRequests } from "../requests";
 import { IOptions } from "../../options/IOptions";
 import BrowserInfo from "./BrowserInfo";
-import BrowserRequests from "./BrowserRequests";
+import { BrowserRequests } from "./BrowserRequests";
 import { IWebSocketWithEvents } from "../IWebSocket";
 import BrowserWebSocket from "./BrowserWebSocket";
 

package/src/platform/browser/BrowserRequests.ts

@@ -1,6 +1,6 @@
 import { IRequestOptions, IRequests } from "../requests";
 
-export default class BrowserRequests implements IRequests {
+export  class BrowserRequests implements IRequests {
   fetch(url: string, options: IRequestOptions = {}): Promise<any> {
     return fetch(url, options);
   }

package/src/platform/browser/FbClient.ts

@@ -2,10 +2,11 @@ import { FbClientCore } from "../../FbClientCore";
 import { IOptions } from "../../options/IOptions";
 import { BasicLogger } from "../../logging/BasicLogger";
 import { EventEmitter } from "../../utils/EventEmitter";
-import SafeLogger from "../../logging/SafeLogger";
+import { SafeLogger } from "../../logging/SafeLogger";
 import { Emits } from "../../utils/Emits";
 import { IEventEmitter } from "../../utils/IEventEmitter";
 import BrowserPlatform from "./BrowserPlatform";
+import LocalStorageStore from "./LocalStorageStore";
 
 /**
  * @ignore
@@ -23,8 +24,13 @@ class FbClient extends FbClientCore {
 
     const emitter = new EventEmitter(logger);
 
+    let { store } = options;
+    if (!store) {
+      store = new LocalStorageStore(options);
+    }
+
     super(
-      {...options, logger},
+      {...options, logger, store },
       new BrowserPlatform({...options, logger}),
       {
         onError: (err: Error) => {

package/src/platform/browser/LocalStorageStore.ts

@@ -1,134 +1,41 @@
-import { IDataKind } from "../../IDataKind";
 import {
   StoreStorageKey,
-  IKeyedStoreItem,
-  IStoreDataStorage,
-  IStoreItem,
-  IStoreKindData,
-  CurrentUserStorageKey
+  IStoreDataStorage, CurrentUserStorageKey
 } from "../../store/store";
-import { IStore } from "../../platform/IStore";
-import { IUser } from "../../options/IUser";
-import { ILogger } from "../../logging/ILogger";
 import { IOptions } from "../../options/IOptions";
+import { BaseStore } from "../../store/BaseStore";
+import { ILogger } from "../../logging";
 import { serializeUser } from "../../utils/serializeUser";
 
-export default class LocalStorageStore implements IStore {
-  private store: IStoreDataStorage  = {} as IStoreDataStorage;
-
-  private initCalled = false;
-
-  private _user: IUser = {} as IUser;
-
+export default class LocalStorageStore extends BaseStore {
   private logger: ILogger;
 
   constructor(options: IOptions) {
-    this.logger = options.logger!;
-  }
-
-  identify(user: IUser) {
-    this._user = {...user};
-
-    localStorage.setItem(CurrentUserStorageKey, serializeUser(this._user));
-    this.loadStoreFromStorage();
-  }
-
-  get user(): IUser {
-    return this._user;
-  }
-
-  private addItem(kind: IDataKind, key: string, item: IStoreItem) {
-    let items = this.store[kind.namespace];
-    if (!items) {
-      items = {};
-      this.store[kind.namespace] = items;
-    }
-    if (Object.hasOwnProperty.call(items, key)) {
-      const old = items[key];
-      if (!old || old.version < item.version) {
-        items[key] = item;
-      }
-    } else {
-      items[key] = item;
-    }
-
-    if (item.version > this.store.version) {
-      this.store.version = item.version;
-    }
+    super();
 
-    this.dumpStoreToStorage();
-  }
-
-  get(kind: IDataKind, key: string): IStoreItem | null {
-    const items = this.store[kind.namespace];
-    if (items) {
-      if (Object.prototype.hasOwnProperty.call(items, key)) {
-        const item = items[key];
-        if (item) {
-          return item;
-        }
-      }
-    }
-    return null;
-  }
-
-  all(kind: IDataKind): [IStoreKindData, number] {
-    const result: IStoreKindData = {};
-    const items = this.store[kind.namespace] ?? {};
-    Object.entries(items).forEach(([key, item]) => {
-      if (item) {
-        result[key] = <IStoreItem>item;
-      }
-    });
-
-    return [result, this.store.version];
-  }
-
-  init(allData: IStoreDataStorage, callback: () => void): void {
-    this.store = allData as IStoreDataStorage;
-
-    Object.keys(allData).map(namespace => {
-      Object.entries(allData[namespace]).forEach(([_, item]) => {
-        const ele = item as IStoreItem;
-        if (ele.version > this.store.version) {
-          this.store.version = ele.version;
-        }
-      })
-    });
-
-    this.dumpStoreToStorage();
-    this.initCalled = true;
-    callback?.();
-  }
-
-  upsert(kind: IDataKind, data: IKeyedStoreItem, callback: () => void): void {
-    this.addItem(kind, data.key, data);
-    callback?.();
-  }
-
-  initialized(): boolean {
-    return this.initCalled;
+    this.logger = options.logger!;
   }
 
   /* eslint-disable class-methods-use-this */
   close(): void {
-    // For the memory store this is a no-op.
+    // For the LocalStorage store this is a no-op.
   }
 
-  getDescription(): string {
+  get description(): string {
     return 'local-storage-store'
   }
 
-  get version(): number {
-    return this.store.version;
+  // This method needs to be overridden in the child class
+  protected async saveUser(): Promise<void> {
+    localStorage.setItem(CurrentUserStorageKey, serializeUser(this._user));
   }
 
-  private dumpStoreToStorage(): void {
+  protected override async dumpStoreToStorage() {
     const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
     localStorage.setItem(storageKey, JSON.stringify(this.store));
   }
 
-  private loadStoreFromStorage(): void {
+  protected override async loadStoreFromStorage() {
     const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
     const dataStoreStr = localStorage.getItem(storageKey);
     let store: IStoreDataStorage | null = null;

package/src/platform/index.ts

@@ -1,4 +1,12 @@
 export * from './IInfo';
+export * from './IStore';
 export * from './IPlatform';
 export * from './IWebSocket';
-export * from './requests';
+export * from './requests';
+export * from './browser/BrowserRequests';
+
+import BrowserWebSocket from './browser/BrowserWebSocket';
+
+export {
+  BrowserWebSocket
+};

package/src/store/BaseStore.ts

@@ -0,0 +1,123 @@
+import { IStore } from "../platform";
+import { IKeyedStoreItem, IStoreDataStorage, IStoreItem, IStoreKindData } from "./store";
+import { IUser } from "../options";
+import { IDataKind } from "../IDataKind";
+
+export class BaseStore implements IStore {
+  protected store: IStoreDataStorage  = {} as IStoreDataStorage;
+
+  protected initCalled = false;
+
+  protected _user: IUser = {} as IUser;
+
+  constructor() {
+  }
+
+  async identify(user: IUser) {
+    this._user = {...user};
+
+    await this.saveUser();
+    await this.loadStoreFromStorage();
+  }
+
+  get user(): IUser {
+    return this._user;
+  }
+
+  protected async addItem(kind: IDataKind, key: string, item: IStoreItem) {
+    let items = this.store[kind.namespace];
+    if (!items) {
+      items = {};
+      this.store[kind.namespace] = items;
+    }
+    if (Object.hasOwnProperty.call(items, key)) {
+      const old = items[key];
+      if (!old || old.version < item.version) {
+        items[key] = item;
+      }
+    } else {
+      items[key] = item;
+    }
+
+    if (item.version > this.store.version) {
+      this.store.version = item.version;
+    }
+
+    await this.dumpStoreToStorage();
+  }
+
+  get(kind: IDataKind, key: string): IStoreItem | null {
+    const items = this.store[kind.namespace];
+    if (items) {
+      if (Object.prototype.hasOwnProperty.call(items, key)) {
+        const item = items[key];
+        if (item) {
+          return item;
+        }
+      }
+    }
+    return null;
+  }
+
+  all(kind: IDataKind): [IStoreKindData, number] {
+    const result: IStoreKindData = {};
+    const items = this.store[kind.namespace] ?? {};
+    Object.entries(items).forEach(([key, item]) => {
+      if (item) {
+        result[key] = <IStoreItem>item;
+      }
+    });
+
+    return [result, this.store.version];
+  }
+
+  async init(allData: IStoreDataStorage) {
+    this.store = allData as IStoreDataStorage;
+
+    Object.keys(allData).map(namespace => {
+      Object.entries(allData[namespace]).forEach(([_, item]) => {
+        const ele = item as IStoreItem;
+        if (ele.version > this.store.version) {
+          this.store.version = ele.version;
+        }
+      })
+    });
+
+    await this.dumpStoreToStorage();
+    this.initCalled = true;
+  }
+
+  async upsert(kind: IDataKind, data: IKeyedStoreItem) {
+    await this.addItem(kind, data.key, data);
+  }
+
+  initialized(): boolean {
+    return this.initCalled;
+  }
+
+  /* eslint-disable class-methods-use-this */
+  close(): void {
+    // For the LocalStorage store this is a no-op.
+  }
+
+  get version(): number {
+    return this.store.version;
+  }
+
+  // This getter needs to be overridden in the child class
+  get description(): string {
+    return '';
+  }
+
+  // This method needs to be overridden in the child class
+  protected async saveUser(): Promise<void> {
+  }
+
+  // This method needs to be overridden in the child class
+  protected async loadStoreFromStorage(): Promise<void> {
+  }
+
+  // This method needs to be overridden in the child class
+  protected async dumpStoreToStorage(): Promise<void> {
+  }
+}

package/src/store/InMemoryStore.ts

@@ -1,115 +1,37 @@
-import { IDataKind } from "../IDataKind";
-import { StoreStorageKey, IKeyedStoreItem, IStoreDataStorage, IStoreItem, IStoreKindData } from "./store";
-import { IStore } from "../platform/IStore";
-import { IUser } from "../options/IUser";
-import { IOptions } from "../options/IOptions";
-
-export default class InMemoryStore implements IStore {
+import {
+  StoreStorageKey,
+  IStoreDataStorage
+} from "./store";
+import { BaseStore } from "./BaseStore";
 
+export default class InMemoryStore extends BaseStore {
   private allStores: { [DataStoreStorageKey: string]: IStoreDataStorage } = {};
 
-  private store: IStoreDataStorage  = {} as IStoreDataStorage;
-
-  private initCalled = false;
-
-  private _user: IUser = {} as IUser;
-
-  constructor(options: IOptions) {}
-
-  identify(user: IUser) {
-    this._user = {...user};
-
-    this.store = this.allStores[`${StoreStorageKey}-${this._user.keyId}`] ?? { flags: {}, version: 0 };
-  }
-
-  get user(): IUser {
-    return this._user;
-  }
-
-  private addItem(kind: IDataKind, key: string, item: IStoreItem) {
-    let items = this.store[kind.namespace];
-    if (!items) {
-      items = {};
-      this.store[kind.namespace] = items;
-    }
-    if (Object.hasOwnProperty.call(items, key)) {
-      const old = items[key];
-      if (!old || old.version < item.version) {
-        items[key] = item;
-      }
-    } else {
-      items[key] = item;
-    }
-
-    if (item.version > this.store.version) {
-      this.store.version = item.version;
-    }
-
-    this.allStores[`${StoreStorageKey}-${this._user.keyId}`] = {...this.store};
+  constructor() {
+    super();
   }
 
-  get(kind: IDataKind, key: string): IStoreItem | null {
-    const items = this.store[kind.namespace];
-    if (items) {
-      if (Object.prototype.hasOwnProperty.call(items, key)) {
-        const item = items[key];
-        if (item) {
-          return item;
-        }
-      }
-    }
-    return null;
-  }
-
-  all(kind: IDataKind): [IStoreKindData, number] {
-    const result: IStoreKindData = {};
-    const items = this.store[kind.namespace] ?? {};
-    Object.entries(items).forEach(([key, item]) => {
-      if (item) {
-        result[key] = <IStoreItem>item;
-      }
-    });
-
-    return [result, this.store.version];
-  }
-
-  init(allData: IStoreDataStorage, callback: () => void): void {
-    this.store = allData as IStoreDataStorage;
-
-    this.store.version = 0;
-    Object.keys(allData).map(namespace => {
-      Object.entries(allData[namespace]).forEach(([_, item]) => {
-        const ele = item as IStoreItem;
-        if (ele.version > this.store.version) {
-          this.store.version = ele.version;
-        }
-      })
-    });
-
-    this.allStores[`${StoreStorageKey}-${this._user.keyId}`] = {...this.store};
-    this.initCalled = true;
-    callback?.();
+  /* eslint-disable class-methods-use-this */
+  close(): void {
+    // For the LocalStorage store this is a no-op.
   }
 
-  upsert(kind: IDataKind, data: IKeyedStoreItem, callback: () => void): void {
-    this.addItem(kind, data.key, data);
-    callback?.();
+  get description(): string {
+    return 'in-memory-store'
   }
 
-  initialized(): boolean {
-    return this.initCalled;
+  protected async saveUser(): Promise<void> {
+    // For in-memory store, this is a no-op.
   }
 
-  /* eslint-disable class-methods-use-this */
-  close(): void {
-    // For the memory store this is a no-op.
+  protected override async dumpStoreToStorage() {
+    const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
+    this.allStores[storageKey] = {...this.store};
   }
 
-  getDescription(): string {
-    return 'in-memory-store';
-  }
+  protected override async loadStoreFromStorage() {
+    const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
 
-  get version(): number {
-    return this.store.version;
+    this.store = this.allStores[storageKey] ?? { flags: {}, version: 0 };
   }
 }

package/src/store/index.ts

@@ -2,4 +2,5 @@ export * from './DataKinds';
 export * from './IDataSourceUpdates';
 export * from './InMemoryStore';
 export * from './serialization';
-export * from './store';
+export * from './store';
+export * from './BaseStore';