@featbit/js-client-sdk 2.0.2 → 3.0.1

package/src/platform/browser/BrowserPlatform.ts

@@ -0,0 +1,20 @@
+import { IPlatform } from "../IPlatform";
+import { IInfo } from "../IInfo";
+import { IRequests } from "../requests";
+import { IOptions } from "../../options/IOptions";
+import BrowserInfo from "./BrowserInfo";
+import { BrowserRequests } from "./BrowserRequests";
+import { IWebSocketWithEvents } from "../IWebSocket";
+import BrowserWebSocket from "./BrowserWebSocket";
+
+export default class BrowserPlatform implements IPlatform {
+  info: IInfo = new BrowserInfo();
+
+  requests: IRequests;
+  webSocket: IWebSocketWithEvents;
+
+  constructor(options: IOptions) {
+    this.requests = new BrowserRequests();
+    this.webSocket = new BrowserWebSocket();
+  }
+}

package/src/platform/browser/BrowserRequests.ts

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

package/src/platform/browser/BrowserWebSocket.ts

@@ -0,0 +1,143 @@
+import { IWebSocket, IWebSocketConfig } from "../IWebSocket";
+import { Emits } from "../../utils/Emits";
+import { IEventEmitter } from "../../utils/IEventEmitter";
+import { EventEmitter } from "../../utils/EventEmitter";
+import { generateConnectionToken } from "../../data-sync/utils";
+import { StreamResponseEventType } from "../../data-sync/types";
+import { IUser } from "../../options/IUser";
+
+const socketConnectionIntervals = [1000, 3000, 5000, 7000, 11000, 13000, 30000, 60000];
+
+class BrowserWebSocket implements IWebSocket {
+  emitter: IEventEmitter;
+  private ws?: WebSocket;
+  private retryCounter = 0;
+  private closed: boolean = false;
+
+  private _config: IWebSocketConfig = {} as IWebSocketConfig;
+
+  constructor() {
+    this.emitter = new EventEmitter();
+  }
+
+  identify(user: IUser) {
+    this._config.user = user;
+    this.doDataSync();
+  }
+
+  connect() {
+    let that = this;
+    const startTime = Date.now();
+    const url = this._config.streamingUri.replace(/^http/, 'ws') + `?type=client&token=${ generateConnectionToken(this._config.sdkKey) }`;
+    this.ws = new WebSocket(url);
+
+    // Connection opened
+    that.ws?.addEventListener('open', function (this: WebSocket, event) {
+      // this is the websocket instance to which the current listener is binded to, it's different from that.socket
+      that._config.logger.info(`WebSocket connection succeeded, connection time: ${ Date.now() - startTime } ms`);
+      that.doDataSync();
+      that.sendPingMessage();
+    });
+
+    // Connection closed
+    that.ws?.addEventListener('close', function (event) {
+      that._config.logger.warn('WebSocket closed');
+      if (event.code === 4003) { // do not reconnect when 4003
+        return;
+      }
+
+      that.reconnect();
+    });
+
+    // Connection error
+    that.ws?.addEventListener('error', function (event) {
+      // reconnect
+      that._config.logger.debug('error');
+    });
+
+    // Listen for messages
+    that.ws?.addEventListener('message', function (event) {
+      const message = JSON.parse(event.data as string);
+      if (message.messageType === 'data-sync') {
+        switch (message.data.eventType) {
+          case StreamResponseEventType.patch:
+            that.emitter.emit('patch', message);
+            break;
+          case StreamResponseEventType.full:
+            that.emitter.emit('put', message);
+            break;
+        }
+      }
+    });
+  }
+
+  close() {
+    this.closed = true;
+    this.ws?.close(4003, 'The client is closed by user');
+    this.ws = undefined;
+  }
+
+  config(param: IWebSocketConfig) {
+    if (param.emitter) {
+      this.emitter = param.emitter;
+    }
+
+    this._config = {...param};
+  }
+
+  private sendPingMessage() {
+    const payload = {
+      messageType: 'ping',
+      data: null
+    };
+
+    setTimeout(() => {
+      try {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this._config.logger.debug('sending ping')
+          this.ws.send(JSON.stringify(payload));
+          this.sendPingMessage();
+        } else {
+          this._config.logger.debug(`socket closed at ${ new Date() }`);
+        }
+      } catch (err) {
+        this._config.logger.debug(err);
+      }
+    }, this._config.pingInterval);
+  }
+
+  private doDataSync() {
+    const payload = {
+      messageType: 'data-sync',
+      data: {
+        timestamp: this._config.getStoreTimestamp(),
+        user: this._config.user
+      }
+    };
+
+    try {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this._config.logger.debug('requesting data');
+        this.ws?.send(JSON.stringify(payload));
+      } else {
+        this._config.logger.error(`not requesting data because socket not open`);
+      }
+    } catch (err) {
+      this._config.logger.debug(err);
+    }
+  }
+
+  private reconnect() {
+    if (!this.closed) {
+      this.ws = undefined;
+      const waitTime = socketConnectionIntervals[Math.min(this.retryCounter++, socketConnectionIntervals.length - 1)];
+      this._config.logger.info(`The client will try to reconnect in ${ waitTime } milliseconds.`);
+      setTimeout(() => {
+        this._config.logger.info(`The client is trying to reconnect, flag evaluation results may be stale until reconnected, waited for: ${ waitTime } milliseconds`);
+        this.connect();
+      }, waitTime);
+    }
+  }
+}
+
+export default Emits(BrowserWebSocket);

package/src/platform/browser/FbClient.ts

@@ -0,0 +1,65 @@
+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 { Emits } from "../../utils/Emits";
+import { IEventEmitter } from "../../utils/IEventEmitter";
+import BrowserPlatform from "./BrowserPlatform";
+import LocalStorageStore from "./LocalStorageStore";
+
+/**
+ * @ignore
+ */
+class FbClient extends FbClientCore {
+  emitter: IEventEmitter;
+
+  constructor(options: IOptions) {
+    const fallbackLogger = new BasicLogger({
+      level: 'none',
+      destination: console.log
+    });
+
+    const logger = options.logger ? new SafeLogger(options.logger, fallbackLogger) : fallbackLogger;
+
+    const emitter = new EventEmitter(logger);
+
+    let { store } = options;
+    if (!store) {
+      store = new LocalStorageStore(options);
+    }
+
+    super(
+      {...options, logger, store },
+      new BrowserPlatform({...options, logger}),
+      {
+        onError: (err: Error) => {
+          if (emitter.listenerCount('error')) {
+            emitter.emit('error', err);
+          }
+        },
+        onFailed: (err: Error) => {
+          emitter.emit('failed', err);
+        },
+        onReady: () => {
+          emitter.emit('ready');
+        },
+        onUpdate: (keys: string[]) => {
+          emitter.emit('update', [keys]);
+          keys.forEach((key) => emitter.emit(`update:${ key }`, key));
+        },
+        hasEventListeners: () =>
+          emitter
+            .eventNames()
+            .some(
+              (name) =>
+                name === 'update' || (typeof name === 'string' && name.startsWith('update:')),
+            ),
+      },
+    );
+
+    this.emitter = emitter;
+  }
+}
+
+export default Emits(FbClient);

package/src/platform/browser/LocalStorageStore.ts

@@ -0,0 +1,60 @@
+import {
+  StoreStorageKey,
+  IStoreDataStorage, CurrentUserStorageKey
+} from "../../store/store";
+import { IOptions } from "../../options/IOptions";
+import { BaseStore } from "../../store/BaseStore";
+import { ILogger } from "../../logging";
+import { serializeUser } from "../../utils/serializeUser";
+
+export default class LocalStorageStore extends BaseStore {
+  private logger: ILogger;
+
+  constructor(options: IOptions) {
+    super();
+
+    this.logger = options.logger!;
+  }
+
+  /* eslint-disable class-methods-use-this */
+  close(): void {
+    // For the LocalStorage store this is a no-op.
+  }
+
+  get description(): string {
+    return 'local-storage-store'
+  }
+
+  // This method needs to be overridden in the child class
+  protected async saveUser(): Promise<void> {
+    localStorage.setItem(CurrentUserStorageKey, serializeUser(this._user));
+  }
+
+  protected override async dumpStoreToStorage() {
+    const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
+    localStorage.setItem(storageKey, JSON.stringify(this.store));
+  }
+
+  protected override async loadStoreFromStorage() {
+    const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
+    const dataStoreStr = localStorage.getItem(storageKey);
+    let store: IStoreDataStorage | null = null;
+
+    try {
+      if (dataStoreStr && dataStoreStr.trim().length > 0) {
+        store = JSON.parse(dataStoreStr);
+      }
+    } catch (err) {
+      this.logger.error(`error while loading local data store: ${storageKey}`, err);
+    }
+
+    if (!!store) {
+      this.store = store;
+    } else {
+      this.store = {
+        flags: {},
+        version: 0
+      };
+    }
+  }
+}

package/src/platform/index.ts

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

package/src/platform/requests.ts

@@ -0,0 +1,77 @@
+// These are not full specifications of the interface, but instead subsets
+// based on the functionality needed by the SDK. Exposure of the full standard
+// would require much more per platform implementation for platforms that do not
+// natively support fetch.
+
+/**
+ * Interface for headers that are part of a fetch response.
+ */
+export interface IHeaders {
+  /**
+   * Get a header by name.
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
+   *
+   * @param name The name of the header to get.
+   */
+  get(name: string): string | null;
+
+  /**
+   * Returns an iterator allowing iteration of all the keys contained
+   * in this object.
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/API/Headers/keys
+   *
+   */
+  keys(): Iterable<string>;
+
+  /**
+   * Returns an iterator allowing iteration of all the values contained
+   * in this object.
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/API/Headers/values
+   */
+  values(): Iterable<string>;
+
+  /**
+   * Returns an iterator allowing iteration of all the key-value pairs in
+   * the object.
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/API/Headers/entries
+   */
+  entries(): Iterable<[string, string]>;
+
+  /**
+   * Returns true if the header is present.
+   * @param name The name of the header to check.
+   */
+  has(name: string): boolean;
+}
+
+/**
+ * Interface for fetch responses.
+ */
+export interface IResponse {
+  status: number;
+
+  /**
+   * Read the response and provide it as a string.
+   */
+  text(): Promise<string>;
+
+  /**
+   * Read the response and provide it as decoded json.
+   */
+  json(): Promise<any>;
+}
+
+export interface IRequestOptions {
+  headers?: Record<string, string>;
+  method?: string;
+  body?: string;
+  timeout?: number;
+}
+
+export interface IRequests {
+  fetch(url: string, options?: IRequestOptions): Promise<IResponse>;
+}

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/DataKinds.ts

@@ -0,0 +1,7 @@
+import { IDataKind } from "../IDataKind";
+
+export default class DataKinds {
+  static readonly Flags: IDataKind = {
+    namespace: 'flags'
+  };
+}

package/src/store/IDataSourceUpdates.ts

@@ -0,0 +1,49 @@
+import { IDataKind } from "../IDataKind";
+import { IStoreDataStorage, IKeyedStoreItem } from "./store";
+
+/**
+ * Interface that a data source implementation will use to push data into the SDK.
+ *
+ * The data source interacts with this object, rather than manipulating the data store directly, so
+ * that the SDK can perform any other necessary operations that must happen when data is updated.
+ */
+export interface IDataSourceUpdates {
+  /**
+   * Completely overwrites the current contents of the data store with a set of items for each
+   * collection.
+   *
+   * @param userKeyId
+   *  The key ID of the user whose data is being updated.
+   *
+   * @param allData
+   *   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(userKeyId: string, allData: IStoreDataStorage, callback?: () => void): void;
+
+  /**
+   * Updates or inserts an item in the specified collection. For updates, the object will only be
+   * updated if the existing version is less than the new version.
+   *
+   * @param userKeyId
+   *  The key ID of the user whose data is being updated.
+   *
+   * @param kind
+   *   The type of data to be accessed. The actual type of this parameter is
+   *   {@link IDataKind}.
+   *
+   * @param data
+   *   The contents of the entity, as an object that can be converted to JSON. The store
+   *   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(userKeyId: string, kind: IDataKind, data: IKeyedStoreItem, callback: () => void): void;
+}

package/src/store/InMemoryStore.ts

@@ -0,0 +1,37 @@
+import {
+  StoreStorageKey,
+  IStoreDataStorage
+} from "./store";
+import { BaseStore } from "./BaseStore";
+
+export default class InMemoryStore extends BaseStore {
+  private allStores: { [DataStoreStorageKey: string]: IStoreDataStorage } = {};
+
+  constructor() {
+    super();
+  }
+
+  /* eslint-disable class-methods-use-this */
+  close(): void {
+    // For the LocalStorage store this is a no-op.
+  }
+
+  get description(): string {
+    return 'in-memory-store'
+  }
+
+  protected async saveUser(): Promise<void> {
+    // For in-memory store, this is a no-op.
+  }
+
+  protected override async dumpStoreToStorage() {
+    const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
+    this.allStores[storageKey] = {...this.store};
+  }
+
+  protected override async loadStoreFromStorage() {
+    const storageKey = `${StoreStorageKey}-${this._user.keyId}`;
+
+    this.store = this.allStores[storageKey] ?? { flags: {}, version: 0 };
+  }
+}

package/src/store/index.ts

@@ -0,0 +1,6 @@
+export * from './DataKinds';
+export * from './IDataSourceUpdates';
+export * from './InMemoryStore';
+export * from './serialization';
+export * from './store';
+export * from './BaseStore';

package/src/store/serialization.ts

@@ -0,0 +1,52 @@
+import { IFlag } from "../evaluation/data/IFlag";
+import DataKinds from "./DataKinds";
+import { IVersionedData } from "../IVersionedData";
+import { IDataKind } from "../IDataKind";
+
+export interface Flags {
+  flags: { [name: string]: IFlag };
+}
+
+type VersionedFlag = IVersionedData & IFlag;
+
+export interface IPatchData {
+  data: VersionedFlag;
+  kind: IDataKind;
+}
+
+/**
+ * @internal
+ */
+export function deserializeAll(flags: IFlag[]): Flags {
+  const result = {
+    [DataKinds.Flags.namespace]: {}
+  };
+
+  if (flags?.length) {
+    result[DataKinds.Flags.namespace] = flags.reduce((acc: any, cur: any) => {
+      acc[cur.id] = {...cur, version: cur.timestamp || 0, key: cur.id, variations: cur.variationOptions};
+      return acc;
+    }, {});
+  }
+
+  return result as any as Flags;
+}
+
+/**
+ * @internal
+ */
+export function deserializePatch(flags: IFlag[]): IPatchData[] {
+  const result = [
+    ...flags?.map(item => ({
+      data: {
+        ...item,
+        version:item.timestamp,
+        key: item.id,
+        variations: item.variationOptions
+      },
+      kind: DataKinds.Flags
+    })) || []
+  ];
+
+  return result as any as IPatchData[];
+}