@featbit/js-client-sdk 3.0.13 → 4.0.0

package/src/errors.ts

@@ -1,48 +1,48 @@
-export class PollingError extends Error {
-  public readonly status?: number;
-
-  constructor(message: string, status?: number) {
-    super(message);
-    this.status = status;
-    this.name = 'FbPollingError';
-  }
-}
-
-export class StreamingError extends Error {
-  public readonly code?: number;
-
-  constructor(message: string, code?: number) {
-    super(message);
-    this.code = code;
-    this.name = 'FbStreamingError';
-  }
-}
-
-export class UnexpectedResponseError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'FbUnexpectedResponseError';
-  }
-}
-
-
-export class ClientError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'FbClientError';
-  }
-}
-
-export class TimeoutError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'FeatBitTimeoutError';
-  }
-}
-
-export function isHttpRecoverable(status: number) {
-  if (status >= 400 && status < 500) {
-    return status === 400 || status === 408 || status === 429;
-  }
-  return true;
+export class PollingError extends Error {
+  public readonly status?: number;
+
+  constructor(message: string, status?: number) {
+    super(message);
+    this.status = status;
+    this.name = 'FbPollingError';
+  }
+}
+
+export class StreamingError extends Error {
+  public readonly code?: number;
+
+  constructor(message: string, code?: number) {
+    super(message);
+    this.code = code;
+    this.name = 'FbStreamingError';
+  }
+}
+
+export class UnexpectedResponseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FbUnexpectedResponseError';
+  }
+}
+
+
+export class ClientError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FbClientError';
+  }
+}
+
+export class TimeoutError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FeatBitTimeoutError';
+  }
+}
+
+export function isHttpRecoverable(status: number) {
+  if (status >= 400 && status < 500) {
+    return status === 400 || status === 408 || status === 429;
+  }
+  return true;
 }

package/src/evaluation/EvalResult.ts

@@ -1,36 +1,36 @@
-import { ReasonKinds } from "./ReasonKinds";
-import { IFlag } from "./data/IFlag";
-import { EvalEvent } from "../events/event";
-import { IUser } from "../options/IUser";
-
-/**
- * A class which encapsulates the result of an evaluation. It allows for differentiating between
- * successful and error result types.
- *
- * @internal
- */
-export default class EvalResult {
-  protected constructor(
-    public kind: ReasonKinds,
-    public value: IFlag | null,
-    public reason?: string,
-  ) {
-  }
-
-  static flagNotFound(flagKey: string) {
-    return new EvalResult(ReasonKinds.FlagNotFound, null, `flag not found: ${ flagKey }`);
-  }
-
-  static matched(val: IFlag) {
-    return new EvalResult(ReasonKinds.Match, val, 'target match');
-  }
-
-  toEvalEvent(user: IUser): EvalEvent | null {
-    if (this.kind !== ReasonKinds.Match) {
-      return null;
-    }
-
-    const targetedVariation = this.value?.variations.find(v => v.value === this.value?.variation);
-    return new EvalEvent(user, this.value?.id!, targetedVariation!, this.value?.sendToExperiment!);
-  }
+import { ReasonKinds } from "./ReasonKinds";
+import { IFlag } from "./data/IFlag";
+import { EvalEvent } from "../events/event";
+import { IUser } from "../options/IUser";
+
+/**
+ * A class which encapsulates the result of an evaluation. It allows for differentiating between
+ * successful and error result types.
+ *
+ * @internal
+ */
+export default class EvalResult {
+  protected constructor(
+    public kind: ReasonKinds,
+    public value: IFlag | null,
+    public reason?: string,
+  ) {
+  }
+
+  static flagNotFound(flagKey: string) {
+    return new EvalResult(ReasonKinds.FlagNotFound, null, `flag not found: ${ flagKey }`);
+  }
+
+  static matched(val: IFlag) {
+    return new EvalResult(ReasonKinds.Match, val, 'target match');
+  }
+
+  toEvalEvent(user: IUser): EvalEvent | null {
+    if (this.kind !== ReasonKinds.Match) {
+      return null;
+    }
+
+    const targetedVariation = this.value?.variations.find(v => v.value === this.value?.variation);
+    return new EvalEvent(user, this.value?.id!, targetedVariation!, this.value?.sendToExperiment!);
+  }
 }

package/src/evaluation/Evaluator.ts

@@ -1,27 +1,27 @@
-import { IFlag } from "./data/IFlag";
-import EvalResult from "./EvalResult";
-import { IStore } from "../platform/IStore";
-import DataKinds from "../store/DataKinds";
-
-/**
- * @internal
- */
-export default class Evaluator {
-  constructor(private store: IStore) {
-  }
-
-  /**
-   * Evaluate the given flag against the given context.
-   * @param flagKey The key of the feature flag.
-   */
-  evaluate(
-    flagKey: string,
-  ): EvalResult {
-    const flag = this.store.get(DataKinds.Flags, flagKey) as unknown as IFlag;
-    if (!flag) {
-      return EvalResult.flagNotFound(flagKey);
-    }
-
-    return EvalResult.matched(flag);
-  }
+import { IFlag } from "./data/IFlag";
+import EvalResult from "./EvalResult";
+import { IStore } from "../platform/IStore";
+import DataKinds from "../store/DataKinds";
+
+/**
+ * @internal
+ */
+export default class Evaluator {
+  constructor(private store: IStore) {
+  }
+
+  /**
+   * Evaluate the given flag against the given context.
+   * @param flagKey The key of the feature flag.
+   */
+  evaluate(
+    flagKey: string,
+  ): EvalResult {
+    const flag = this.store.get(DataKinds.Flags, flagKey) as unknown as IFlag;
+    if (!flag) {
+      return EvalResult.flagNotFound(flagKey);
+    }
+
+    return EvalResult.matched(flag);
+  }
 }

package/src/evaluation/IEvalDetail.ts

@@ -1,24 +1,24 @@
-import { ReasonKinds } from "./ReasonKinds";
-
-export interface IEvalDetail<TValue> {
-  /**
-   * The unique key of the feature flag.
-   */
-  flagKey: string;
-
-  /**
-   * An enum indicating the category of the reason. See {@link ReasonKinds}
-   */
-  kind: ReasonKinds;
-
-  /**
-   * The result of the flag evaluation. This will be either one of the flag's variations or
-   * the default value that was passed to `FbClient.variationDetail`.
-   */
-  value?: TValue;
-
-  /**
-   * A string describing the main factor that influenced the flag evaluation value.
-   */
-  reason?: string;
+import { ReasonKinds } from "./ReasonKinds";
+
+export interface IEvalDetail<TValue> {
+  /**
+   * The unique key of the feature flag.
+   */
+  flagKey: string;
+
+  /**
+   * An enum indicating the category of the reason. See {@link ReasonKinds}
+   */
+  kind: ReasonKinds;
+
+  /**
+   * The result of the flag evaluation. This will be either one of the flag's variations or
+   * the default value that was passed to `FbClient.variationDetail`.
+   */
+  value?: TValue;
+
+  /**
+   * A string describing the main factor that influenced the flag evaluation value.
+   */
+  reason?: string;
 }

package/src/evaluation/ReasonKinds.ts

@@ -1,10 +1,10 @@
-/**
- * Different kinds of error which may be encountered during evaluation.
- */
-export enum ReasonKinds {
-  ClientNotReady = 'ClientNotReady',
-  Match = 'Match',
-  WrongType = 'WrongType',
-  FlagNotFound = 'FlagNotFound',
-  Error = 'Error'
+/**
+ * Different kinds of error which may be encountered during evaluation.
+ */
+export enum ReasonKinds {
+  ClientNotReady = 'ClientNotReady',
+  Match = 'Match',
+  WrongType = 'WrongType',
+  FlagNotFound = 'FlagNotFound',
+  Error = 'Error'
 }

package/src/evaluation/data/IFlag.ts

@@ -1,29 +1,29 @@
-export type FlagValue = any;
-
-export enum VariationDataType {
-  string = 'string',
-  boolean = 'boolean',
-  number = 'number',
-  json = 'json',
-  empty = ''
-}
-
-export interface IVariation {
-  id: number,
-  value: FlagValue
-}
-
-export interface IFlagBase {
-  id: string, // the key
-  variation: FlagValue,
-  variationType: VariationDataType,
-  sendToExperiment?: boolean,
-  timestamp?: number,
-  variationOptions?: IVariation[],
-}
-
-export interface IFlag extends IFlagBase {
-  key: string, // the same value to id
-  variations: IVariation[],// the same value to variationOptions
-  version: number
-}
+export type FlagValue = any;
+
+export enum VariationDataType {
+  string = 'string',
+  boolean = 'boolean',
+  number = 'number',
+  json = 'json',
+  empty = ''
+}
+
+export interface IVariation {
+  id: number,
+  value: FlagValue
+}
+
+export interface IFlagBase {
+  id: string, // the key
+  variation: FlagValue,
+  variationType: VariationDataType,
+  sendToExperiment?: boolean,
+  timestamp?: number,
+  variationOptions?: IVariation[],
+}
+
+export interface IFlag extends IFlagBase {
+  key: string, // the same value to id
+  variations: IVariation[],// the same value to variationOptions
+  version: number
+}

package/src/evaluation/index.ts

@@ -1,5 +1,5 @@
-export * from './data';
-export * from './EvalResult';
-export * from './Evaluator';
-export * from './IEvalDetail';
+export * from './data';
+export * from './EvalResult';
+export * from './Evaluator';
+export * from './IEvalDetail';
 export * from './ReasonKinds';

package/src/events/DefaultEventProcessor.ts

@@ -1,84 +1,84 @@
-import { IEventProcessor } from "./IEventProcessor";
-import { EventDispatcher } from "./EventDispatcher";
-import ClientContext from "../options/ClientContext";
-import { FlushEvent, IEvent, ShutdownEvent } from "./event";
-import { isNullOrUndefined } from "../utils/isNullOrUndefined";
-import { IEventQueue } from "./IEventQueue";
-import { DefaultEventQueue } from "./DefaultEventQueue";
-import { ILogger } from "../logging/ILogger";
-
-export class DefaultEventProcessor implements IEventProcessor {
-  private readonly logger: ILogger;
-  private readonly flushInterval: number;
-  private readonly eventDispatcher: EventDispatcher;
-  private readonly eventQueue: IEventQueue;
-  private closed: boolean = false;
-
-  constructor(clientContext: ClientContext) {
-    const {logger, flushInterval, maxEventsInQueue} = clientContext;
-    this.logger = logger!;
-    this.flushInterval = flushInterval;
-    this.eventQueue = new DefaultEventQueue(maxEventsInQueue, this.logger);
-    this.eventDispatcher = new EventDispatcher(clientContext, this.eventQueue);
-
-    this.flushLoop();
-  }
-
-  private flushLoop() {
-    if (this.closed) {
-      return;
-    }
-
-    setTimeout(async () => {
-      try {
-        await this.flush();
-      } catch (err) {
-        this.logger.error('Unexpected error while flushing events in event processor.', err);
-      }
-
-      this.flushLoop();
-    }, this.flushInterval);
-  }
-
-  flush(): Promise<any> {
-    const flushEvent = new FlushEvent();
-    this.record(flushEvent);
-    return flushEvent.waitForCompletion();
-  }
-
-  async close(): Promise<void> {
-    if (this.closed) {
-      return;
-    }
-
-    // send a shutdown event to dispatcher
-    const shutdown = new ShutdownEvent();
-    this.record(shutdown);
-
-    try {
-      await shutdown.waitForCompletion();
-    } catch (err) {
-      this.logger.error('Event processor shutdown but not complete.');
-    }
-
-    // mark the event queue as complete for adding
-    this.eventQueue.close();
-    this.closed = true;
-  }
-
-  record(event: IEvent | null): boolean {
-    if (isNullOrUndefined(event)) {
-      return false;
-    }
-
-    if (!this.eventQueue.addEvent(event!)) {
-      if (event instanceof FlushEvent) {
-        event.complete();
-      }
-
-      return false;
-    }
-
-    return true;
-  }
+import { IEventProcessor } from "./IEventProcessor";
+import { EventDispatcher } from "./EventDispatcher";
+import ClientContext from "../options/ClientContext";
+import { FlushEvent, IEvent, ShutdownEvent } from "./event";
+import { isNullOrUndefined } from "../utils/isNullOrUndefined";
+import { IEventQueue } from "./IEventQueue";
+import { DefaultEventQueue } from "./DefaultEventQueue";
+import { ILogger } from "../logging/ILogger";
+
+export class DefaultEventProcessor implements IEventProcessor {
+  private readonly logger: ILogger;
+  private readonly flushInterval: number;
+  private readonly eventDispatcher: EventDispatcher;
+  private readonly eventQueue: IEventQueue;
+  private closed: boolean = false;
+
+  constructor(clientContext: ClientContext) {
+    const {logger, flushInterval, maxEventsInQueue} = clientContext;
+    this.logger = logger!;
+    this.flushInterval = flushInterval;
+    this.eventQueue = new DefaultEventQueue(maxEventsInQueue, this.logger);
+    this.eventDispatcher = new EventDispatcher(clientContext, this.eventQueue);
+
+    this.flushLoop();
+  }
+
+  private flushLoop() {
+    if (this.closed) {
+      return;
+    }
+
+    setTimeout(async () => {
+      try {
+        await this.flush();
+      } catch (err) {
+        this.logger.error('Unexpected error while flushing events in event processor.', err);
+      }
+
+      this.flushLoop();
+    }, this.flushInterval);
+  }
+
+  flush(): Promise<any> {
+    const flushEvent = new FlushEvent();
+    this.record(flushEvent);
+    return flushEvent.waitForCompletion();
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) {
+      return;
+    }
+
+    // send a shutdown event to dispatcher
+    const shutdown = new ShutdownEvent();
+    this.record(shutdown);
+
+    try {
+      await shutdown.waitForCompletion();
+    } catch (err) {
+      this.logger.error('Event processor shutdown but not complete.');
+    }
+
+    // mark the event queue as complete for adding
+    this.eventQueue.close();
+    this.closed = true;
+  }
+
+  record(event: IEvent | null): boolean {
+    if (isNullOrUndefined(event)) {
+      return false;
+    }
+
+    if (!this.eventQueue.addEvent(event!)) {
+      if (event instanceof FlushEvent) {
+        event.complete();
+      }
+
+      return false;
+    }
+
+    return true;
+  }
 }

package/src/events/DefaultEventQueue.ts

@@ -1,50 +1,50 @@
-import { IEventQueue } from "./IEventQueue";
-import { IEvent } from "./event";
-import { ILogger } from "../logging/ILogger";
-
-export class DefaultEventQueue implements IEventQueue {
-  private events: IEvent[];
-  private closed: boolean = false;
-
-  constructor(private readonly capacity: number, private readonly logger: ILogger) {
-    this.events = [];
-  }
-
-  addEvent(event: IEvent): boolean {
-    if (this.closed) {
-      return false;
-    }
-
-    if (this.events.length >= this.capacity) {
-      this.logger.warn("Events are being produced faster than they can be processed. We shouldn't see this.");
-      return false;
-    }
-
-    this.events.push(event);
-    return true;
-  }
-
-  clear(): void {
-    this.events = [];
-  }
-
-  shift(): IEvent | undefined {
-    return this.events.shift();
-  }
-
-  close(): void {
-    this.closed = true;
-  }
-
-  get eventsSnapshot(): IEvent[] {
-    return [...this.events];
-  }
-
-  get length(): number {
-    return this.events.length;
-  }
-
-  get isEmpty(): boolean {
-    return this.length === 0;
-  }
+import { IEventQueue } from "./IEventQueue";
+import { IEvent } from "./event";
+import { ILogger } from "../logging/ILogger";
+
+export class DefaultEventQueue implements IEventQueue {
+  private events: IEvent[];
+  private closed: boolean = false;
+
+  constructor(private readonly capacity: number, private readonly logger: ILogger) {
+    this.events = [];
+  }
+
+  addEvent(event: IEvent): boolean {
+    if (this.closed) {
+      return false;
+    }
+
+    if (this.events.length >= this.capacity) {
+      this.logger.warn("Events are being produced faster than they can be processed. We shouldn't see this.");
+      return false;
+    }
+
+    this.events.push(event);
+    return true;
+  }
+
+  clear(): void {
+    this.events = [];
+  }
+
+  shift(): IEvent | undefined {
+    return this.events.shift();
+  }
+
+  close(): void {
+    this.closed = true;
+  }
+
+  get eventsSnapshot(): IEvent[] {
+    return [...this.events];
+  }
+
+  get length(): number {
+    return this.events.length;
+  }
+
+  get isEmpty(): boolean {
+    return this.length === 0;
+  }
 }