@featbit/js-client-sdk 2.0.2 → 3.0.1

package/src/store/store.ts

@@ -0,0 +1,38 @@
+export const StoreStorageKey = 'fb-datastore';
+
+export const CurrentUserStorageKey = 'fb-user';
+
+/**
+ * Represents an item which can be stored in the feature store.
+ */
+export interface IStoreItem {
+  version: number;
+
+  // The actual data associated with the item.
+  [attribute: string]: any;
+}
+
+/**
+ * When upserting an item it must contain a key.
+ */
+export interface IKeyedStoreItem extends IStoreItem {
+  key: string;
+}
+
+/**
+ * Represents the storage for a single kind of data. e.g. 'flag' or 'segment'.
+ */
+export interface IStoreKindData {
+  [key: string]: IStoreItem;
+}
+
+/**
+ * Represents the storage for the full data store.
+ */
+export interface IStoreDataStorage {
+  flags: IStoreKindData;
+  version: number;
+
+  // This attribute is to ingore the type check error
+  [attribute: string]: any;
+}

package/src/utils/Emits.ts

@@ -0,0 +1,76 @@
+import { IEventEmitter } from "./IEventEmitter";
+
+export type EventableConstructor<T = {}> = new (...args: any[]) => T;
+export type Eventable = EventableConstructor<{ emitter: IEventEmitter }>;
+
+/**
+ * Adds the implementation of an event emitter to something that contains
+ * a field of `emitter` with type `EventEmitter`.
+ * @param Base The class to derive the mixin from.
+ * @returns A class extending the base with an event emitter.
+ */
+export function Emits<TBase extends Eventable>(Base: TBase) {
+  return class WithEvents extends Base implements IEventEmitter {
+    on(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.on(eventName, listener, context);
+      return this;
+    }
+
+    addListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.addListener(eventName, listener, context);
+      return this;
+    }
+
+    once(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.once(eventName, listener, context);
+      return this;
+    }
+
+    removeListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.removeListener(eventName, listener, context);
+      return this;
+    }
+
+    off(eventName: string | symbol, listener: (...args: any) => void, context?: any): this {
+      this.emitter.off(eventName, listener, context);
+      return this;
+    }
+
+    removeAllListeners(event?: string | symbol): this {
+      this.emitter.removeAllListeners(event);
+      return this;
+    }
+
+    listeners(eventName: string | symbol): Function[] {
+      return this.emitter.listeners(eventName);
+    }
+
+    emit(eventName: string | symbol, ...args: any[]): this  {
+      this.emitter.emit(eventName, args);
+      return this;
+    }
+
+    listenerCount(eventName: string | symbol): number {
+      return this.emitter.listenerCount(eventName);
+    }
+
+    prependListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.prependListener(eventName, listener, context);
+      return this;
+    }
+
+    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.prependOnceListener(eventName, listener, context);
+      return this;
+    }
+
+    eventNames(): (string | symbol)[] {
+      return this.emitter.eventNames();
+    }
+
+    maybeReportError (error: any): this {
+      this.emitter.maybeReportError(error);
+      return this;
+    }
+  };
+}

package/src/utils/EventEmitter.ts

@@ -0,0 +1,129 @@
+import { ILogger } from "../logging/ILogger";
+import { IEventEmitter } from "./IEventEmitter";
+
+interface Events {
+  [key: string | symbol]: {
+    handler: (...args: any[]) => void;
+    context: any;
+  }[];
+}
+
+export class EventEmitter implements IEventEmitter {
+  private events: Events = {};
+
+  constructor(private logger?: ILogger) {}
+
+  private listeningTo (event: string) {
+    return !!this.events[event];
+  }
+
+  on (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    this.events[event] = this.events[event] || [];
+    this.events[event] = this.events[event].concat({
+      handler: handler,
+      context: context,
+    });
+
+    return this;
+  }
+
+  addListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    return this.on(event, handler, context);
+  }
+
+  once (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    const onceHandler = (...args: any[]) => {
+      this.off(event, onceHandler, context);
+      handler.apply(context, args);
+    };
+    return this.on(event, onceHandler, context);
+  }
+
+  off (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    if (!this.events[event]) {
+      return this;
+    }
+    for (let i = 0; i < this.events[event].length; i++) {
+      if (this.events[event][i].handler === handler && this.events[event][i].context === context) {
+        this.events[event] = this.events[event].slice(0, i).concat(this.events[event].slice(i + 1));
+      }
+    }
+
+    return this;
+  }
+
+  removeListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    return this.off(event, handler, context);
+  }
+
+  removeAllListeners (event?: string | symbol): this {
+    if (event) {
+      delete this.events[event];
+    } else {
+      this.events = {};
+    }
+
+    return this;
+  }
+
+  listeners (event: string | symbol): Function[] {
+    return this.events[event] ? this.events[event].map((event) => event.handler) : [];
+  }
+
+  emit (event: string | symbol, ...args: any[]): this {
+    if (!this.events[event]) {
+      return this;
+    }
+    // Copy the list of handlers before iterating, in case any handler adds or removes another handler.
+    // Any such changes should not affect what we do here-- we want to notify every handler that existed
+    // at the moment that the event was fired.
+    const copiedHandlers = [...this.events[event]];
+    for (let i = 0; i < copiedHandlers.length; i++) {
+      copiedHandlers[i].handler.apply(copiedHandlers[i].context, Array.prototype.slice.call(arguments, 1));
+    }
+
+    return this;
+  }
+
+  listenerCount (event: string | symbol): number {
+    return this.events[event] ? this.events[event].length : 0;
+  }
+
+  prependListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    this.events[event] = this.events[event] || [];
+    this.events[event] = [
+      {
+        handler: handler,
+        context: context,
+      },
+      ...this.events[event]
+    ];
+
+    return this;
+  }
+
+  prependOnceListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    const onceHandler = (...args: any[]) => {
+      this.off(event, onceHandler, context);
+      handler.apply(context, args);
+    };
+    return this.prependListener(event, onceHandler, context);
+  }
+
+  eventNames (): (string | symbol)[] {
+    return Object.keys(this.events);
+  }
+
+  maybeReportError (error: any): this {
+    if (!error) {
+      return this;
+    }
+    if (this.listeningTo('error')) {
+      this.emit('error', error);
+    } else {
+      this.logger?.error(error);
+    }
+
+    return this;
+  }
+}

package/src/utils/IEventEmitter.ts

@@ -0,0 +1,15 @@
+export interface IEventEmitter {
+  on(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  addListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  once(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  off(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  removeListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  removeAllListeners(event?: string | symbol): this;
+  listeners(event: string | symbol): Function[];
+  emit(event: string | symbol, ...args: any[]): this;
+  listenerCount(event: string | symbol): number;
+  prependListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  prependOnceListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  eventNames(): (string | symbol)[];
+  maybeReportError(error: any): this;
+}

package/src/utils/Regex.ts

@@ -0,0 +1,22 @@
+import { isNullOrUndefined } from "./isNullOrUndefined";
+
+export class Regex {
+  private static patternWithFlags = /\/(.*)\/([a-z]*)/i;
+  private static whiteSpaceRegex = /\s/g;
+
+  static fromString(patternString: string): RegExp {
+    let flags = '';
+    const match = patternString.match(Regex.patternWithFlags);
+
+    if (match) {
+      patternString = match[1]; // Update the pattern string
+      flags = match[2]; // Update the flags
+    }
+
+    return new RegExp(patternString, flags);
+  }
+
+  static isNullOrWhiteSpace(str: string) {
+    return isNullOrUndefined(str) || !str.replace(Regex.whiteSpaceRegex, '').length;
+  }
+}

package/src/utils/ValueConverters.ts

@@ -0,0 +1,56 @@
+import { Regex } from "./Regex";
+
+export interface IConvertResult<TValue> {
+  isSucceeded: boolean,
+  value?: TValue
+}
+
+export class ValueConverters {
+  static bool(value: string): IConvertResult<boolean> {
+    if (value?.toUpperCase() === 'TRUE') {
+      return ValueConverters.success<boolean>(true);
+    }
+
+    if (value?.toUpperCase() === 'FALSE') {
+      return ValueConverters.success<boolean>(false);
+    }
+
+    return ValueConverters.error<boolean>();
+  }
+
+  static number(value: string): IConvertResult<number> {
+    const num = Number(value);
+
+    if (Number.isNaN(num)) {
+      return ValueConverters.error<number>();
+    }
+
+    return ValueConverters.success<number>(num);
+  }
+
+  static string(value: string): IConvertResult<string> {
+    return ValueConverters.success<string>(value);
+  }
+
+  static json(value: string): IConvertResult<unknown> {
+    try {
+      const val = JSON.parse(value);
+      return ValueConverters.success<unknown>(val);
+    } catch (err) {
+      return ValueConverters.error<unknown>();
+    }
+  }
+
+  private static success<TValue>(value: TValue): IConvertResult<TValue> {
+    return {
+      isSucceeded: true,
+      value: value
+    }
+  }
+
+  private static error<TValue>(): IConvertResult<TValue> {
+    return {
+      isSucceeded: false
+    }
+  }
+}

package/src/utils/VoidFunction.ts

@@ -0,0 +1 @@
+export type VoidFunction = () => void;

package/src/utils/canonicalizeUri.ts

@@ -0,0 +1,4 @@
+// This function is designed to remove any trailing forward slashes at the end of the provided URI string
+export function canonicalizeUri(uri: string): string {
+  return uri.replace(/\/+$/, '');
+}

package/src/utils/debounce.ts

@@ -0,0 +1,33 @@
+/**
+ * Wait before calling the same function. Useful for expensive calls.
+ * Adapted from https://amitd.co/code/typescript/debounce.
+ *
+ * @return The debounced function.
+ *
+ * @example
+ *
+ * ```js
+ * const debouncedFunction = debounce(e => {
+ *   console.log(e);
+ * }, 5000);
+ *
+ * // Console logs 'Hello world again ' after 5 seconds
+ * debouncedFunction('Hello world');
+ * debouncedFunction('Hello world again');
+ * ```
+ * @param fn The function to be debounced.
+ * @param delayMs Defaults to 5 seconds.
+ */
+export const debounce = <T extends (...args: any[]) => ReturnType<T>>(
+  fn: T,
+  delayMs: number = 5000,
+): ((...args: Parameters<T>) => void) => {
+  let timer: ReturnType<typeof setTimeout>;
+
+  return (...args: Parameters<T>) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      fn(...args);
+    }, delayMs);
+  };
+};

package/src/utils/http.ts

@@ -0,0 +1,40 @@
+import { IInfo } from "../platform/IInfo";
+
+export type Headers = {
+  Authorization: string;
+  'User-Agent': string;
+  'Content-Type': string;
+};
+
+export function defaultHeaders(
+  sdkKey: string,
+  info: IInfo
+): Headers {
+  const {userAgentBase, version} = info.sdkData();
+
+  const headers: Headers = {
+    'Content-Type': 'application/json',
+    'User-Agent': `${ userAgentBase ?? info.appType }/${ version }`,
+    'Authorization': sdkKey
+  };
+
+  return headers;
+}
+
+export function httpErrorMessage(
+  err: {
+    status: number;
+    message: string;
+  },
+  context: string,
+  retryMessage?: string,
+): string {
+  let desc;
+  if (err.status) {
+    desc = `error ${ err.status }${ err.status === 401 ? ' (invalid SDK key)' : '' }`;
+  } else {
+    desc = `I/O error (${ err.message || err })`;
+  }
+  const action = retryMessage ?? 'giving up permanently';
+  return `Received ${ desc } for ${ context } - ${ action }`;
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './isNullOrUndefined';
+export * from './sleep';
+export * from './ValueConverters';
+export * from './VoidFunction';
+export * from './serializeUser';
+export * from './debounce';

package/src/utils/isNullOrUndefined.ts

@@ -0,0 +1,3 @@
+export function isNullOrUndefined(val: any) {
+  return val === null || val === undefined;
+}

package/src/utils/serializeUser.ts

@@ -0,0 +1,28 @@
+import { IUser } from "../options/IUser";
+
+export function serializeUser(user: IUser | undefined): string {
+  if (!user) {
+    return '';
+  }
+
+  const builtInProperties = `${user.keyId},${user.name}`;
+
+  const customizedProperties = user.customizedProperties
+    ?.sort((a, b) => {
+      const nameA = a.name.toLowerCase();
+      const nameB = b.name.toLowerCase();
+      if (nameA < nameB) {
+        return -1;
+      }
+
+      if (nameA > nameB) {
+        return 1;
+      }
+
+      return 0;
+    })
+    .map(p => `${p.name}:${p.value}`)
+    .join(',');
+
+  return `${builtInProperties},${customizedProperties}`;
+}

package/src/utils/sleep.ts

@@ -0,0 +1,6 @@
+const sleep = async (delayMillis: number = 1000) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, delayMillis);
+  });
+
+export default sleep;

package/src/version.ts

@@ -0,0 +1 @@
+export const version = "3.0.1"; export const name = "@featbit/js-client-sdk";

package/esm/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const insightsFlushTopic = "insights.flush";
-export declare const featureFlagEvaluatedTopic = "featureflag.evaluated.topic";
-export declare const featureFlagEvaluatedBufferTopic = "featureflag.evaluated.buffer.topic";
-export declare const websocketReconnectTopic = "network.websocket.reconnect";
-export declare const insightsTopic = "insights.topic";
-export declare const currentUserStorageKey = "fb-user";

package/esm/constants.js

@@ -1,7 +0,0 @@
-export var insightsFlushTopic = 'insights.flush';
-export var featureFlagEvaluatedTopic = 'featureflag.evaluated.topic';
-export var featureFlagEvaluatedBufferTopic = 'featureflag.evaluated.buffer.topic';
-export var websocketReconnectTopic = 'network.websocket.reconnect';
-export var insightsTopic = 'insights.topic';
-export var currentUserStorageKey = 'fb-user';
-//# sourceMappingURL=constants.js.map

package/esm/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,IAAM,kBAAkB,GAAG,gBAAgB,CAAC;AACnD,MAAM,CAAC,IAAM,yBAAyB,GAAG,6BAA6B,CAAC;AACvE,MAAM,CAAC,IAAM,+BAA+B,GAAG,oCAAoC,CAAC;AACpF,MAAM,CAAC,IAAM,uBAAuB,GAAG,6BAA6B,CAAC;AACrE,MAAM,CAAC,IAAM,aAAa,GAAG,gBAAgB,CAAC;AAC9C,MAAM,CAAC,IAAM,qBAAqB,GAAG,SAAS,CAAC"}

package/esm/events.d.ts

@@ -1,14 +0,0 @@
-interface Events {
-    [key: string]: Function[];
-}
-declare class EventEmitter {
-    events: Events;
-    constructor(events?: Events);
-    subscribe(name: string, cb: Function): {
-        unsubscribe: () => Function[];
-    };
-    unsubscribe(name: string, cb: Function): void;
-    emit(name: string, ...args: any[]): void;
-}
-export declare const eventHub: EventEmitter;
-export {};

package/esm/events.js

@@ -1,27 +0,0 @@
-var EventEmitter = /** @class */ (function () {
-    function EventEmitter(events) {
-        this.events = events || {};
-    }
-    EventEmitter.prototype.subscribe = function (name, cb) {
-        var _this = this;
-        (this.events[name] || (this.events[name] = [])).push(cb);
-        return {
-            unsubscribe: function () {
-                return _this.events[name] && _this.events[name].splice(_this.events[name].indexOf(cb) >>> 0, 1);
-            }
-        };
-    };
-    EventEmitter.prototype.unsubscribe = function (name, cb) {
-        this.events[name] && this.events[name].splice(this.events[name].indexOf(cb) >>> 0, 1);
-    };
-    EventEmitter.prototype.emit = function (name) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        (this.events[name] || []).forEach(function (fn) { return fn.apply(void 0, args); });
-    };
-    return EventEmitter;
-}());
-export var eventHub = new EventEmitter();
-//# sourceMappingURL=events.js.map

package/esm/events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAIA;IAEE,sBAAY,MAAe;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IAC7B,CAAC;IAEM,gCAAS,GAAhB,UAAiB,IAAY,EAAE,EAAY;QAA3C,iBAOC;QANC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEzD,OAAO;YACL,WAAW,EAAE;gBACX,OAAA,KAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAArF,CAAqF;SACxF,CAAC;IACJ,CAAC;IAEM,kCAAW,GAAlB,UAAmB,IAAY,EAAE,EAAY;QAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;IACxF,CAAC;IAEM,2BAAI,GAAX,UAAY,IAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QACtC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,eAAI,IAAI,GAAV,CAAW,CAAC,CAAC;IACvD,CAAC;IACH,mBAAC;AAAD,CAAC,AAtBD,IAsBC;AAED,MAAM,CAAC,IAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC"}

package/esm/featbit.d.ts

@@ -1,34 +0,0 @@
-import { FeatureFlagValue, ICustomEvent, IFeatureFlag, IFeatureFlagBase, IFeatureFlagSet, IOption, IUser } from "./types";
-export declare class FB {
-    private _readyEventEmitted;
-    private _readyPromise;
-    private _insightsQueue;
-    private _featureFlagEvaluationBuffer;
-    private _option;
-    constructor();
-    on(name: string, cb: Function): void;
-    off(name: string, cb: Function): void;
-    waitUntilReady(): Promise<IFeatureFlagBase[]>;
-    init(option: IOption): Promise<void>;
-    identify(user: IUser): Promise<void>;
-    logout(): Promise<IUser>;
-    /**
-     * bootstrap with predefined feature flags.
-     * @param {array} featureFlags the predefined feature flags.
-     * @param {boolean} forceFullFetch if a forced full fetch should be made.
-     * @return {Promise<void>} nothing.
-     */
-    bootstrap(featureFlags?: IFeatureFlag[], forceFullFetch?: boolean): Promise<void>;
-    private dataSync;
-    variation(key: string, defaultResult: FeatureFlagValue): FeatureFlagValue;
-    /**
-     * deprecated, you should use variation method directly
-     */
-    boolVariation(key: string, defaultResult: boolean): boolean;
-    getUser(): IUser;
-    sendCustomEvent(data: ICustomEvent[]): void;
-    sendFeatureFlagInsight(key: string, variation: string): void;
-    getAllFeatureFlags(): IFeatureFlagSet;
-}
-declare const _default: FB;
-export default _default;