@webex/contact-center 3.9.0 → 3.10.0-next.1

package/src/utils/PageCache.ts

@@ -0,0 +1,252 @@
+import LoggerProxy from '../logger-proxy';
+
+/**
+ * Common pagination metadata interface used across all APIs.
+ * @public
+ * @template T - Additional metadata properties specific to the API
+ */
+export interface PaginationMeta {
+  /** Organization ID */
+  orgid?: string;
+  /** Current page number */
+  page?: number;
+  /** Page size for current data set */
+  pageSize?: number;
+  /** Number of pages */
+  totalPages?: number;
+  /** Total number of items */
+  totalRecords?: number;
+  /** Total number of items (alias for compatibility) */
+  totalItems?: number;
+  /** Current page number (alias for compatibility) */
+  currentPage?: number;
+  /** Map of pagination links */
+  links?: Record<string, string>;
+}
+
+/**
+ * Common paginated response interface used across all APIs.
+ * @public
+ * @template T - The type of data items in the response
+ */
+export interface PaginatedResponse<T> {
+  /** Array of data items */
+  data: T[];
+  /** Pagination metadata */
+  meta: PaginationMeta;
+}
+
+/**
+ * Common search and pagination parameters interface.
+ * @public
+ */
+export interface BaseSearchParams {
+  /** Search keyword */
+  search?: string;
+  /** Filter criteria using RSQL syntax */
+  filter?: string;
+  /** Attributes to be returned */
+  attributes?: string;
+  /** Page number (starts from 0) */
+  page?: number;
+  /** Number of items per page */
+  pageSize?: number;
+  /** Sort field */
+  sortBy?: string;
+  /** Sort direction */
+  sortOrder?: 'asc' | 'desc';
+}
+
+/**
+ * Default pagination constants used across all APIs.
+ * @public
+ */
+export const PAGINATION_DEFAULTS = {
+  /** Default page number */
+  PAGE: 0,
+  /** Default page size */
+  PAGE_SIZE: 100,
+} as const;
+
+/**
+ * Interface for cached page entry with metadata
+ * @public
+ */
+export interface PageCacheEntry<T> {
+  /** Cached data items for this page */
+  data: T[];
+  /** Timestamp when this page was cached */
+  timestamp: number;
+  /** Total metadata if available */
+  totalMeta?: {
+    totalPages?: number;
+    totalRecords?: number;
+  };
+}
+
+/**
+ * Interface for cache validation parameters
+ * @public
+ */
+export interface CacheValidationParams {
+  /** Search query parameter */
+  search?: string;
+  /** Filter parameter */
+  filter?: string;
+  /** Attributes parameter */
+  attributes?: string;
+  /** Sort by parameter */
+  sortBy?: string;
+}
+
+/**
+ * Default cache TTL in minutes
+ */
+const DEFAULT_CACHE_TTL_MINUTES = 5;
+
+/**
+ * Page cache utility class for managing paginated API response caching.
+ * Provides consistent caching behavior across all Contact Center APIs.
+ *
+ * @class PageCache
+ * @public
+ * @template T - The type of data items being cached
+ * @example
+ * ```typescript
+ * // Create a cache instance for a specific data type
+ * const cache = new PageCache<AddressBookEntry>('AddressBook');
+ *
+ * // Check if we can use cache (no search/filter parameters)
+ * if (cache.canUseCache({ search, filter })) {
+ *   const cacheKey = cache.buildCacheKey(orgId, page, pageSize);
+ *   const cachedPage = cache.getCachedPage(cacheKey);
+ *
+ *   if (cachedPage) {
+ *     return cachedPage.data;
+ *   }
+ * }
+ *
+ * // Cache API response
+ * cache.cachePage(cacheKey, responseData, responseMeta);
+ * ```
+ */
+export class PageCache<T> {
+  private cache: Map<string, PageCacheEntry<T>> = new Map();
+  private apiName: string;
+
+  /**
+   * Creates an instance of PageCache
+   * @param {string} apiName - Name of the API using this cache (for logging)
+   * @public
+   */
+  constructor(apiName: string) {
+    this.apiName = apiName;
+  }
+
+  /**
+   * Checks if cache can be used for the given parameters.
+   * Cache is only used for simple pagination without search/filter/attributes/sort.
+   * @param {CacheValidationParams} params - Parameters to validate
+   * @returns {boolean} True if cache can be used
+   * @public
+   */
+  public canUseCache(params: CacheValidationParams): boolean {
+    const {search, filter, attributes, sortBy} = params;
+
+    return !search && !filter && !attributes && !sortBy;
+  }
+
+  /**
+   * Builds a cache key for the given parameters
+   * @param {string} orgId - Organization ID
+   * @param {number} page - Page number
+   * @param {number} pageSize - Page size
+   * @returns {string} Cache key
+   * @public
+   */
+  public buildCacheKey(orgId: string, page: number, pageSize: number): string {
+    return `${orgId}:${page}:${pageSize}`;
+  }
+
+  /**
+   * Gets a cached page if it exists and is valid
+   * @param {string} cacheKey - Cache key to look up
+   * @returns {PageCacheEntry<T> | null} Cached page entry or null if not found/expired
+   * @public
+   */
+  public getCachedPage(cacheKey: string): PageCacheEntry<T> | null {
+    const cachedEntry = this.cache.get(cacheKey);
+
+    if (!cachedEntry) {
+      return null;
+    }
+
+    // Check if cache entry is expired
+    const now = Date.now();
+    const cacheAge = (now - cachedEntry.timestamp) / (1000 * 60); // in minutes
+
+    if (cacheAge >= DEFAULT_CACHE_TTL_MINUTES) {
+      LoggerProxy.log(`Cache entry expired for key: ${cacheKey}`, {
+        module: this.apiName,
+        method: 'getCachedPage',
+      });
+      this.cache.delete(cacheKey);
+
+      return null;
+    }
+
+    return cachedEntry;
+  }
+
+  /**
+   * Caches a page of data with metadata
+   * @param {string} cacheKey - Cache key
+   * @param {T[]} data - Data items to cache
+   * @param {any} meta - Metadata from API response
+   * @public
+   */
+  public cachePage(cacheKey: string, data: T[], meta?: any): void {
+    const cacheEntry: PageCacheEntry<T> = {
+      data,
+      timestamp: Date.now(),
+      totalMeta: meta
+        ? {
+            totalPages: meta.totalPages,
+            totalRecords: meta.totalRecords || meta.totalItems,
+          }
+        : undefined,
+    };
+
+    this.cache.set(cacheKey, cacheEntry);
+
+    LoggerProxy.log(`Cached page with ${data.length} items for key: ${cacheKey}`, {
+      module: this.apiName,
+      method: 'cachePage',
+    });
+  }
+
+  /**
+   * Clears all cached entries
+   * @public
+   */
+  public clearCache(): void {
+    const cacheSize = this.cache.size;
+    this.cache.clear();
+
+    LoggerProxy.log(`Cleared ${cacheSize} cache entries`, {
+      module: this.apiName,
+      method: 'clearCache',
+    });
+  }
+
+  /**
+   * Gets the current number of cached entries
+   * @returns {number} Number of cached entries
+   * @public
+   */
+  public getCacheSize(): number {
+    return this.cache.size;
+  }
+}
+
+export default PageCache;

package/test/unit/spec/cc.ts

@@ -7,6 +7,11 @@ import {
   WebexSDK,
 } from '../../../src/types';
 import ContactCenter from '../../../src/cc';
+import EntryPoint from '../../../src/services/EntryPoint';
+import type {EntryPointListResponse} from '../../../src/types';
+import AddressBook from '../../../src/services/AddressBook';
+import Queue from '../../../src/services/Queue';
+import type {ContactServiceQueuesResponse} from '../../../src/types';
 import MockWebex from '@webex/test-helper-mock-webex';
 import {StationLoginSuccess, AGENT_EVENTS} from '../../../src/services/agent/types';
 import {SetStateResponse} from '../../../src/types';
@@ -113,6 +118,7 @@ describe('webex.cc', () => {
       },
       config: {
         getAgentConfig: jest.fn(),
+        getOutdialAniEntries: jest.fn(),
       },
       webSocketManager: mockWebSocketManager,
       connectionService: {
@@ -134,6 +140,7 @@ describe('webex.cc', () => {
       webSocketManager: mockWebSocketManager,
       task: undefined,
       setWrapupData: jest.fn(),
+      setAgentId: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),
@@ -155,7 +162,7 @@ describe('webex.cc', () => {
     };
 
     jest.spyOn(MetricsManager, 'getInstance').mockReturnValue(mockMetricsManager);
-    jest.spyOn(Services, 'getInstance').mockReturnValue(mockServicesInstance);
+    jest.spyOn(Services, 'getInstance').mockReturnValue(mockServicesInstance as any);
     jest.spyOn(TaskManager, 'getTaskManager').mockReturnValue(mockTaskManager);
     jest.spyOn(WebexRequest, 'getInstance').mockReturnValue(mockWebexRequest);
     // Instantiate ContactCenter to ensure it's fully initialized
@@ -1310,7 +1317,7 @@ describe('webex.cc', () => {
   });
 
   describe('startOutdial', () => {
-    it('should make outdial call successfully.', async () => {
+    it('should make outdial call successfully without origin.', async () => {
       // Setup outDialEp.
       webex.cc.agentConfig = {
         outDialEp: 'test-entry-point',
@@ -1319,9 +1326,10 @@ describe('webex.cc', () => {
       // destination number required for making outdial call.
       const destination = '1234567890';
 
-      // Construct Payload for startOutdial.
+      // Construct Payload for startOutdial without origin.
       const newPayload = {
         destination,
+        origin: undefined,
         entryPointId: 'test-entry-point',
         direction: OUTDIAL_DIRECTION,
         attributes: ATTRIBUTES,
@@ -1351,6 +1359,49 @@ describe('webex.cc', () => {
       expect(result).toEqual(mockResponse);
     });
 
+    it('should make outdial call successfully with origin.', async () => {
+      // Setup outDialEp.
+      webex.cc.agentConfig = {
+        outDialEp: 'test-entry-point',
+      };
+
+      // destination number and origin for making outdial call.
+      const destination = '1234567890';
+      const origin = '+19403016307';
+
+      // Construct Payload for startOutdial with origin.
+      const newPayload = {
+        destination,
+        origin,
+        entryPointId: 'test-entry-point',
+        direction: OUTDIAL_DIRECTION,
+        attributes: ATTRIBUTES,
+        mediaType: OUTDIAL_MEDIA_TYPE,
+        outboundType: OUTBOUND_TYPE,
+      } as const;
+
+      const mockResponse = {} as AgentContact;
+
+      const startOutdialMock = jest
+        .spyOn(webex.cc.services.dialer, 'startOutdial')
+        .mockResolvedValue(mockResponse);
+
+      const result = await webex.cc.startOutdial(destination, origin);
+
+      // Verify logging calls
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Starting outbound dial', {
+        module: CC_FILE,
+        method: 'startOutdial',
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith('Outbound dial completed successfully', {
+        module: CC_FILE,
+        method: 'startOutdial',
+      });
+
+      expect(startOutdialMock).toHaveBeenCalledWith({data: newPayload});
+      expect(result).toEqual(mockResponse);
+    });
+
     it('should handle error during startOutdial', async () => {
       // Setup outDialEp.
       webex.cc.agentConfig = {
@@ -1387,88 +1438,6 @@ describe('webex.cc', () => {
     });
   });
 
-  describe('getQueues', () => {
-    it('should return queues response when successful', async () => {
-      const mockQueuesResponse = [
-        {
-          queueId: 'queue1',
-          queueName: 'Queue 1',
-        },
-        {
-          queueId: 'queue2',
-          queueName: 'Queue 2',
-        },
-      ];
-
-      webex.cc.services.config.getQueues = jest.fn().mockResolvedValue(mockQueuesResponse);
-
-      const result = await webex.cc.getQueues();
-
-      // Verify logging calls
-      expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queues', {
-        module: CC_FILE,
-        method: 'getQueues',
-      });
-      expect(LoggerProxy.log).toHaveBeenCalledWith(
-        `Successfully retrieved ${result.length} queues`,
-        {
-          module: CC_FILE,
-          method: 'getQueues',
-        }
-      );
-
-      expect(webex.cc.services.config.getQueues).toHaveBeenCalledWith(
-        'mockOrgId',
-        0,
-        100,
-        undefined,
-        undefined
-      );
-      expect(result).toEqual(mockQueuesResponse);
-    });
-
-    it('should throw an error if orgId is not present', async () => {
-      jest.spyOn(webex.credentials, 'getOrgId').mockResolvedValue(undefined);
-      webex.cc.services.config.getQueues = jest.fn();
-
-      try {
-        await webex.cc.getQueues();
-      } catch (error) {
-        expect(error).toEqual(new Error('Org ID not found.'));
-        expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queues', {
-          module: CC_FILE,
-          method: 'getQueues',
-        });
-        expect(LoggerProxy.error).toHaveBeenCalledWith('Org ID not found.', {
-          module: CC_FILE,
-          method: 'getQueues',
-        });
-        expect(webex.cc.services.config.getQueues).not.toHaveBeenCalled();
-      }
-    });
-
-    it('should throw an error if config getQueues throws an error', async () => {
-      webex.cc.services.config.getQueues = jest.fn().mockRejectedValue(new Error('Test error.'));
-
-      try {
-        await webex.cc.getQueues();
-      } catch (error) {
-        expect(error).toEqual(new Error('Test error.'));
-        expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queues', {
-          module: CC_FILE,
-          method: 'getQueues',
-        });
-        expect(webex.cc.services.config.getQueues).toHaveBeenCalledWith(
-          'mockOrgId',
-          0,
-          100,
-          undefined,
-          undefined
-        );
-      }
-    });
-  });
-
   describe('uploadLogs', () => {
     it('should upload logs successfully', async () => {
       const uploadLogsMock = jest.spyOn(webex.cc.webexRequest, 'uploadLogs').mockResolvedValue({
@@ -1796,6 +1765,31 @@ describe('webex.cc', () => {
     });
   });
 
+  describe('API property exposure', () => {
+    it('should provide getEntryPoints wrapper that delegates to EntryPoint', async () => {
+      const spy = jest
+        .spyOn(EntryPoint.prototype, 'getEntryPoints')
+        .mockResolvedValue({} as EntryPointListResponse);
+      await webex.cc.getEntryPoints();
+      expect(spy).toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('should expose addressBook API', () => {
+      expect(webex.cc.addressBook).toBeDefined();
+      expect(webex.cc.addressBook).toBeInstanceOf(AddressBook);
+    });
+
+    it('should provide getQueues wrapper that delegates to Queue', async () => {
+      const spy = jest
+        .spyOn(Queue.prototype, 'getQueues')
+        .mockResolvedValue({} as ContactServiceQueuesResponse);
+      await webex.cc.getQueues();
+      expect(spy).toHaveBeenCalled();
+      spy.mockRestore();
+    });
+  });
+
   describe('updateAgentProfile', () => {
     beforeEach(() => {
       webex.cc.agentConfig = {
@@ -1982,4 +1976,207 @@ describe('webex.cc', () => {
       });
     });
   });
+
+  describe('getOutdialAniEntries', () => {
+    const mockOutdialANI = 'ani-123-456';
+    const mockParams = {
+      outdialANI: mockOutdialANI,
+      page: 0,
+      pageSize: 10,
+      search: 'test',
+      filter: 'active=true',
+      attributes: 'id,name,number',
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      // Reset orgId mock to return valid value
+      webex.credentials.getOrgId.mockReturnValue('mockOrgId');
+    });
+
+    it('should successfully fetch outdial ANI entries and track success metrics', async () => {
+      const mockResult = [
+        {
+          id: '142fba3c-8502-4446-bf6e-584fd657553a',
+          name: 'Test Entry',
+          number: '+19403016307',
+        },
+        {
+          id: '6f53000b-e04a-4418-9de9-ba511d2367cb',
+          name: 'Another Entry',
+          number: '+19403016308',
+        },
+      ];
+
+      // Mock the service call to return successful result
+      webex.cc.services.config.getOutdialAniEntries.mockResolvedValue(mockResult);
+
+      const result = await webex.cc.getOutdialAniEntries(mockParams);
+
+      // Verify the service was called with correct parameters
+      expect(webex.cc.services.config.getOutdialAniEntries).toHaveBeenCalledWith('mockOrgId', {
+        outdialANI: mockOutdialANI,
+        page: 0,
+        pageSize: 10,
+        search: 'test',
+        filter: 'active=true',
+        attributes: 'id,name,number',
+      });
+
+      // Verify the result is returned correctly
+      expect(result).toEqual(mockResult);
+
+      // Verify success metrics are tracked
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.OUTDIAL_ANI_EP_FETCH_SUCCESS,
+        {
+          outdialANI: mockOutdialANI,
+          resultCount: 2,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+
+      // Verify success logging
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        `Successfully retrieved outdial ANI entries for ANI ID ${mockOutdialANI}`,
+        {
+          module: CC_FILE,
+          method: 'getOutdialAniEntries',
+        }
+      );
+    });
+
+    it('should handle empty results and track success metrics with zero count', async () => {
+      const mockResult = [];
+
+      // Mock the service call to return empty result
+      webex.cc.services.config.getOutdialAniEntries.mockResolvedValue(mockResult);
+
+      const result = await webex.cc.getOutdialAniEntries({outdialANI: mockOutdialANI});
+
+      // Verify the result is returned correctly
+      expect(result).toEqual(mockResult);
+
+      // Verify success metrics are tracked with zero count
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.OUTDIAL_ANI_EP_FETCH_SUCCESS,
+        {
+          outdialANI: mockOutdialANI,
+          resultCount: 0,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+    });
+
+    it('should handle undefined results and track success metrics with zero count', async () => {
+      // Mock the service call to return undefined
+      webex.cc.services.config.getOutdialAniEntries.mockResolvedValue(undefined);
+
+      const result = await webex.cc.getOutdialAniEntries({outdialANI: mockOutdialANI});
+
+      // Verify the result is returned correctly
+      expect(result).toBeUndefined();
+
+      // Verify success metrics are tracked with zero count
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.OUTDIAL_ANI_EP_FETCH_SUCCESS,
+        {
+          outdialANI: mockOutdialANI,
+          resultCount: 0,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+    });
+
+    it('should handle service failure and track failure metrics', async () => {
+      const mockError = new Error('Service unavailable') as any;
+      mockError.details = {
+        trackingId: 'test-tracking-id',
+        orgId: 'mockOrgId',
+        error: 'Service error',
+      };
+
+      // Mock the service call to throw an error
+      webex.cc.services.config.getOutdialAniEntries.mockRejectedValue(mockError);
+
+      // Mock getErrorDetails to return a detailed error
+      const detailedError = new Error('Detailed service error');
+      getErrorDetailsSpy.mockReturnValue({error: detailedError});
+
+      await expect(webex.cc.getOutdialAniEntries(mockParams)).rejects.toThrow('Detailed service error');
+
+      // Verify failure metrics are tracked
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.OUTDIAL_ANI_EP_FETCH_FAILED,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(mockError.details),
+          outdialANI: mockOutdialANI,
+          error: mockError,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+
+      // Verify error logging
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        `Failed to fetch outdial ANI entries for ANI ID ${mockOutdialANI} due to: ${mockError}`,
+        {
+          module: CC_FILE,
+          method: 'getOutdialAniEntries',
+          trackingId: 'test-tracking-id',
+        }
+      );
+
+      // Verify getErrorDetails was called
+      expect(getErrorDetailsSpy).toHaveBeenCalledWith(
+        mockError,
+        'getOutdialAniEntries',
+        CC_FILE
+      );
+    });
+
+    it('should throw error when orgId is not found', async () => {
+      // Mock getOrgId to return null
+      webex.credentials.getOrgId.mockReturnValue(null);
+
+      await expect(webex.cc.getOutdialAniEntries(mockParams)).rejects.toThrow('Org ID not found.');
+
+      // Verify error logging
+      expect(LoggerProxy.error).toHaveBeenCalledWith('Org ID not found.', {
+        module: CC_FILE,
+        method: 'getOutdialAniEntries',
+      });
+
+      // Verify service was not called
+      expect(webex.cc.services.config.getOutdialAniEntries).not.toHaveBeenCalled();
+
+      // Verify no metrics were tracked
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should handle minimal parameters correctly', async () => {
+      const minimalParams = {outdialANI: mockOutdialANI};
+      const mockResult = [{id: 'test', name: 'Test', number: '+1234567890'}];
+
+      webex.cc.services.config.getOutdialAniEntries.mockResolvedValue(mockResult);
+
+      const result = await webex.cc.getOutdialAniEntries(minimalParams);
+
+      // Verify the service was called with minimal parameters
+      expect(webex.cc.services.config.getOutdialAniEntries).toHaveBeenCalledWith('mockOrgId', {
+        outdialANI: mockOutdialANI,
+      });
+
+      expect(result).toEqual(mockResult);
+
+      // Verify success metrics are tracked
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.OUTDIAL_ANI_EP_FETCH_SUCCESS,
+        {
+          outdialANI: mockOutdialANI,
+          resultCount: 1,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+    });
+  });
 });

package/test/unit/spec/metrics/MetricsManager.ts

@@ -3,7 +3,6 @@ import MetricsManager from '../../../../src/metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
 import {WebexSDK} from '../../../../src/types';
 import {EventPayload} from '@webex/internal-plugin-metrics/src/metrics.types';
-import LoggerProxy from '../../../../src/logger-proxy';
 
 describe('MetricsManagerImplementation', () => {
   let webex: WebexSDK;