@rc-ex/ws 0.16.1 → 0.17.0

package/{index.ts → src/index.ts}

@@ -1,28 +1,30 @@
+/* eslint-disable no-console */
 import RingCentral from '@rc-ex/core';
 import {
+  RestMethod,
   RestRequestConfig,
   RestResponse,
-  RestMethod,
-} from '@rc-ex/core/lib/Rest';
+} from '@rc-ex/core/lib/types';
 import SdkExtension from '@rc-ex/core/lib/SdkExtension';
-import WS, {OPEN, CONNECTING, MessageEvent} from 'isomorphic-ws';
+import WS, { OPEN, CONNECTING, MessageEvent } from 'isomorphic-ws';
 import hyperid from 'hyperid';
-import {EventEmitter} from 'events';
+import { EventEmitter } from 'events';
 import waitFor from 'wait-for-async';
 import RestException from '@rc-ex/core/lib/RestException';
-import {SubscriptionInfo} from '@rc-ex/core/lib/definitions';
+import SubscriptionInfo from '@rc-ex/core/lib/definitions/SubscriptionInfo';
 import debounce from 'lodash/debounce';
 
-import {request} from './rest';
+import { request } from './rest';
 import {
   WsToken,
   ConnectionDetails,
   WebSocketOptions,
   WsgEvent,
   Wsc,
+  WebSocketExtensionInterface,
 } from './types';
 import Subscription from './subscription';
-import {ConnectionException} from './exceptions';
+import ConnectionException from './exceptions/ConnectionException';
 import Utils from './utils';
 
 const uuid = hyperid();
@@ -39,19 +41,30 @@ class WebSocketExtension extends SdkExtension {
   eventEmitter = new EventEmitter();
 
   options: WebSocketOptions;
+
   rc!: RingCentral;
+
   wsToken?: WsToken;
+
   wsTokenExpiresAt = 0;
+
   ws!: WS;
+
   connectionDetails!: ConnectionDetails;
+
   wsc?: Wsc;
+
   subscriptions: Subscription[] = [];
+
   recover: Function;
+
   connect: Function;
 
   // for auto recover
   intervalHandle?: NodeJS.Timeout;
+
   recoverTimestamp?: number;
+
   pingServerHandle?: NodeJS.Timeout;
 
   request = request; // request method was moved to another file to keep this file short
@@ -64,7 +77,7 @@ class WebSocketExtension extends SdkExtension {
     this.options.autoRecover ??= {
       enabled: true,
     };
-    this.options.autoRecover.checkInterval ??= retriesAttempted => {
+    this.options.autoRecover.checkInterval ??= (retriesAttempted) => {
       const interval = 2000 + 2000 * retriesAttempted;
       return Math.min(8000, interval);
     };
@@ -81,9 +94,9 @@ class WebSocketExtension extends SdkExtension {
 
   disable() {
     super.disable();
-    for (const subscription of this.subscriptions ?? []) {
+    (this.subscriptions ?? []).forEach((subscription) => {
       subscription.enabled = false;
-    }
+    });
   }
 
   async install(rc: RingCentral) {
@@ -95,7 +108,7 @@ class WebSocketExtension extends SdkExtension {
         endpoint: string,
         content?: {},
         queryParams?: {},
-        config?: RestRequestConfig
+        config?: RestRequestConfig,
       ): Promise<RestResponse<T>> => {
         if (!this.enabled || !this.options.restOverWebSocket) {
           return request<T>(method, endpoint, content, queryParams, config);
@@ -103,10 +116,10 @@ class WebSocketExtension extends SdkExtension {
         if (
           // the following cannot be done with WebSocket
           (config?.headers?.['Content-Type'] as string | undefined)?.includes(
-            'multipart/form-data'
-          ) ||
-          config?.responseType === 'arraybuffer' ||
-          endpoint.startsWith('/restapi/oauth/') // token, revoke, wstoken
+            'multipart/form-data',
+          )
+          || config?.responseType === 'arraybuffer'
+          || endpoint.startsWith('/restapi/oauth/') // token, revoke, wstoken
         ) {
           return request<T>(method, endpoint, content, queryParams, config);
         }
@@ -155,14 +168,14 @@ class WebSocketExtension extends SdkExtension {
           retriesAttempted = 0;
           if (this.options.debugMode) {
             console.debug(
-              `Auto recover done, recoveryState: ${this.connectionDetails.recoveryState}`
+              `Auto recover done, recoveryState: ${this.connectionDetails.recoveryState}`,
             );
           }
           this.eventEmitter.emit(
             this.connectionDetails.recoveryState === 'Successful'
               ? Events.autoRecoverSuccess
               : Events.autoRecoverFailed,
-            this.ws
+            this.ws,
           );
         } catch (e) {
           if (e instanceof RestException) {
@@ -176,13 +189,13 @@ class WebSocketExtension extends SdkExtension {
         }
         this.intervalHandle = setInterval(
           check,
-          this.options.autoRecover!.checkInterval!(retriesAttempted)
+          this.options.autoRecover!.checkInterval!(retriesAttempted),
         );
       }
     };
     this.intervalHandle = setInterval(
       check,
-      this.options.autoRecover!.checkInterval!(retriesAttempted)
+      this.options.autoRecover!.checkInterval!(retriesAttempted),
     );
 
     // browser only code start
@@ -212,9 +225,9 @@ class WebSocketExtension extends SdkExtension {
       this.recoverTimestamp = Date.now();
     }
     if (
-      this.connectionDetails !== undefined &&
-      Date.now() - this.recoverTimestamp >
-        this.connectionDetails.recoveryTimeout * 1000
+      this.connectionDetails !== undefined
+      && Date.now() - this.recoverTimestamp
+      > this.connectionDetails.recoveryTimeout * 1000
     ) {
       if (this.options.debugMode) {
         console.debug('connect to WSG but do not recover');
@@ -246,7 +259,7 @@ class WebSocketExtension extends SdkExtension {
               type: 'Heartbeat',
               messageId: uuid(),
             },
-          ])
+          ]),
         );
       }
     } catch (e) {
@@ -258,8 +271,7 @@ class WebSocketExtension extends SdkExtension {
     if (Date.now() > this.wsTokenExpiresAt) {
       const r = await this.rc.post('/restapi/oauth/wstoken');
       this.wsToken = r.data as WsToken;
-      this.wsTokenExpiresAt =
-        Date.now() + (this.wsToken.expires_in - 10) * 1000;
+      this.wsTokenExpiresAt = Date.now() + (this.wsToken.expires_in - 10) * 1000;
     }
     let wsUri = '';
     if (this.wsToken) {
@@ -290,7 +302,7 @@ class WebSocketExtension extends SdkExtension {
         }
         this.pingServerHandle = setTimeout(
           () => this.pingServer(),
-          this.options.autoRecover!.pingServerInterval
+          this.options.autoRecover!.pingServerInterval,
         );
       });
     }
@@ -305,10 +317,10 @@ class WebSocketExtension extends SdkExtension {
       const event = mEvent as WsgEvent;
       const [meta, body] = Utils.splitWsgData(event.data);
       if (
-        meta.wsc &&
-        (!this.wsc ||
-          (meta.type === 'ConnectionDetails' && body.recoveryState) ||
-          this.wsc.sequence < meta.wsc.sequence)
+        meta.wsc
+        && (!this.wsc
+          || (meta.type === 'ConnectionDetails' && body.recoveryState)
+          || this.wsc.sequence < meta.wsc.sequence)
       ) {
         this.wsc = meta.wsc;
         this.eventEmitter.emit(Events.newWsc, this.wsc);
@@ -318,7 +330,7 @@ class WebSocketExtension extends SdkExtension {
     // get initial ConnectionDetails data
     const [meta, body, event] = await Utils.waitForWebSocketMessage(
       this.ws,
-      meta => meta.type === 'ConnectionDetails' || meta.type === 'Error'
+      (meta) => meta.type === 'ConnectionDetails' || meta.type === 'Error',
     );
     if (meta.type === 'Error') {
       throw new ConnectionException(event);
@@ -326,12 +338,14 @@ class WebSocketExtension extends SdkExtension {
     this.connectionDetails = body;
 
     // recover all subscriptions, if there are any
-    for (const subscription of this.subscriptions.filter(sub => sub.enabled)) {
+    for (const subscription of this.subscriptions.filter(
+      (sub) => sub.enabled,
+    )) {
       // because we have a new ws object
       subscription.setupWsEventListener();
       if (
-        !recoverSession ||
-        this.connectionDetails.recoveryState === 'Failed'
+        !recoverSession
+        || this.connectionDetails.recoveryState === 'Failed'
       ) {
         // create new subscription if don't recover existing one
         await subscription.subscribe();
@@ -361,9 +375,9 @@ class WebSocketExtension extends SdkExtension {
   async subscribe(
     eventFilters: string[],
     callback: (event: {}) => void,
-    cache: SubscriptionInfo | undefined | null = undefined
+    cache: SubscriptionInfo | undefined | null = undefined,
   ) {
-    const subscription = new Subscription(this, eventFilters, callback);
+    const subscription = new Subscription(this as WebSocketExtensionInterface, eventFilters, callback);
     if (cache === undefined || cache === null) {
       await subscription.subscribe();
     } else {

package/{rest.ts → src/rest.ts}

@@ -2,72 +2,72 @@ import {
   RestMethod,
   RestRequestConfig,
   RestResponse,
-} from '@rc-ex/core/lib/Rest';
+} from '@rc-ex/core/lib/types';
 import RestException from '@rc-ex/core/lib/RestException';
 import hyperid from 'hyperid';
-import {getReasonPhrase} from 'http-status-codes';
+import { getReasonPhrase } from 'http-status-codes';
 
-import WebSocketExtension from './index';
-import {version} from './package.json';
 import Utils from './utils';
+import {
+  WebSocketExtensionInterface,
+} from './types';
+
+const version = '0.16';
 
 const uuid = hyperid();
 
 export async function request<T>(
-  this: WebSocketExtension,
+  this: WebSocketExtensionInterface,
   method: RestMethod,
   endpoint: string,
   content?: {},
   queryParams?: {},
-  config?: RestRequestConfig
+  config?: RestRequestConfig,
 ): Promise<RestResponse<T>> {
-  const _config: RestRequestConfig = {
-    method: method,
+  const newConfig: RestRequestConfig = {
+    method,
     baseURL: this.wsToken?.uri,
     url: endpoint,
     data: content,
     params: queryParams,
     ...config,
   };
-  _config.headers = {
-    ..._config.headers,
-    'X-User-Agent': `${this.rc.rest!.appName}/${
-      this.rc.rest!.appVersion
-    } ringcentral-extensible/ws/${version}`,
+  newConfig.headers = {
+    ...newConfig.headers,
+    'X-User-Agent': `${this.rc.rest!.appName}/${this.rc.rest!.appVersion} ringcentral-extensible/ws/${version}`,
   };
   const messageId = uuid();
   const requestBody = [
     {
       type: 'ClientRequest',
       messageId,
-      method: _config.method,
-      path: _config.url,
-      headers: _config.headers,
-      query: _config.params,
+      method: newConfig.method,
+      path: newConfig.url,
+      headers: newConfig.headers,
+      query: newConfig.params,
     },
   ];
-  if (_config.data) {
-    requestBody.push(_config.data);
+  if (newConfig.data) {
+    requestBody.push(newConfig.data);
   }
   await this.ws.send(JSON.stringify(requestBody));
   const [meta, body] = await Utils.waitForWebSocketMessage(
     this.ws,
-    meta => meta.messageId === messageId
+    (_meta) => _meta.messageId === messageId,
   );
   const response: RestResponse = {
     data: body as T,
     status: meta.status,
     statusText: getReasonPhrase(meta.status),
     headers: meta.headers,
-    config: _config,
+    config: newConfig,
   };
   if (
-    meta.type === 'ClientRequest' &&
-    meta.status >= 200 &&
-    meta.status < 300
+    meta.type === 'ClientRequest'
+    && meta.status >= 200
+    && meta.status < 300
   ) {
     return response;
-  } else {
-    throw new RestException(response);
   }
+  throw new RestException(response);
 }

package/{subscription.ts → src/subscription.ts}

@@ -1,36 +1,37 @@
-import {
-  CreateSubscriptionRequest,
-  SubscriptionInfo,
-} from '@rc-ex/core/lib/definitions';
-import {RestResponse} from '@rc-ex/core/lib/Rest';
-import {MessageEvent} from 'ws';
-
-import WebSocketExtension from './index';
-import {WsgEvent, WsgMeta} from './types';
+/* eslint-disable no-console */
+import CreateSubscriptionRequest from '@rc-ex/core/lib/definitions/CreateSubscriptionRequest';
+import SubscriptionInfo from '@rc-ex/core/lib/definitions/SubscriptionInfo';
+import { RestResponse } from '@rc-ex/core/lib/types';
+import { MessageEvent } from 'ws';
+
+import { WsgEvent, WsgMeta, WebSocketExtensionInterface } from './types';
 import Utils from './utils';
 
 class Subscription {
-  wse: WebSocketExtension;
+  wse: WebSocketExtensionInterface;
+
   eventFilters: string[];
+
   eventListener: (event: MessageEvent) => void;
+
   timeout?: NodeJS.Timeout;
+
   enabled = true;
 
   constructor(
-    wse: WebSocketExtension,
+    wse: WebSocketExtensionInterface,
     eventFilters: string[],
-    callback: (event: {}) => void
+    callback: (event: {}) => void,
   ) {
     this.wse = wse;
     this.eventFilters = eventFilters;
     this.eventListener = (mEvent: MessageEvent) => {
       const event = mEvent as WsgEvent;
-      const [meta, body]: [WsgMeta, {subscriptionId: string}] =
-        Utils.splitWsgData(event.data);
+      const [meta, body]: [WsgMeta, { subscriptionId: string }] = Utils.splitWsgData(event.data);
       if (
-        this.enabled &&
-        meta.type === 'ServerNotification' &&
-        body.subscriptionId === this.subscriptionInfo!.id
+        this.enabled
+        && meta.type === 'ServerNotification'
+        && body.subscriptionId === this.subscriptionInfo!.id
       ) {
         callback(body);
       }
@@ -44,15 +45,17 @@ class Subscription {
 
   get requestBody(): CreateSubscriptionRequest {
     return {
-      deliveryMode: {transportType: 'WebSocket'},
+      deliveryMode: { transportType: 'WebSocket' },
       eventFilters: this.eventFilters,
     };
   }
 
   _subscriptionInfo?: SubscriptionInfo;
+
   get subscriptionInfo(): SubscriptionInfo | undefined {
     return this._subscriptionInfo;
   }
+
   set subscriptionInfo(_subscription) {
     this._subscriptionInfo = _subscription;
     if (this.timeout) {
@@ -71,7 +74,7 @@ class Subscription {
       await this.wse.request<SubscriptionInfo>(
         'POST',
         '/restapi/v1.0/subscription',
-        this.requestBody
+        this.requestBody,
       )
     ).data;
   }
@@ -85,11 +88,11 @@ class Subscription {
         await this.wse.request<SubscriptionInfo>(
           'PUT',
           `/restapi/v1.0/subscription/${this.subscriptionInfo!.id}`,
-          this.requestBody
+          this.requestBody,
         )
       ).data;
     } catch (e) {
-      const re = e as {response: RestResponse};
+      const re = e as { response: RestResponse };
       if (re.response && re.response.status === 404) {
         // subscription expired
         await this.subscribe();
@@ -101,24 +104,19 @@ class Subscription {
     if (!this.subscriptionInfo) {
       return;
     }
-    if (this.timeout) {
-      global.clearTimeout(this.timeout);
-      this.timeout = undefined;
-    }
     try {
       await this.wse.request<SubscriptionInfo>(
         'DELETE',
-        `/restapi/v1.0/subscription/${this.subscriptionInfo!.id}`
+        `/restapi/v1.0/subscription/${this.subscriptionInfo!.id}`,
       );
     } catch (e) {
-      const re = e as {response: RestResponse};
+      const re = e as { response: RestResponse };
       if (re.response && re.response.status === 404) {
         // ignore
         if (this.wse.options.debugMode) {
           console.debug(
-            `Subscription ${
-              this.subscriptionInfo!.id
-            } doesn't exist on server side`
+            `Subscription ${this.subscriptionInfo!.id
+            } doesn't exist on server side`,
           );
         }
       } else if (re.response && re.response.status === 401) {
@@ -130,9 +128,20 @@ class Subscription {
         throw e;
       }
     }
-    this.subscriptionInfo = undefined;
+    this.remove();
+  }
+
+  remove() {
+    if (this.timeout) {
+      global.clearTimeout(this.timeout);
+      this.timeout = undefined;
+    }
     this.enabled = false;
-    this.wse.ws.removeEventListener('message', this.eventListener);
+    this.subscriptionInfo = undefined;
+    if (this.wse.ws) {
+      this.wse.ws.removeEventListener('message', this.eventListener);
+    }
+    this.wse.subscriptions = this.wse.subscriptions.filter((x) => x !== this);
   }
 }
 

package/{types.ts → src/types.ts}

@@ -1,3 +1,7 @@
+import RingCentral from '@rc-ex/core';
+import { RestMethod, RestRequestConfig, RestResponse } from '@rc-ex/core/lib/types';
+import WS from 'isomorphic-ws';
+
 export type WsToken = {
   uri: string;
   ws_access_token: string;
@@ -27,11 +31,11 @@ export type Wsc = {
 
 export type WsgMeta = {
   type:
-    | 'ClientRequest'
-    | 'ServerNotification'
-    | 'Error'
-    | 'ConnectionDetails'
-    | 'Heartbeat';
+  | 'ClientRequest'
+  | 'ServerNotification'
+  | 'Error'
+  | 'ConnectionDetails'
+  | 'Heartbeat';
   messageId: string;
   status: number;
   headers: {
@@ -56,3 +60,21 @@ export type ConnectionDetails = {
   recoveryState?: 'Successful' | 'Failed';
   recoveryErrorCode?: string;
 };
+
+export interface WebSocketExtensionInterface {
+  options: WebSocketOptions;
+  subscriptions: SubscriptionInterface[];
+  ws: WS;
+  wsToken?: WsToken;
+  rc: RingCentral;
+  request<T>(
+    method: RestMethod,
+    endpoint: string,
+    content?: {},
+    queryParams?: {},
+    config?: RestRequestConfig,
+  ): Promise<RestResponse<T>>;
+}
+
+export interface SubscriptionInterface {
+}

package/{utils.ts → src/utils.ts}

@@ -1,7 +1,9 @@
-import WS, {MessageEvent} from 'isomorphic-ws';
+/* eslint-disable no-console */
+import WS, { MessageEvent } from 'isomorphic-ws';
 
-import {WsgMeta, WsgEvent} from './types';
-import {ClosedException, TimeoutException} from './exceptions';
+import { WsgMeta, WsgEvent } from './types';
+import ClosedException from './exceptions/ClosedException';
+import TimeoutException from './exceptions/TimeoutException';
 
 class Utils {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -12,19 +14,19 @@ class Utils {
         JSON.parse(wsgData.substring(1, index)),
         wsgData.substring(index + 1, wsgData.length - 1),
       ];
-    } else {
-      return JSON.parse(wsgData);
     }
+    return JSON.parse(wsgData);
   }
 
-  static debugWebSocket(ws: WS) {
+  static debugWebSocket(_ws: WS) {
+    const ws = _ws;
     const send = ws.send.bind(ws);
     ws.send = async (str: string) => {
       await send(str);
       console.debug(
         `*** WebSocket outgoing message: ***
 ${JSON.stringify(JSON.parse(str), null, 2)}
-******`
+******`,
       );
     };
     ws.addEventListener('message', (mEvent: MessageEvent) => {
@@ -32,16 +34,16 @@ ${JSON.stringify(JSON.parse(str), null, 2)}
       console.debug(
         `*** WebSocket incoming message: ***
 ${JSON.stringify(JSON.parse(event.data), null, 2)}
-******`
+******`,
       );
     });
-    ws.addEventListener('open', event => {
+    ws.addEventListener('open', (event) => {
       console.debug('WebSocket open event:', event);
     });
-    ws.addEventListener('error', event => {
+    ws.addEventListener('error', (event) => {
       console.debug('WebSocket error event:', event);
     });
-    ws.addEventListener('close', event => {
+    ws.addEventListener('close', (event) => {
       console.debug('WebSocket close event:', event);
     });
   }
@@ -49,7 +51,7 @@ ${JSON.stringify(JSON.parse(event.data), null, 2)}
   static waitForWebSocketMessage(
     ws: WS,
     matchCondition: (meta: WsgMeta) => boolean,
-    timeout = 60000
+    timeout = 60000,
   ) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return new Promise<[WsgMeta, any, WsgEvent]>((resolve, reject) => {
@@ -60,10 +62,10 @@ ${JSON.stringify(JSON.parse(event.data), null, 2)}
         }
       }, 1000);
       const timeoutHandle = setTimeout(() => {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         ws.removeEventListener('message', handler);
         clearInterval(checkHandle);
         reject(new TimeoutException());
-        return;
       }, timeout);
       const handler = (mEvent: MessageEvent) => {
         const event = mEvent as WsgEvent;
@@ -73,7 +75,6 @@ ${JSON.stringify(JSON.parse(event.data), null, 2)}
           clearInterval(checkHandle);
           clearTimeout(timeoutHandle);
           resolve([meta, body, event]);
-          return;
         }
       };
       ws.addEventListener('message', handler);

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../../../tsconfig.json",
   "compilerOptions": {
-    "outDir": "./lib"
-  }
+    "outDir": "lib"
+  },
+  "include": ["src"]
 }

package/exceptions.ts

@@ -1,25 +0,0 @@
-import {WsgEvent, WsgError, WsgMeta} from './types';
-import Utils from './utils';
-
-export class ConnectionException extends Error {
-  wsgEvent: WsgEvent;
-  wsgError: WsgError;
-  constructor(wsgEvent: WsgEvent) {
-    const [, wsgError]: [WsgMeta, WsgError] = Utils.splitWsgData(wsgEvent.data);
-    super(JSON.stringify(wsgError, null, 2));
-    this.wsgEvent = wsgEvent;
-    this.wsgError = wsgError;
-  }
-}
-
-export class TimeoutException extends Error {
-  constructor(message?: string) {
-    super(message ?? 'Failed to receive expected WebSocket message in time.');
-  }
-}
-
-export class ClosedException extends Error {
-  constructor(message?: string) {
-    super(message ?? 'WebSocket has been closed');
-  }
-}

package/lib/exceptions.d.ts

@@ -1,12 +0,0 @@
-import { WsgEvent, WsgError } from './types';
-export declare class ConnectionException extends Error {
-    wsgEvent: WsgEvent;
-    wsgError: WsgError;
-    constructor(wsgEvent: WsgEvent);
-}
-export declare class TimeoutException extends Error {
-    constructor(message?: string);
-}
-export declare class ClosedException extends Error {
-    constructor(message?: string);
-}