@webex/contact-center 0.0.0-next.1

package/src/services/core/aqm-reqs.ts

@@ -0,0 +1,272 @@
+import {Msg} from './GlobalTypes';
+import * as Err from './Err';
+import {HTTP_METHODS, WebexRequestPayload} from '../../types';
+import LoggerProxy from '../../logger-proxy';
+import {CbRes, Conf, ConfEmpty, Pending, Req, Res, ResEmpty} from './types';
+import {TIMEOUT_REQ, METHODS} from './constants';
+import {AQM_REQS_FILE} from '../../constants';
+import WebexRequest from './WebexRequest';
+import {WebSocketManager} from './websocket/WebSocketManager';
+
+export default class AqmReqs {
+  private pendingRequests: Record<string, Pending> = {};
+  private pendingNotifCancelrequest: Record<string, Pending> = {};
+  private webexRequest: WebexRequest;
+  private webSocketManager: WebSocketManager;
+
+  constructor(webSocketManager: WebSocketManager) {
+    this.webexRequest = WebexRequest.getInstance();
+    this.webSocketManager = webSocketManager;
+    this.webSocketManager.on('message', this.onMessage.bind(this));
+  }
+
+  req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq> {
+    return (p: TReq, cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(p), cbRes);
+  }
+
+  reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes> {
+    return (cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(), cbRes);
+  }
+
+  private async makeAPIRequest<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>): Promise<TRes> {
+    return this.createPromise(c, cbRes);
+  }
+
+  private createPromise<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>) {
+    return new Promise<TRes>((resolve, reject) => {
+      const keySuccess = this.bindPrint(c.notifSuccess.bind);
+      const keyFail = c.notifFail ? this.bindPrint(c.notifFail.bind) : null;
+      const keyCancel = c.notifCancel?.bind ? this.bindPrint(c.notifCancel.bind) : null;
+      let k = '';
+      if (this.pendingRequests[keySuccess]) {
+        k = keySuccess;
+      }
+      if (keyFail && this.pendingRequests[keyFail]) {
+        k += keyFail;
+      }
+      if (k && c.timeout !== 'disabled') {
+        reject(
+          new Err.Details('Service.aqm.reqs.Pending', {
+            key: k,
+            msg: 'The request has been already created, multiple requests are not allowed.',
+          })
+        );
+
+        return;
+      }
+
+      let isClear = false;
+      const clear = () => {
+        delete this.pendingRequests[keySuccess];
+        if (keyFail) {
+          delete this.pendingRequests[keyFail];
+        }
+        if (keyCancel) {
+          delete this.pendingNotifCancelrequest[keyCancel];
+        }
+        isClear = true;
+      };
+
+      this.pendingRequests[keySuccess] = {
+        check: (msg: Msg) => this.bindCheck(c.notifSuccess.bind, msg),
+        handle: (msg: Msg) => {
+          clear();
+          resolve(msg as any);
+        },
+      };
+      if (keyCancel) {
+        this.pendingRequests[keySuccess].alternateBind = keyCancel;
+        this.pendingNotifCancelrequest[keyCancel] = {
+          check: (msg: Msg) => this.bindCheck(c.notifCancel?.bind, msg),
+          handle: (msg: Msg) => {
+            const alternateBindKey = this.pendingNotifCancelrequest[keyCancel].alternateBind;
+            if (alternateBindKey) {
+              this.pendingRequests[alternateBindKey].handle(msg);
+            }
+          },
+          alternateBind: keySuccess,
+        };
+      }
+
+      if (keyFail) {
+        this.pendingRequests[keyFail] = {
+          check: (msg: Msg) => this.bindCheck(c.notifFail!.bind, msg),
+          handle: (msg: Msg) => {
+            clear();
+            const notifFail = c.notifFail!;
+            if ('errId' in notifFail) {
+              LoggerProxy.log(`Routing request failed: ${JSON.stringify(msg)}`, {
+                module: AQM_REQS_FILE,
+                method: METHODS.CREATE_PROMISE,
+              });
+              const eerr = new Err.Details(notifFail.errId, msg as any);
+              LoggerProxy.log(`Routing request failed: ${eerr}`, {
+                module: AQM_REQS_FILE,
+                method: METHODS.CREATE_PROMISE,
+              });
+              reject(eerr);
+            } else {
+              reject(notifFail.err(msg as any));
+            }
+          },
+        };
+      }
+      let response: WebexRequestPayload | null = null;
+      this.webexRequest
+        .request({
+          service: c.host ?? '',
+          resource: c.url,
+          // eslint-disable-next-line no-nested-ternary
+          method: c.method ? c.method : c.data ? HTTP_METHODS.POST : HTTP_METHODS.GET,
+
+          body: c.data,
+        })
+        .then((res: any) => {
+          response = res;
+          if (cbRes) {
+            cbRes(res);
+          }
+        })
+        .catch((error: WebexRequestPayload) => {
+          clear();
+          if (error?.headers) {
+            error.headers.Authorization = '*';
+          }
+          if (error?.headers) {
+            error.headers.Authorization = '*';
+          }
+          if (typeof c.err === 'function') {
+            reject(c.err(error));
+          } else if (typeof c.err === 'string') {
+            reject(new Err.Message(c.err));
+          } else {
+            reject(new Err.Message('Service.aqm.reqs.GenericRequestError'));
+          }
+        });
+
+      if (c.timeout !== 'disabled') {
+        window.setTimeout(
+          () => {
+            if (isClear) {
+              return;
+            }
+            clear();
+            if (response?.headers) {
+              response.headers.Authorization = '*';
+            }
+            LoggerProxy.error(`Routing request timeout${keySuccess}${response!}${c.url}`, {
+              module: AQM_REQS_FILE,
+              method: METHODS.CREATE_PROMISE,
+            });
+            reject(
+              new Err.Details('Service.aqm.reqs.Timeout', {
+                key: keySuccess,
+                response: response!,
+              })
+            );
+          },
+          c.timeout && c.timeout > 0 ? c.timeout : TIMEOUT_REQ
+        );
+      }
+    });
+  }
+
+  private bindPrint(bind: any) {
+    let result = '';
+    // eslint-disable-next-line no-restricted-syntax
+    for (const k in bind) {
+      if (Array.isArray(bind[k])) {
+        result += `${k}=[${bind[k].join(',')}],`;
+      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
+        result += `${k}=(${this.bindPrint(bind[k])}),`;
+      } else {
+        result += `${k}=${bind[k]},`;
+      }
+    }
+
+    return result ? result.slice(0, -1) : result;
+  }
+
+  private bindCheck(bind: any, msg: any) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const k in bind) {
+      if (Array.isArray(bind[k])) {
+        // Check if the message value matches any of the values in the array
+        if (!bind[k].includes(msg[k])) {
+          return false;
+        }
+      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
+        if (typeof msg[k] === 'object' && msg[k] !== null) {
+          if (!this.bindCheck(bind[k], msg[k])) {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      } else if (!msg[k] || msg[k] !== bind[k]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // must be lambda
+  private readonly onMessage = (msg: any) => {
+    const event = JSON.parse(msg);
+    if (event.type === 'Welcome') {
+      LoggerProxy.info(`Welcome message from Notifs Websocket`, {
+        module: AQM_REQS_FILE,
+        method: METHODS.ON_MESSAGE,
+      });
+
+      return;
+    }
+
+    if (event.keepalive === 'true') {
+      LoggerProxy.info(`Keepalive from web socket`, {
+        module: AQM_REQS_FILE,
+        method: METHODS.ON_MESSAGE,
+      });
+
+      return;
+    }
+
+    if (event.type === 'AgentReloginFailed') {
+      LoggerProxy.info('Silently handling the agent relogin fail', {
+        module: AQM_REQS_FILE,
+        method: METHODS.ON_MESSAGE,
+      });
+    }
+
+    let isHandled = false;
+
+    const kReq = Object.keys(this.pendingRequests);
+    for (const thisReq of kReq) {
+      const req = this.pendingRequests[thisReq];
+      if (req.check(event)) {
+        req.handle(event);
+        isHandled = true;
+        break;
+      }
+    }
+    // pendingNotifCancelrequest stores the secondary bind key, checks for the secondary bind key and handles the event
+    const kReqAlt = Object.keys(this.pendingNotifCancelrequest);
+    for (const thisReq of kReqAlt) {
+      const req = this.pendingNotifCancelrequest[thisReq];
+      if (req.check(event)) {
+        req.handle(event);
+        isHandled = true;
+      }
+    }
+
+    // TODO:  add event emitter for unhandled events to replicate event.listen or .on
+
+    if (!isHandled) {
+      LoggerProxy.info(`event=missingEventHandler | [AqmReqs] missing routing message handler`, {
+        module: AQM_REQS_FILE,
+        method: METHODS.ON_MESSAGE,
+      });
+    }
+  };
+}

package/src/services/core/constants.ts

@@ -0,0 +1,106 @@
+/**
+ * Interval in milliseconds for sending keepalive pings to the worker.
+ * @ignore
+ */
+export const KEEPALIVE_WORKER_INTERVAL = 4000;
+
+/**
+ * Delay in milliseconds before resolving notification handlers.
+ * @ignore
+ */
+export const NOTIFS_RESOLVE_DELAY = 1200;
+
+/**
+ * Timeout duration in milliseconds before forcefully closing a WebSocket connection.
+ * @ignore
+ */
+export const CLOSE_SOCKET_TIMEOUT_DURATION = 16000;
+
+/**
+ * API endpoint used for connectivity or health checks.
+ * @ignore
+ */
+export const PING_API_URL = '/health';
+
+/**
+ * Timeout in milliseconds to wait for a welcome message after socket connection.
+ * @ignore
+ */
+export const WELCOME_TIMEOUT = 30000;
+
+/**
+ * Event name used for real-time device (RTD) ping status.
+ * @ignore
+ */
+export const RTD_PING_EVENT = 'rtd-online-status';
+
+/**
+ * Timeout in milliseconds for individual HTTP requests.
+ * @ignore
+ */
+export const TIMEOUT_REQ = 20000;
+
+/**
+ * Duration in milliseconds to wait before attempting lost connection recovery.
+ * @ignore
+ */
+export const LOST_CONNECTION_RECOVERY_TIMEOUT = 50000;
+
+/**
+ * Duration in milliseconds after which a WebSocket disconnect is considered allowed or expected.
+ * @ignore
+ */
+export const WS_DISCONNECT_ALLOWED = 8000;
+
+/**
+ * Interval in milliseconds to check for connectivity status.
+ * @ignore
+ */
+export const CONNECTIVITY_CHECK_INTERVAL = 5000;
+
+/**
+ * Timeout in milliseconds for cleanly closing the WebSocket.
+ * @ignore
+ */
+export const CLOSE_SOCKET_TIMEOUT = 16000;
+
+// Method names for core services
+export const METHODS = {
+  // WebexRequest methods
+  REQUEST: 'request',
+  UPLOAD_LOGS: 'uploadLogs',
+
+  // Utils methods
+  GET_ERROR_DETAILS: 'getErrorDetails',
+  GET_COMMON_ERROR_DETAILS: 'getCommonErrorDetails',
+  CREATE_ERR_DETAILS_OBJECT: 'createErrDetailsObject',
+
+  // AqmReqs methods
+  REQ: 'req',
+  REQ_EMPTY: 'reqEmpty',
+  MAKE_API_REQUEST: 'makeAPIRequest',
+  CREATE_PROMISE: 'createPromise',
+  BIND_PRINT: 'bindPrint',
+  BIND_CHECK: 'bindCheck',
+  ON_MESSAGE: 'onMessage',
+
+  // WebSocketManager methods
+  INIT_WEB_SOCKET: 'initWebSocket',
+  CLOSE: 'close',
+  HANDLE_CONNECTION_LOST: 'handleConnectionLost',
+  REGISTER: 'register',
+  CONNECT: 'connect',
+  WEB_SOCKET_ON_CLOSE_HANDLER: 'webSocketOnCloseHandler',
+
+  // ConnectionService methods
+  SETUP_EVENT_LISTENERS: 'setupEventListeners',
+  DISPATCH_CONNECTION_EVENT: 'dispatchConnectionEvent',
+  CS_HANDLE_CONNECTION_LOST: 'handleConnectionLost',
+  CLEAR_TIMER_ON_RESTORE_FAILED: 'clearTimerOnRestoreFailed',
+  HANDLE_RESTORE_FAILED: 'handleRestoreFailed',
+  UPDATE_CONNECTION_DATA: 'updateConnectionData',
+  SET_CONNECTION_PROP: 'setConnectionProp',
+  ON_PING: 'onPing',
+  HANDLE_SOCKET_CLOSE: 'handleSocketClose',
+  ON_SOCKET_CLOSE: 'onSocketClose',
+};

package/src/services/core/types.ts

@@ -0,0 +1,48 @@
+import {HTTP_METHODS, RequestBody, WebexRequestPayload} from '../../types';
+import * as Err from './Err';
+import {Msg} from './GlobalTypes';
+
+export type Pending = {
+  check: (msg: Msg) => boolean;
+  handle: (msg: Msg) => void;
+  alternateBind?: string;
+};
+
+export type BindType = string | string[] | {[key: string]: BindType};
+interface Bind {
+  type: BindType;
+  data?: any;
+}
+
+export type Timeout = number | 'disabled';
+
+export type Req<TRes, TErr> = {
+  url: string;
+  host?: string;
+  method?: HTTP_METHODS;
+  err?:
+    | ((errObj: WebexRequestPayload) => Err.Details<'Service.reqs.generic.failure'>)
+    | Err.IdsMessage
+    | ((e: WebexRequestPayload) => Err.Message | Err.Details<Err.IdsDetails>);
+  notifSuccess: {bind: Bind; msg: TRes};
+  notifFail?:
+    | {
+        bind: Bind;
+        errMsg: TErr;
+        err: (e: TErr) => Err.Details<Err.IdsDetails>;
+      }
+    | {
+        bind: Bind;
+        errId: Err.IdsDetails;
+      };
+  data?: RequestBody;
+  headers?: Record<string, string>;
+  timeout?: Timeout;
+  notifCancel?: {bind: Bind; msg: TRes};
+};
+
+export type Conf<TRes, TErr, TReq> = (p: TReq) => Req<TRes, TErr>;
+export type ConfEmpty<TRes, TErr> = () => Req<TRes, TErr>;
+export type Res<TRes, TReq> = (p: TReq, cbRes?: CbRes<TRes>) => Promise<TRes>;
+export type ResEmpty<TRes> = (cbRes?: CbRes<TRes>) => Promise<TRes>;
+export type CbRes<TRes> = (res: any) => void | TRes;

package/src/services/core/websocket/WebSocketManager.ts

@@ -0,0 +1,196 @@
+import EventEmitter from 'events';
+import {WebexSDK, SubscribeRequest, HTTP_METHODS} from '../../../types';
+import {SUBSCRIBE_API, WCC_API_GATEWAY} from '../../constants';
+import {ConnectionLostDetails} from './types';
+import {CC_EVENTS, SubscribeResponse, WelcomeResponse} from '../../config/types';
+import LoggerProxy from '../../../logger-proxy';
+import workerScript from './keepalive.worker';
+import {KEEPALIVE_WORKER_INTERVAL, CLOSE_SOCKET_TIMEOUT, METHODS} from '../constants';
+import {WEB_SOCKET_MANAGER_FILE} from '../../../constants';
+
+/**
+ * WebSocketManager handles the WebSocket connection for Contact Center operations.
+ * It manages the connection lifecycle, including registration, reconnection, and message handling.
+ * It also utilizes a Web Worker to manage keepalive messages and socket closure.
+ * @ignore
+ */
+export class WebSocketManager extends EventEmitter {
+  private websocket: WebSocket;
+  shouldReconnect: boolean;
+  isSocketClosed: boolean;
+  private isWelcomeReceived: boolean;
+  private url: string | null = null;
+  private forceCloseWebSocketOnTimeout: boolean;
+  private isConnectionLost: boolean;
+  private webex: WebexSDK;
+  private welcomePromiseResolve:
+    | ((value: WelcomeResponse | PromiseLike<WelcomeResponse>) => void)
+    | null = null;
+
+  private keepaliveWorker: Worker;
+
+  constructor(options: {webex: WebexSDK}) {
+    super();
+    const {webex} = options;
+    this.webex = webex;
+    this.shouldReconnect = true;
+    this.websocket = {} as WebSocket;
+    this.isSocketClosed = false;
+    this.isWelcomeReceived = false;
+    this.forceCloseWebSocketOnTimeout = false;
+    this.isConnectionLost = false;
+
+    const workerScriptBlob = new Blob([workerScript], {type: 'application/javascript'});
+    this.keepaliveWorker = new Worker(URL.createObjectURL(workerScriptBlob));
+  }
+
+  async initWebSocket(options: {body: SubscribeRequest}): Promise<WelcomeResponse> {
+    const connectionConfig = options.body;
+    await this.register(connectionConfig);
+
+    return new Promise((resolve, reject) => {
+      this.welcomePromiseResolve = resolve;
+      this.connect().catch((error) => {
+        LoggerProxy.error(`[WebSocketStatus] | Error in connecting Websocket ${error}`, {
+          module: WEB_SOCKET_MANAGER_FILE,
+          method: METHODS.INIT_WEB_SOCKET,
+        });
+        reject(error);
+      });
+    });
+  }
+
+  close(shouldReconnect: boolean, reason = 'Unknown') {
+    if (!this.isSocketClosed && this.shouldReconnect) {
+      this.shouldReconnect = shouldReconnect;
+      this.websocket.close();
+      this.keepaliveWorker.postMessage({type: 'terminate'});
+      LoggerProxy.log(
+        `[WebSocketStatus] | event=webSocketClose | WebSocket connection closed manually REASON: ${reason}`,
+        {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CLOSE}
+      );
+    }
+  }
+
+  handleConnectionLost(event: ConnectionLostDetails) {
+    this.isConnectionLost = event.isConnectionLost;
+  }
+
+  private async register(connectionConfig: SubscribeRequest) {
+    try {
+      const subscribeResponse: SubscribeResponse = await this.webex.request({
+        service: WCC_API_GATEWAY,
+        resource: SUBSCRIBE_API,
+        method: HTTP_METHODS.POST,
+        body: connectionConfig,
+      });
+      this.url = subscribeResponse.body.webSocketUrl;
+    } catch (e) {
+      LoggerProxy.error(
+        `Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`,
+        {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.REGISTER}
+      );
+    }
+  }
+
+  private async connect() {
+    if (!this.url) {
+      return undefined;
+    }
+    LoggerProxy.log(
+      `[WebSocketStatus] | event=webSocketConnecting | Connecting to WebSocket: ${this.url}`,
+      {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}
+    );
+    this.websocket = new WebSocket(this.url);
+
+    return new Promise((resolve, reject) => {
+      this.websocket.onopen = () => {
+        this.isSocketClosed = false;
+        this.shouldReconnect = true;
+
+        this.websocket.send(JSON.stringify({keepalive: 'true'}));
+        this.keepaliveWorker.onmessage = (keepAliveEvent: {data: any}) => {
+          if (keepAliveEvent?.data?.type === 'keepalive') {
+            this.websocket.send(JSON.stringify({keepalive: 'true'}));
+          }
+
+          if (keepAliveEvent?.data?.type === 'closeSocket' && this.isConnectionLost) {
+            this.forceCloseWebSocketOnTimeout = true;
+            this.close(true, 'WebSocket did not auto close within 16 secs');
+            LoggerProxy.error(
+              '[webSocketTimeout] | event=webSocketTimeout | WebSocket connection closed forcefully',
+              {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}
+            );
+          }
+        };
+
+        this.keepaliveWorker.postMessage({
+          type: 'start',
+          intervalDuration: KEEPALIVE_WORKER_INTERVAL, // Keepalive interval
+          isSocketClosed: this.isSocketClosed,
+          closeSocketTimeout: CLOSE_SOCKET_TIMEOUT, // Close socket timeout
+        });
+      };
+
+      this.websocket.onerror = (event: any) => {
+        LoggerProxy.error(
+          `[WebSocketStatus] | event=socketConnectionFailed | WebSocket connection failed ${event}`,
+          {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}
+        );
+        reject();
+      };
+
+      this.websocket.onclose = async (event: any) => {
+        this.webSocketOnCloseHandler(event);
+      };
+
+      this.websocket.onmessage = (e: MessageEvent) => {
+        this.emit('message', e.data);
+        const eventData = JSON.parse(e.data);
+
+        if (eventData.type === CC_EVENTS.WELCOME) {
+          this.isWelcomeReceived = true;
+          if (this.welcomePromiseResolve) {
+            this.welcomePromiseResolve(eventData.data as WelcomeResponse);
+            this.welcomePromiseResolve = null;
+          }
+        }
+
+        if (eventData.type === 'AGENT_MULTI_LOGIN') {
+          this.close(false, 'multiLogin');
+          LoggerProxy.error(
+            '[WebSocketStatus] | event=agentMultiLogin | WebSocket connection closed by agent multiLogin',
+            {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}
+          );
+        }
+      };
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private async webSocketOnCloseHandler(event: any) {
+    this.isSocketClosed = true;
+    this.keepaliveWorker.postMessage({type: 'terminate'});
+    if (this.shouldReconnect) {
+      this.emit('socketClose');
+      let issueReason;
+      if (this.forceCloseWebSocketOnTimeout) {
+        issueReason = 'WebSocket auto close timed out. Forcefully closed websocket.';
+      } else {
+        const onlineStatus = navigator.onLine;
+        LoggerProxy.info(`[WebSocketStatus] | desktop online status is ${onlineStatus}`, {
+          module: WEB_SOCKET_MANAGER_FILE,
+          method: METHODS.WEB_SOCKET_ON_CLOSE_HANDLER,
+        });
+        issueReason = !onlineStatus
+          ? 'network issue'
+          : 'missing keepalive from either desktop or notif service';
+      }
+      LoggerProxy.error(
+        `[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: ${issueReason}`,
+        {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.WEB_SOCKET_ON_CLOSE_HANDLER}
+      );
+      this.forceCloseWebSocketOnTimeout = false;
+    }
+  }
+}