@featbit/js-client-sdk 3.0.13 → 4.0.0

package/src/data-sync/PollingDataSynchronizer.ts

@@ -1,125 +1,125 @@
-import { isHttpRecoverable, PollingError } from "../errors";
-import { IDataSynchronizer } from "./IDataSynchronizer";
-import { ILogger } from "../logging/ILogger";
-import Configuration from "../Configuration";
-import { EventName, PollingErrorHandler, ProcessStreamResponse, StreamResponseEventType } from "./types";
-import Requestor from "./Requestor";
-import { httpErrorMessage } from "../utils/http";
-import { IUser } from "../options/IUser";
-
-export default class PollingDataSynchronizer implements IDataSynchronizer {
-  private stopped = false;
-
-  private logger?: ILogger;
-
-  private pollingInterval: number;
-
-  private user: IUser | undefined;
-
-  private timeoutHandle: any;
-
-  constructor(
-    config: Configuration,
-    private readonly requestor: Requestor,
-    private readonly getStoreTimestamp: () => number,
-    private readonly listeners: Map<EventName, ProcessStreamResponse>,
-    private readonly errorHandler?: PollingErrorHandler,
-  ) {
-    this.logger = config.logger;
-    this.pollingInterval = config.pollingInterval;
-    this.user = config.user;
-  }
-
-  private poll(resolve?: () => void, reject?: () => void) {
-    if (this.stopped) {
-      return;
-    }
-
-    const startTime = Date.now();
-    this.logger?.debug('Polling for feature flag and segments updates');
-    this.requestor.requestData(this.getStoreTimestamp(), this.user, async (err, body) => {
-      const elapsed = Date.now() - startTime;
-      const sleepFor = Math.max(this.pollingInterval - elapsed, 0);
-
-      this.logger?.debug('Elapsed: %d ms, sleeping for %d ms', elapsed, sleepFor);
-      if (err) {
-        const {status} = err;
-        if (status && !isHttpRecoverable(status)) {
-          const message = httpErrorMessage(err, 'polling request');
-          this.logger?.error(message);
-          this.errorHandler?.(new PollingError(message, status));
-          // It is not recoverable, return and do not trigger another
-          // poll.
-          reject?.();
-          return;
-        }
-        this.logger?.warn(httpErrorMessage(err, 'polling request', 'will retry'));
-        // Falling through, there was some type of error, we need to trigger
-        // a new poll.
-        this.timeoutHandle = setTimeout(() => {
-          this.poll(resolve, reject);
-        }, sleepFor);
-      } else {
-        let featureFlags = [];
-        let userKeyId = this.user?.keyId!;
-        let processStreamResponse: ProcessStreamResponse | undefined = this.listeners.get('patch');
-
-        if (body) {
-          const message = JSON.parse(body);
-          if (message.messageType === 'data-sync') {
-            switch (message.data.eventType) {
-              case StreamResponseEventType.patch:
-                processStreamResponse = this.listeners.get('patch');
-                break;
-              case StreamResponseEventType.full:
-                processStreamResponse = this.listeners.get('put');
-                break;
-            }
-
-            ({featureFlags, userKeyId} = message.data);
-          }
-        }
-
-        const data = processStreamResponse?.deserializeData?.(featureFlags);
-        await processStreamResponse?.processJson?.(userKeyId, data);
-        resolve?.();
-        // Falling through, there was some type of error, we need to trigger
-        // a new poll.
-        this.timeoutHandle = setTimeout(() => {
-          this.poll();
-        }, sleepFor);
-      }
-    });
-  }
-
-  async identify(user: IUser): Promise<void> {
-    this.user = {...user};
-    if (this.timeoutHandle) {
-      clearTimeout(this.timeoutHandle);
-      this.timeoutHandle = undefined;
-    }
-
-    return new Promise((resolve, reject) => {
-      this.poll(resolve, reject);
-    });
-  }
-
-  close(): void {
-    this.stop();
-  }
-
-  start(): void {
-    this.poll();
-  }
-
-  stop(): void {
-    if (this.timeoutHandle) {
-      clearTimeout(this.timeoutHandle);
-      this.timeoutHandle = undefined;
-    }
-    this.stopped = true;
-  }
-}
-
-
-
+import { isHttpRecoverable, PollingError } from "../errors";
+import { IDataSynchronizer } from "./IDataSynchronizer";
+import { ILogger } from "../logging/ILogger";
+import Configuration from "../Configuration";
+import { EventName, PollingErrorHandler, ProcessStreamResponse, StreamResponseEventType } from "./types";
+import Requestor from "./Requestor";
+import { httpErrorMessage } from "../utils/http";
+import { IUser } from "../options/IUser";
+
+export default class PollingDataSynchronizer implements IDataSynchronizer {
+  private stopped = false;
+
+  private logger?: ILogger;
+
+  private pollingInterval: number;
+
+  private user: IUser | undefined;
+
+  private timeoutHandle: any;
+
+  constructor(
+    config: Configuration,
+    private readonly requestor: Requestor,
+    private readonly getStoreTimestamp: () => number,
+    private readonly listeners: Map<EventName, ProcessStreamResponse>,
+    private readonly errorHandler?: PollingErrorHandler,
+  ) {
+    this.logger = config.logger;
+    this.pollingInterval = config.pollingInterval;
+    this.user = config.user;
+  }
+
+  private poll(resolve?: () => void, reject?: () => void) {
+    if (this.stopped) {
+      return;
+    }
+
+    const startTime = Date.now();
+    this.logger?.debug('Polling for feature flag and segments updates');
+    this.requestor.requestData(this.getStoreTimestamp(), this.user, async (err, body) => {
+      const elapsed = Date.now() - startTime;
+      const sleepFor = Math.max(this.pollingInterval - elapsed, 0);
+
+      this.logger?.debug('Elapsed: %d ms, sleeping for %d ms', elapsed, sleepFor);
+      if (err) {
+        const {status} = err;
+        if (status && !isHttpRecoverable(status)) {
+          const message = httpErrorMessage(err, 'polling request');
+          this.logger?.error(message);
+          this.errorHandler?.(new PollingError(message, status));
+          // It is not recoverable, return and do not trigger another
+          // poll.
+          reject?.();
+          return;
+        }
+        this.logger?.warn(httpErrorMessage(err, 'polling request', 'will retry'));
+        // Falling through, there was some type of error, we need to trigger
+        // a new poll.
+        this.timeoutHandle = setTimeout(() => {
+          this.poll(resolve, reject);
+        }, sleepFor);
+      } else {
+        let featureFlags = [];
+        let userKeyId = this.user?.keyId!;
+        let processStreamResponse: ProcessStreamResponse | undefined = this.listeners.get('patch');
+
+        if (body) {
+          const message = JSON.parse(body);
+          if (message.messageType === 'data-sync') {
+            switch (message.data.eventType) {
+              case StreamResponseEventType.patch:
+                processStreamResponse = this.listeners.get('patch');
+                break;
+              case StreamResponseEventType.full:
+                processStreamResponse = this.listeners.get('put');
+                break;
+            }
+
+            ({featureFlags, userKeyId} = message.data);
+          }
+        }
+
+        const data = processStreamResponse?.deserializeData?.(featureFlags);
+        await processStreamResponse?.processJson?.(userKeyId, data);
+        resolve?.();
+        // Falling through, there was some type of error, we need to trigger
+        // a new poll.
+        this.timeoutHandle = setTimeout(() => {
+          this.poll();
+        }, sleepFor);
+      }
+    });
+  }
+
+  async identify(user: IUser): Promise<void> {
+    this.user = {...user};
+    if (this.timeoutHandle) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = undefined;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.poll(resolve, reject);
+    });
+  }
+
+  close(): void {
+    this.stop();
+  }
+
+  start(): void {
+    this.poll();
+  }
+
+  stop(): void {
+    if (this.timeoutHandle) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = undefined;
+    }
+    this.stopped = true;
+  }
+}
+
+
+

package/src/data-sync/Requestor.ts

@@ -1,61 +1,61 @@
-import { IRequestor } from "./IRequestor";
-import Configuration from "../Configuration";
-import { IInfo } from "../platform/IInfo";
-import { IRequestOptions, IRequests, IResponse } from "../platform/requests";
-import { StreamingError } from "../errors";
-import { defaultHeaders } from "../utils/http";
-
-/**
- * @internal
- */
-export default class Requestor implements IRequestor {
-  private readonly headers: Record<string, string>;
-
-  private readonly uri: string;
-
-  constructor(
-    sdkKey: string,
-    config: Configuration,
-    info: IInfo,
-    private readonly requests: IRequests,
-  ) {
-    this.headers = defaultHeaders(sdkKey, info);
-    this.uri = config.pollingUri;
-  }
-
-  /**
-   * Perform a request and utilize the ETag cache. The ETags are cached in the
-   * requestor instance.
-   */
-  private async request(
-    requestUrl: string,
-    options: IRequestOptions,
-  ): Promise<{
-    res: IResponse;
-    body: string;
-  }> {
-    const res = await this.requests.fetch(requestUrl, options);
-
-    const body = await res.text();
-
-    return {res, body};
-  }
-
-  async requestData(timestamp: number, payload: any, cb: (err: any, body: any) => void) {
-    const options: IRequestOptions = {
-      method: 'POST',
-      headers: this.headers,
-      body: JSON.stringify(payload)
-    };
-    try {
-      const {res, body} = await this.request(`${ this.uri }?timestamp=${ timestamp ?? 0 }`, options);
-      if (res.status !== 200 && res.status !== 304) {
-        const err = new StreamingError(`Unexpected status code: ${ res.status }`, res.status);
-        return cb(err, undefined);
-      }
-      return cb(undefined, res.status === 304 ? null : body);
-    } catch (err) {
-      return cb(err, undefined);
-    }
-  }
-}
+import { IRequestor } from "./IRequestor";
+import Configuration from "../Configuration";
+import { IInfo } from "../platform/IInfo";
+import { IRequestOptions, IRequests, IResponse } from "../platform/requests";
+import { StreamingError } from "../errors";
+import { defaultHeaders } from "../utils/http";
+
+/**
+ * @internal
+ */
+export default class Requestor implements IRequestor {
+  private readonly headers: Record<string, string>;
+
+  private readonly uri: string;
+
+  constructor(
+    sdkKey: string,
+    config: Configuration,
+    info: IInfo,
+    private readonly requests: IRequests,
+  ) {
+    this.headers = defaultHeaders(sdkKey, info);
+    this.uri = config.pollingUri;
+  }
+
+  /**
+   * Perform a request and utilize the ETag cache. The ETags are cached in the
+   * requestor instance.
+   */
+  private async request(
+    requestUrl: string,
+    options: IRequestOptions,
+  ): Promise<{
+    res: IResponse;
+    body: string;
+  }> {
+    const res = await this.requests.fetch(requestUrl, options);
+
+    const body = await res.text();
+
+    return {res, body};
+  }
+
+  async requestData(timestamp: number, payload: any, cb: (err: any, body: any) => void) {
+    const options: IRequestOptions = {
+      method: 'POST',
+      headers: this.headers,
+      body: JSON.stringify(payload)
+    };
+    try {
+      const {res, body} = await this.request(`${ this.uri }?timestamp=${ timestamp ?? 0 }`, options);
+      if (res.status !== 200 && res.status !== 304) {
+        const err = new StreamingError(`Unexpected status code: ${ res.status }`, res.status);
+        return cb(err, undefined);
+      }
+      return cb(undefined, res.status === 304 ? null : body);
+    } catch (err) {
+      return cb(err, undefined);
+    }
+  }
+}

package/src/data-sync/WebSocketDataSynchronizer.ts

@@ -1,78 +1,78 @@
-import { IDataSynchronizer } from "./IDataSynchronizer";
-import ClientContext from "../options/ClientContext";
-import { EventName, ProcessStreamResponse } from "./types";
-import { ILogger } from "../logging/ILogger";
-import { IWebSocketWithEvents } from "../platform/IWebSocket";
-import { IUser } from "../options/IUser";
-
-class WebSocketDataSynchronizer implements IDataSynchronizer {
-  private socket?: IWebSocketWithEvents;
-  private readonly logger?: ILogger;
-  private identifyResolve?: () => void;
-
-  private connectionAttemptStartTime?: number;
-
-  constructor(
-    sdkKey: string,
-    user: IUser,
-    clientContext: ClientContext,
-    socket: IWebSocketWithEvents,
-    private readonly getStoreTimestamp: () => number,
-    private readonly listeners: Map<EventName, ProcessStreamResponse>,
-    webSocketPingInterval: number
-  ) {
-    const {logger, streamingUri} = clientContext;
-
-    this.logger = logger;
-    this.socket = socket;
-    this.socket.config({
-      sdkKey,
-      streamingUri,
-      pingInterval: webSocketPingInterval,
-      user,
-      logger,
-      getStoreTimestamp
-    });
-
-    this.listeners.forEach(({deserializeData, processJson}, eventName) => {
-      this.socket?.addListener(eventName, async (event) => {
-        this.logger?.debug(`Received ${ eventName } event`);
-
-        if (event?.data) {
-          const {featureFlags, userKeyId} = event.data;
-          const data = deserializeData(featureFlags);
-          await processJson(userKeyId, data);
-          this.identifyResolve?.();
-          this.identifyResolve = undefined;
-        }
-      });
-    })
-  }
-
-  async identify(user: IUser): Promise<void> {
-    this.socket?.identify(user);
-    return new Promise(resolve => this.identifyResolve = resolve);
-  }
-
-  start(): void {
-    this.logConnectionStarted();
-
-    this.socket?.connect();
-  }
-
-  private logConnectionStarted() {
-    this.connectionAttemptStartTime = Date.now();
-    this.logger?.info(`Stream connection attempt StartTime ${ this.connectionAttemptStartTime }`);
-  }
-
-  close(): void {
-    this.stop();
-  }
-
-  stop(): void {
-    this.socket?.close();
-    this.socket = undefined;
-  }
-}
-
+import { IDataSynchronizer } from "./IDataSynchronizer";
+import ClientContext from "../options/ClientContext";
+import { EventName, ProcessStreamResponse } from "./types";
+import { ILogger } from "../logging/ILogger";
+import { IWebSocketWithEvents } from "../platform/IWebSocket";
+import { IUser } from "../options/IUser";
+
+class WebSocketDataSynchronizer implements IDataSynchronizer {
+  private socket?: IWebSocketWithEvents;
+  private readonly logger?: ILogger;
+  private identifyResolve?: () => void;
+
+  private connectionAttemptStartTime?: number;
+
+  constructor(
+    sdkKey: string,
+    user: IUser,
+    clientContext: ClientContext,
+    socket: IWebSocketWithEvents,
+    private readonly getStoreTimestamp: () => number,
+    private readonly listeners: Map<EventName, ProcessStreamResponse>,
+    webSocketPingInterval: number
+  ) {
+    const {logger, streamingUri} = clientContext;
+
+    this.logger = logger;
+    this.socket = socket;
+    this.socket.config({
+      sdkKey,
+      streamingUri,
+      pingInterval: webSocketPingInterval,
+      user,
+      logger,
+      getStoreTimestamp
+    });
+
+    this.listeners.forEach(({deserializeData, processJson}, eventName) => {
+      this.socket?.addListener(eventName, async (event) => {
+        this.logger?.debug(`Received ${ eventName } event`);
+
+        if (event?.data) {
+          const {featureFlags, userKeyId} = event.data;
+          const data = deserializeData(featureFlags);
+          await processJson(userKeyId, data);
+          this.identifyResolve?.();
+          this.identifyResolve = undefined;
+        }
+      });
+    })
+  }
+
+  async identify(user: IUser): Promise<void> {
+    this.socket?.identify(user);
+    return new Promise(resolve => this.identifyResolve = resolve);
+  }
+
+  start(): void {
+    this.logConnectionStarted();
+
+    this.socket?.connect();
+  }
+
+  private logConnectionStarted() {
+    this.connectionAttemptStartTime = Date.now();
+    this.logger?.info(`Stream connection attempt StartTime ${ this.connectionAttemptStartTime }`);
+  }
+
+  close(): void {
+    this.stop();
+  }
+
+  stop(): void {
+    this.socket?.close();
+    this.socket = undefined;
+  }
+}
+
 export default WebSocketDataSynchronizer;

package/src/data-sync/index.ts

@@ -1,9 +1,9 @@
-export * from './DataSyncMode';
-export * from './IDataSynchronizer';
-export * from './IRequestor';
-export * from './NullDataSynchronizer';
-export * from './PollingDataSynchronizer';
-export * from './Requestor';
-export * from './types';
-export * from './utils';
+export * from './DataSyncMode';
+export * from './IDataSynchronizer';
+export * from './IRequestor';
+export * from './NullDataSynchronizer';
+export * from './PollingDataSynchronizer';
+export * from './Requestor';
+export * from './types';
+export * from './utils';
 export * from './WebSocketDataSynchronizer';

package/src/data-sync/types.ts

@@ -1,20 +1,20 @@
-import { PollingError } from "../errors";
-import { IFlag } from "../evaluation/data/IFlag";
-
-export type PollingErrorHandler = (err: PollingError) => void;
-
-export enum StreamResponseEventType {
-  full = 'full',
-  patch = 'patch'
-}
-
-export interface IStreamResponse {
-  eventType: StreamResponseEventType,
-  featureFlags: IFlag[]
-}
-
-export type EventName = 'delete' | 'patch' | 'ping' | 'put';
-export type ProcessStreamResponse = {
-  deserializeData: (flags: IFlag[]) => any;
-  processJson: (userKeyId: string, json: any) => Promise<void>;
+import { PollingError } from "../errors";
+import { IFlag } from "../evaluation/data/IFlag";
+
+export type PollingErrorHandler = (err: PollingError) => void;
+
+export enum StreamResponseEventType {
+  full = 'full',
+  patch = 'patch'
+}
+
+export interface IStreamResponse {
+  eventType: StreamResponseEventType,
+  featureFlags: IFlag[]
+}
+
+export type EventName = 'delete' | 'patch' | 'ping' | 'put';
+export type ProcessStreamResponse = {
+  deserializeData: (flags: IFlag[]) => any;
+  processJson: (userKeyId: string, json: any) => Promise<void>;
 };

package/src/data-sync/utils.ts

@@ -1,32 +1,32 @@
-/********************** encode text begin *****************************/
-const alphabet: Record<string, string> = {
-  "0": "Q",
-  "1": "B",
-  "2": "W",
-  "3": "S",
-  "4": "P",
-  "5": "H",
-  "6": "D",
-  "7": "X",
-  "8": "Z",
-  "9": "U",
-}
-
-function encodeNumber(param: number, length: number): string {
-  var s = "000000000000" + param;
-  const numberWithLeadingZeros = s.slice(s.length - length);
-  return numberWithLeadingZeros.split('').map(n => alphabet[n]).join('');
-}
-
-// generate connection token
-export function generateConnectionToken(text: string): string {
-  text = text.replace(/=*$/, '');
-  const timestamp = Date.now();
-  const timestampCode = encodeNumber(timestamp, timestamp.toString().length);
-  // get random number less than the length of the text as the start point, and it must be greater or equal to 2
-  const start = Math.max(Math.floor(Math.random() * text.length), 2);
-
-  return `${ encodeNumber(start, 3) }${ encodeNumber(timestampCode.length, 2) }${ text.slice(0, start) }${ timestampCode }${ text.slice(start) }`;
-}
-
+/********************** encode text begin *****************************/
+const alphabet: Record<string, string> = {
+  "0": "Q",
+  "1": "B",
+  "2": "W",
+  "3": "S",
+  "4": "P",
+  "5": "H",
+  "6": "D",
+  "7": "X",
+  "8": "Z",
+  "9": "U",
+}
+
+function encodeNumber(param: number, length: number): string {
+  var s = "000000000000" + param;
+  const numberWithLeadingZeros = s.slice(s.length - length);
+  return numberWithLeadingZeros.split('').map(n => alphabet[n]).join('');
+}
+
+// generate connection token
+export function generateConnectionToken(text: string): string {
+  text = text.replace(/=*$/, '');
+  const timestamp = Date.now();
+  const timestampCode = encodeNumber(timestamp, timestamp.toString().length);
+  // get random number less than the length of the text as the start point, and it must be greater or equal to 2
+  const start = Math.max(Math.floor(Math.random() * text.length), 2);
+
+  return `${ encodeNumber(start, 3) }${ encodeNumber(timestampCode.length, 2) }${ text.slice(0, start) }${ timestampCode }${ text.slice(start) }`;
+}
+
 /********************** encode text end *****************************/