@webex/contact-center 3.12.0-next.9 → 3.12.0-task-refactor.1

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

@@ -20,40 +20,18 @@ export default class AqmReqs {
     this.webSocketManager.on('message', this.onMessage.bind(this));
   }
 
-  /**
-   * Creates a request function for an API call with parameters
-   * @param c - The configuration for the request
-   * @returns A function that makes the API request
-   */
   req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq> {
     return (p: TReq, cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(p), cbRes);
   }
 
-  /**
-   * Creates a request function for an API call with no parameters
-   * @param c - The configuration for the request
-   * @returns A function that makes the API request
-   */
   reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes> {
     return (cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(), cbRes);
   }
 
-  /**
-   * Makes an API request
-   * @param c - The request configuration
-   * @param cbRes - The callback for the response
-   * @returns A promise that resolves with the response or rejects with an error
-   */
   private async makeAPIRequest<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>): Promise<TRes> {
     return this.createPromise(c, cbRes);
   }
 
-  /**
-   * Creates a promise for an API request
-   * @param c - The request configuration
-   * @param cbRes - The callback for the response
-   * @returns A promise that resolves with the response or rejects with an error
-   */
   private createPromise<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>) {
     return new Promise<TRes>((resolve, reject) => {
       const keySuccess = this.bindPrint(c.notifSuccess.bind);
@@ -176,13 +154,10 @@ export default class AqmReqs {
             if (response?.headers) {
               response.headers.Authorization = '*';
             }
-            LoggerProxy.error(
-              `Routing request timeout${keySuccess}${JSON.stringify(response)}${c.url}`,
-              {
-                module: AQM_REQS_FILE,
-                method: METHODS.CREATE_PROMISE,
-              }
-            );
+            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,
@@ -196,60 +171,39 @@ export default class AqmReqs {
     });
   }
 
-  /**
-   * Converts a bind object to a string representation
-   * @param bind - The bind object to convert
-   * @returns A string representation of the bind object
-   */
-  private bindPrint(bind: any): string {
+  private bindPrint(bind: any) {
     let result = '';
-    for (const key of Object.keys(bind).filter((prop) => prop !== '__typeMap')) {
-      const value = bind[key];
-
-      if (Array.isArray(value)) {
-        result += `${key}=[${value.join(',')}],`;
-      } else if (typeof value === 'object' && value !== null) {
-        result += `${key}=(${this.bindPrint(value)}),`;
+    // 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 += `${key}=${value},`;
+        result += `${k}=${bind[k]},`;
       }
     }
 
     return result ? result.slice(0, -1) : result;
   }
 
-  /**
-   * Checks if a message matches a bind object
-   * @param bind - The bind object to check against
-   * @param msg - The message to check
-   * @returns True if the message matches the bind object, false otherwise
-   */
-  private bindCheck(bind: any, msg: any): boolean {
-    // Handle type-dependent field matching if __typeMap is present
-    if (bind.__typeMap && typeof bind.__typeMap === 'object') {
-      if (!AqmReqs.typeMapCheck(bind.__typeMap, msg)) {
-        return false;
-      }
-    }
-
-    for (const key of Object.keys(bind).filter((prop) => prop !== '__typeMap')) {
-      const bindValue = bind[key];
-      const msgValue = msg[key];
-
-      if (Array.isArray(bindValue)) {
+  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 (!bindValue.includes(msgValue)) {
+        if (!bind[k].includes(msg[k])) {
           return false;
         }
-      } else if (typeof bindValue === 'object' && bindValue !== null) {
-        if (typeof msgValue === 'object' && msgValue !== null) {
-          if (!this.bindCheck(bindValue, msgValue)) {
+      } 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 (!msgValue || msgValue !== bindValue) {
+      } else if (!msg[k] || msg[k] !== bind[k]) {
         return false;
       }
     }
@@ -257,39 +211,7 @@ export default class AqmReqs {
     return true;
   }
 
-  /**
-   * Checks type-dependent field conditions defined in __typeMap.
-   * @param typeMap - The type map to check against
-   * @param msg - The message to check
-   * @returns True if the message matches the type map, false otherwise
-   * The typeMap has the shape:
-   *   { typeField: "type", conditions: { EventA: { field: value }, EventB: { field: value } } }
-   * It reads msg[typeField] to determine which condition set to apply,
-   * then verifies all fields in that condition match the message.
-   */
-  private static typeMapCheck(typeMap: any, msg: any): boolean {
-    const typeField = typeMap.typeField || 'type';
-    const msgType = msg[typeField];
-
-    if (typeMap.conditions && typeMap.conditions[msgType]) {
-      const condition = typeMap.conditions[msgType];
-      for (const field of Object.keys(condition)) {
-        if (!msg[field] || msg[field] !== condition[field]) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Handles incoming messages from the WebSocket (must be a lambda fn)
-   * @param msg - The message to handle
-   * @returns
-   */
+  // must be lambda
   private readonly onMessage = (msg: any) => {
     const event = JSON.parse(msg);
     if (event.type === 'Welcome') {

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

@@ -48,16 +48,8 @@ export class WebSocketManager extends EventEmitter {
     body: SubscribeRequest;
     resource: string;
   }): Promise<WelcomeResponse> {
-    const {body: connectionConfig, resource} = options;
-    try {
-      await this.register(connectionConfig, resource);
-    } catch (error) {
-      LoggerProxy.error(`[WebSocketStatus] | Error in registering Websocket ${error}`, {
-        module: WEB_SOCKET_MANAGER_FILE,
-        method: METHODS.INIT_WEB_SOCKET,
-      });
-      throw error;
-    }
+    const {body, resource} = options;
+    await this.register(body, resource);
 
     return new Promise((resolve, reject) => {
       this.welcomePromiseResolve = resolve;
@@ -89,23 +81,11 @@ export class WebSocketManager extends EventEmitter {
 
   private async register(connectionConfig: SubscribeRequest, resource: string) {
     try {
-      // X-ORGANIZATION-ID header is only required for INT environments
-      const isIntEnv = this.webex.internal?.services?.isIntegrationEnvironment() || false;
-      const orgId = this.webex.credentials.getOrgId();
-
-      if (isIntEnv && orgId) {
-        LoggerProxy.log(`[WebSocketManager] Adding X-ORGANIZATION-ID header for INT environment`, {
-          module: WEB_SOCKET_MANAGER_FILE,
-          method: METHODS.REGISTER,
-        });
-      }
-
       const subscribeResponse: SubscribeResponse = await this.webex.request({
         service: WCC_API_GATEWAY,
         resource,
         method: HTTP_METHODS.POST,
         body: connectionConfig,
-        headers: isIntEnv && orgId ? {'X-ORGANIZATION-ID': orgId} : undefined,
       });
       this.url = subscribeResponse.body.webSocketUrl;
     } catch (e) {
@@ -113,7 +93,6 @@ export class WebSocketManager extends EventEmitter {
         `Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`,
         {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.REGISTER}
       );
-      throw e;
     }
   }
 
@@ -214,3 +193,5 @@ export class WebSocketManager extends EventEmitter {
     }
   }
 }
+
+export default WebSocketManager;

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

@@ -1,5 +1,5 @@
 import {SubscribeRequest} from '../../../types';
-import {WebSocketManager} from './WebSocketManager';
+import type WebSocketManager from './WebSocketManager';
 
 /**
  * Options for initializing a connection service.

package/src/services/index.ts

@@ -25,7 +25,7 @@ export default class Services {
   public readonly dialer: ReturnType<typeof aqmDialer>;
   /** WebSocket manager for handling real-time communications */
   public readonly webSocketManager: WebSocketManager;
-  /** RTD WebSocket manager for handling realtime transcription */
+  /** RTD WebSocket manager for handling real-time transcription */
   public readonly rtdWebSocketManager: WebSocketManager;
   /** Connection service for managing websocket connections */
   public readonly connectionService: ConnectionService;
@@ -41,7 +41,6 @@ export default class Services {
   constructor(options: {webex: WebexSDK; connectionConfig: SubscribeRequest}) {
     const {webex, connectionConfig} = options;
     this.webSocketManager = new WebSocketManager({webex});
-    // TODO: Implement reconnection logic for this websocket in upcoming PR
     this.rtdWebSocketManager = new WebSocketManager({webex});
     const aqmReq = new AqmReqs(this.webSocketManager);
     this.config = new AgentConfigService();