@featurevisor/sdk 0.12.1 → 0.14.0

package/src/createInstance.ts

@@ -1,6 +1,7 @@
 import { DatafileContent, Attributes } from "@featurevisor/types";
 import { FeaturevisorSDK, ConfigureBucketValue, ActivationCallback } from "./client";
 import { createLogger, Logger } from "./logger";
+import { Emitter } from "./emitter";
 
 export type ReadyCallback = () => void;
 
@@ -21,6 +22,8 @@ export interface InstanceOptions {
   onUpdate?: () => void;
 }
 
+export type Event = "ready" | "refresh" | "update" | "activation";
+
 // @TODO: consider renaming it to FeaturevisorSDK in next breaking semver
 export interface FeaturevisorInstance {
   /**
@@ -54,9 +57,18 @@ export interface FeaturevisorInstance {
    * Additions
    */
   setLogLevels: Logger["setLevels"];
+
   refresh: () => void;
   startRefreshing: () => void;
   stopRefreshing: () => void;
+
+  addListener: Emitter["addListener"];
+  on: Emitter["addListener"];
+  removeListener: Emitter["removeListener"];
+  off: Emitter["removeListener"];
+  removeAllListeners: Emitter["removeAllListeners"];
+
+  isReady: () => boolean;
 }
 
 function fetchDatafileContent(datafileUrl, options: InstanceOptions): Promise<DatafileContent> {
@@ -67,13 +79,26 @@ function fetchDatafileContent(datafileUrl, options: InstanceOptions): Promise<Da
   return fetch(datafileUrl).then((res) => res.json());
 }
 
+interface Listeners {
+  [key: string]: Function[];
+}
+
+interface Statuses {
+  ready: boolean;
+  refreshInProgress: boolean;
+}
+
 function getInstanceFromSdk(
   sdk: FeaturevisorSDK,
   options: InstanceOptions,
   logger: Logger,
+  emitter: Emitter,
+  statuses: Statuses,
 ): FeaturevisorInstance {
   let intervalId;
-  let refreshInProgress = false;
+
+  const on = emitter.addListener.bind(emitter);
+  const off = emitter.removeListener.bind(emitter);
 
   const instance: FeaturevisorInstance = {
     // variation
@@ -84,7 +109,7 @@ function getInstanceFromSdk(
     getVariationString: sdk.getVariationString.bind(sdk),
 
     // activate
-    activate: sdk.activate,
+    activate: sdk.activate.bind(sdk),
     activateBoolean: sdk.activateBoolean.bind(sdk),
     activateInteger: sdk.activateInteger.bind(sdk),
     activateDouble: sdk.activateDouble.bind(sdk),
@@ -102,10 +127,18 @@ function getInstanceFromSdk(
     // additions
     setLogLevels: logger.setLevels.bind(logger),
 
+    // emitter
+    on: on,
+    addListener: on,
+    off: off,
+    removeListener: off,
+    removeAllListeners: emitter.removeAllListeners.bind(emitter),
+
+    // refresh
     refresh() {
       logger.debug("refreshing datafile");
 
-      if (refreshInProgress) {
+      if (statuses.refreshInProgress) {
         return logger.warn("refresh in progress, skipping");
       }
 
@@ -113,7 +146,7 @@ function getInstanceFromSdk(
         return logger.error("cannot refresh since `datafileUrl` is not provided");
       }
 
-      refreshInProgress = true;
+      statuses.refreshInProgress = true;
 
       fetchDatafileContent(options.datafileUrl, options)
         .then((datafile) => {
@@ -124,19 +157,17 @@ function getInstanceFromSdk(
           sdk.setDatafile(datafile);
           logger.info("refreshed datafile");
 
-          if (typeof options.onRefresh === "function") {
-            options.onRefresh();
-          }
+          emitter.emit("refresh");
 
-          if (isNotSameRevision && typeof options.onUpdate === "function") {
-            options.onUpdate();
+          if (isNotSameRevision) {
+            emitter.emit("update");
           }
 
-          refreshInProgress = false;
+          statuses.refreshInProgress = false;
         })
         .catch((e) => {
           logger.error("failed to refresh datafile", { error: e });
-          refreshInProgress = false;
+          statuses.refreshInProgress = false;
         });
     },
 
@@ -165,6 +196,10 @@ function getInstanceFromSdk(
 
       clearInterval(intervalId);
     },
+
+    isReady() {
+      return statuses.ready;
+    },
   };
 
   if (options.datafileUrl && options.refreshInterval) {
@@ -190,11 +225,32 @@ export function createInstance(options: InstanceOptions) {
   }
 
   const logger = options.logger || createLogger();
+  const emitter = new Emitter();
+  const statuses: Statuses = {
+    ready: false,
+    refreshInProgress: false,
+  };
 
   if (!options.datafileUrl && options.refreshInterval) {
     logger.warn("refreshing datafile requires `datafileUrl` option");
   }
 
+  if (options.onReady) {
+    emitter.addListener("ready", options.onReady);
+  }
+
+  if (options.onActivation) {
+    emitter.addListener("activation", options.onActivation);
+  }
+
+  if (options.onRefresh) {
+    emitter.addListener("refresh", options.onRefresh);
+  }
+
+  if (options.onUpdate) {
+    emitter.addListener("update", options.onUpdate);
+  }
+
   // datafile content is already provided
   if (options.datafile) {
     const sdk = new FeaturevisorSDK({
@@ -202,18 +258,17 @@ export function createInstance(options: InstanceOptions) {
       onActivation: options.onActivation,
       configureBucketValue: options.configureBucketValue,
       logger,
+      emitter,
       interceptAttributes: options.interceptAttributes,
+      fromInstance: true,
     });
 
-    if (typeof options.onReady === "function") {
-      const onReady = options.onReady;
-
-      setTimeout(function () {
-        onReady();
-      }, 0);
-    }
+    statuses.ready = true;
+    setTimeout(function() {
+      emitter.emit("ready");
+    }, 0);
 
-    return getInstanceFromSdk(sdk, options, logger);
+    return getInstanceFromSdk(sdk, options, logger, emitter, statuses);
   }
 
   // datafile has to be fetched
@@ -222,7 +277,9 @@ export function createInstance(options: InstanceOptions) {
     onActivation: options.onActivation,
     configureBucketValue: options.configureBucketValue,
     logger,
+    emitter,
     interceptAttributes: options.interceptAttributes,
+    fromInstance: true,
   });
 
   if (options.datafileUrl) {
@@ -230,9 +287,8 @@ export function createInstance(options: InstanceOptions) {
       .then((datafile) => {
         sdk.setDatafile(datafile);
 
-        if (typeof options.onReady === "function") {
-          options.onReady();
-        }
+        statuses.ready = true;
+        emitter.emit("ready");
       })
       .catch((e) => {
         logger.error("failed to fetch datafile:");
@@ -240,5 +296,5 @@ export function createInstance(options: InstanceOptions) {
       });
   }
 
-  return getInstanceFromSdk(sdk, options, logger);
+  return getInstanceFromSdk(sdk, options, logger, emitter, statuses);
 }

package/src/emitter.ts

@@ -0,0 +1,53 @@
+export type EventName = "ready" | "refresh" | "update" | "activation";
+
+export interface Listeners {
+  [key: string]: Function[];
+}
+
+export class Emitter {
+  private _listeners: Listeners;
+
+  constructor() {
+    this._listeners = {};
+  }
+
+  public addListener(eventName: EventName, fn: Function): void {
+    if (typeof this._listeners[eventName] === "undefined") {
+      this._listeners[eventName] = [];
+    }
+
+    this._listeners[eventName].push(fn);
+  }
+
+  public removeListener(eventName: EventName, fn: Function): void {
+    if (typeof this._listeners[eventName] === "undefined") {
+      return;
+    }
+
+    const index = this._listeners[eventName].indexOf(fn);
+
+    if (index !== -1) {
+      this._listeners[eventName].splice(index, 1);
+    }
+  }
+
+  public removeAllListeners(eventName?: EventName): void {
+    if (eventName) {
+      this._listeners[eventName] = [];
+    } else {
+      Object.keys(this._listeners).forEach((key) => {
+        this._listeners[key] = [];
+      });
+    }
+  }
+
+  public emit(eventName: EventName, ...args: any[]): void {
+    if (typeof this._listeners[eventName] === "undefined") {
+      return;
+    }
+
+    this._listeners[eventName].forEach((fn) => {
+      fn(...args);
+    });
+  }
+}