@webex/webex-core 3.8.1 → 3.9.0-multi-llms.2

package/src/lib/services-v2/{services-v2.js → services-v2.ts}

@@ -1,12 +1,20 @@
 import sha256 from 'crypto-js/sha256';
 
-import {union, unionBy} from 'lodash';
+import {toNumber, union, unionBy} from 'lodash';
 import WebexPlugin from '../webex-plugin';
 
-import METRICS from './metrics';
+import METRICS from '../metrics';
 import ServiceCatalog from './service-catalog';
 import fedRampServices from './service-fed-ramp';
-import {COMMERCIAL_ALLOWED_DOMAINS} from './constants';
+import {COMMERCIAL_ALLOWED_DOMAINS} from '../constants';
+import {
+  ActiveServices,
+  IServiceCatalog,
+  QueryOptions,
+  Service,
+  ServiceHostmap,
+  ServiceGroup,
+} from './types';
 
 const trailingSlashes = /(?:^\/)|(?:\/$)/;
 
@@ -41,9 +49,9 @@ const Services = WebexPlugin.extend({
    * @private
    * Get the current catalog based on the assocaited
    * webex instance.
-   * @returns {ServiceCatalog}
+   * @returns {IServiceCatalog}
    */
-  _getCatalog() {
+  _getCatalog(): IServiceCatalog {
     return this._catalogs.get(this.webex);
   },
 
@@ -51,14 +59,23 @@ const Services = WebexPlugin.extend({
    * Get a service url from the current services list by name
    * from the associated instance catalog.
    * @param {string} name
-   * @param {boolean} [priorityHost]
-   * @param {string} [serviceGroup]
+   * @param {ServiceGroup} [serviceGroup]
    * @returns {string|undefined}
    */
-  get(name, priorityHost, serviceGroup) {
+  get(name: string, serviceGroup?: ServiceGroup): string | undefined {
     const catalog = this._getCatalog();
 
-    return catalog.get(name, priorityHost, serviceGroup);
+    const clusterId = this._activeServices[name];
+
+    const urlById = catalog.get(clusterId, serviceGroup);
+    const urlByName = catalog.get(name, serviceGroup);
+
+    // if both are undefined, then we cannot find the service
+    if (!urlById && !urlByName) {
+      return undefined;
+    }
+
+    return urlById || urlByName;
   },
 
   /**
@@ -66,59 +83,42 @@ const Services = WebexPlugin.extend({
    *
    * @returns {boolean} - True if a allowed domains list exists.
    */
-  hasAllowedDomains() {
+  hasAllowedDomains(): boolean {
     const catalog = this._getCatalog();
 
     return catalog.getAllowedDomains().length > 0;
   },
 
-  /**
-   * Generate a service catalog as an object from
-   * the associated instance catalog.
-   * @param {boolean} [priorityHost] - use highest priority host if set to `true`
-   * @param {string} [serviceGroup]
-   * @returns {Record<string, string>}
-   */
-  list(priorityHost, serviceGroup) {
-    const catalog = this._getCatalog();
-
-    return catalog.list(priorityHost, serviceGroup);
-  },
-
   /**
    * Mark a priority host service url as failed.
-   * This will mark the host associated with the
-   * `ServiceUrl` to be removed from the its
-   * respective host array, and then return the next
-   * viable host from the `ServiceUrls` host array,
-   * or the `ServiceUrls` default url if no other priority
-   * hosts are available, or if `noPriorityHosts` is set to
-   * `true`.
+   * This will mark the service url associated with the
+   * `ServiceDetail` to be removed from the its
+   * respective service url array, and then return the next
+   * viable service url from the `ServiceDetail` service url array.
    * @param {string} url
-   * @param {boolean} noPriorityHosts
    * @returns {string}
    */
-  markFailedUrl(url, noPriorityHosts) {
+  markFailedUrl(url: string): string | undefined {
     const catalog = this._getCatalog();
 
-    return catalog.markFailedUrl(url, noPriorityHosts);
+    return catalog.markFailedServiceUrl(url);
   },
 
   /**
    * saves all the services from the pre and post catalog service
-   * @param {Object} activeServices
+   * @param {ActiveServices} activeServices
    * @returns {void}
    */
-  _updateActiveServices(activeServices) {
+  _updateActiveServices(activeServices: ActiveServices): void {
     this._activeServices = {...this._activeServices, ...activeServices};
   },
 
   /**
    * saves the hostCatalog object
-   * @param {Object} services
+   * @param {Array<Service>} services
    * @returns {void}
    */
-  _updateServices(services) {
+  _updateServices(services: Array<Service>): void {
     this._services = unionBy(services, this._services, 'id');
   },
 
@@ -135,7 +135,14 @@ const Services = WebexPlugin.extend({
    * @param {string} [param.token] - used for signin catalog
    * @returns {Promise<object>}
    */
-  updateServices({from, query, token, forceRefresh} = {}) {
+  updateServices(
+    {from, query, token, forceRefresh} = {} as {
+      from: string;
+      query: QueryOptions;
+      token: string;
+      forceRefresh: boolean;
+    }
+  ): Promise<object> {
     const catalog = this._getCatalog();
     let formattedQuery;
     let serviceGroup;
@@ -152,9 +159,8 @@ const Services = WebexPlugin.extend({
         serviceGroup = 'postauth';
         break;
     }
-
     // confirm catalog update for group is not in progress.
-    if (catalog.status[serviceGroup].collecting) {
+    if (catalog.status?.[serviceGroup]?.collecting) {
       return this.waitForCatalog(serviceGroup);
     }
 
@@ -188,8 +194,12 @@ const Services = WebexPlugin.extend({
       query: formattedQuery,
       forceRefresh,
     })
-      .then((serviceHostMap) => {
-        catalog.updateServiceGroups(serviceGroup, serviceHostMap);
+      .then((serviceHostMap: ServiceHostmap) => {
+        catalog.updateServiceGroups(
+          serviceGroup,
+          serviceHostMap?.services,
+          serviceHostMap?.timestamp
+        );
         this.updateCredentialsConfig();
         catalog.status[serviceGroup].collecting = false;
       })
@@ -283,7 +293,7 @@ const Services = WebexPlugin.extend({
           // Retrieve the service url from the updated catalog. This is required
           // since `WebexCore` is usually not fully initialized at the time this
           // request completes.
-          const idbrokerService = this.get('idbroker', true);
+          const idbrokerService = this.get('idbroker');
 
           // Collect the client auth token.
           return this.webex.credentials.getClientToken({
@@ -338,7 +348,56 @@ const Services = WebexPlugin.extend({
         })
     );
   },
+  /**
+   * Update cluster id via mercury service update. If the cluster id does not exist,
+   * fetch new catalog.
+   *
+   * @param {ActiveServices} newActiveClusters - The new active clusters to switch to.
+   * @returns {Promsie<void>}
+   * */
+  switchActiveClusterIds(newActiveClusters: ActiveServices): Promise<void> {
+    this.logger.info('services: switching active cluster ids');
+
+    const newActiveClusterIds = Object.values(newActiveClusters);
+
+    const missingClusterIds = newActiveClusterIds.some((clusterId) => {
+      // if the clusterId does not exist in the catalog, fetch the catalog
+      return !this._services.find((service) => service.id === clusterId);
+    });
+
+    if (missingClusterIds) {
+      this.logger.warn(
+        'services: some cluster ids do not exist in the catalog, fetching the catalog'
+      );
+
+      // fetch the catalog
+      return this.initServiceCatalogs(true);
+    }
+    // update the active services
+    this._updateActiveServices(newActiveClusters);
+    this.logger.info('services: active cluster ids updated successfully');
+
+    return Promise.resolve();
+  },
 
+  /**
+   * Invalidate cache via mercury notification. If the timestamp is newer than current,
+   * refetch catalog services.
+   *
+   * @param {string} timestamp - The timestamp of invalidation notification.
+   * @returns {Promsie<void>}
+   * */
+  invalidateCache(timestamp: string): Promise<void> {
+    this.logger.info('services: invalidate cache, timestamp:', timestamp);
+    const lastTime = toNumber(this._getCatalog()?.timestamp) || 0;
+    const invalidateTime = toNumber(timestamp) || 0;
+    if (invalidateTime > lastTime) {
+      this.logger.info('services: invalidateCache, refresh services');
+      this.initServiceCatalogs(true);
+    }
+
+    return Promise.resolve();
+  },
   /**
    * Get user meeting preferences (preferred webex site).
    *
@@ -446,16 +505,20 @@ const Services = WebexPlugin.extend({
 
   /**
    * Updates a given service group i.e. preauth, signin, postauth with a new hostmap.
-   * @param {string} serviceGroup - preauth, signin, postauth
-   * @param {object} hostMap - The new hostmap to update the service group with.
+   * @param {ServiceGroup} serviceGroup - preauth, signin, postauth
+   * @param {ServiceHostmap} hostMap - The new hostmap to update the service group with.
    * @returns {Promise<void>}
    */
-  updateCatalog(serviceGroup, hostMap) {
+  updateCatalog(serviceGroup: ServiceGroup, hostMap: ServiceHostmap): Promise<void> {
     const catalog = this._getCatalog();
 
     const serviceHostMap = this._formatReceivedHostmap(hostMap);
 
-    return catalog.updateServiceGroups(serviceGroup, serviceHostMap);
+    return catalog.updateServiceGroups(
+      serviceGroup,
+      serviceHostMap?.services,
+      serviceHostMap?.timestamp
+    );
   },
 
   /**
@@ -467,7 +530,7 @@ const Services = WebexPlugin.extend({
    * @param {boolean} forceRefresh - Boolean to bypass u2c cache control header
    * @returns {Promise<void>}
    */
-  collectPreauthCatalog(query, forceRefresh = false) {
+  collectPreauthCatalog(query: QueryOptions, forceRefresh = false) {
     if (!query) {
       return this.updateServices({
         from: 'limited',
@@ -486,7 +549,9 @@ const Services = WebexPlugin.extend({
    * @param {string} param.token - must be a client token
    * @returns {Promise<void>}
    */
-  collectSigninCatalog({email, token, forceRefresh} = {}) {
+  collectSigninCatalog(
+    {email, token, forceRefresh} = {} as {email: string; token: string; forceRefresh: boolean}
+  ): Promise<void> {
     if (!email) {
       return Promise.reject(new Error('`email` is required'));
     }
@@ -507,25 +572,26 @@ const Services = WebexPlugin.extend({
    * urls.
    * @returns {void}
    */
-  updateCredentialsConfig() {
-    const {idbroker, identity} = this.list(true);
+  updateCredentialsConfig(): void {
+    const idbrokerUrl = this.get('idbroker');
+    const identityUrl = this.get('identity');
 
-    if (idbroker && identity) {
+    if (idbrokerUrl && identityUrl) {
       const {authorizationString, authorizeUrl} = this.webex.config.credentials;
 
       // This must be set outside of the setConfig method used to assign the
       // idbroker and identity url values.
       this.webex.config.credentials.authorizeUrl = authorizationString
         ? authorizeUrl
-        : `${idbroker.replace(trailingSlashes, '')}/idb/oauth2/v1/authorize`;
+        : `${idbrokerUrl.replace(trailingSlashes, '')}/idb/oauth2/v1/authorize`;
 
       this.webex.setConfig({
         credentials: {
           idbroker: {
-            url: idbroker.replace(trailingSlashes, ''), // remove trailing slash
+            url: idbrokerUrl.replace(trailingSlashes, ''), // remove trailing slash
           },
           identity: {
-            url: identity.replace(trailingSlashes, ''), // remove trailing slash
+            url: identityUrl.replace(trailingSlashes, ''), // remove trailing slash
           },
         },
       });
@@ -535,11 +601,11 @@ const Services = WebexPlugin.extend({
   /**
    * Wait until the service catalog is available,
    * or reject afte ra timeout of 60 seconds.
-   * @param {string} serviceGroup
+   * @param {ServiceGroup} serviceGroup
    * @param {number} [timeout] - in seconds
    * @returns {Promise<void>}
    */
-  waitForCatalog(serviceGroup, timeout) {
+  waitForCatalog(serviceGroup: ServiceGroup, timeout: number): Promise<void> {
     const catalog = this._getCatalog();
     const {supertoken} = this.webex.credentials;
 
@@ -576,7 +642,15 @@ const Services = WebexPlugin.extend({
    * @param {WaitForServicePTO} - The parameter transfer object.
    * @returns {Promise<string>} - Resolves to the priority host of a service.
    */
-  waitForService({name, timeout = 5, url}) {
+  waitForService({
+    name,
+    timeout = 5,
+    url,
+  }: {
+    name: string;
+    timeout: number;
+    url: string;
+  }): Promise<string> {
     const {services} = this.webex.config;
 
     // Save memory by grabbing the catalog after there isn't a priortyURL
@@ -587,10 +661,12 @@ const Services = WebexPlugin.extend({
     );
 
     if (fetchFromServiceUrl) {
-      return Promise.resolve(this._activeServices[name]);
+      const clusterId = this._activeServices[name];
+
+      return Promise.resolve(this.get(clusterId));
     }
 
-    const priorityUrl = this.get(name, true);
+    const priorityUrl = this.get(name);
     const priorityUrlObj = this.getServiceFromUrl(url);
 
     if (priorityUrl || priorityUrlObj) {
@@ -617,7 +693,7 @@ const Services = WebexPlugin.extend({
         catalog
           .waitForCatalog(catalogGroup, timeout)
           .then(() => {
-            const scopedPriorityUrl = this.get(name, true);
+            const scopedPriorityUrl = this.get(name);
             const scopedPrioriryUrlObj = this.getServiceFromUrl(url);
 
             if (scopedPriorityUrl || scopedPrioriryUrlObj) {
@@ -641,25 +717,12 @@ const Services = WebexPlugin.extend({
    * @param {string} uri
    * @returns {string} uri with the host replaced
    */
-  replaceHostFromHostmap(uri) {
-    const url = new URL(uri);
-    const hostCatalog = this._services;
-
-    if (!hostCatalog) {
+  replaceHostFromHostmap(uri: string): string {
+    try {
+      return this.convertUrlToPriorityHostUrl(uri);
+    } catch {
       return uri;
     }
-
-    const host = hostCatalog[url.host];
-
-    if (host && host[0]) {
-      const newHost = host[0].host;
-
-      url.host = newHost;
-
-      return url.toString();
-    }
-
-    return uri;
   },
 
   /**
@@ -687,12 +750,18 @@ const Services = WebexPlugin.extend({
   /**
    * @private
    * Organize a received hostmap from a service
-   * @param {object} serviceHostmap
+   * @param {ServiceHostmap} serviceHostmap
    * catalog endpoint.
-   * @returns {object}
+   * @returns {Array<Service>}
    */
-  _formatReceivedHostmap({services, activeServices}) {
-    const formattedHostmap = services.map((service) => this._formatHostMapEntry(service));
+  _formatReceivedHostmap({services, activeServices, timestamp, orgId, format}) {
+    const formattedHostmap: ServiceHostmap = {
+      activeServices,
+      services: services.map((service) => this._formatHostMapEntry(service)),
+      timestamp,
+      orgId,
+      format,
+    };
     this._updateActiveServices(activeServices);
     this._updateServices(services);
 
@@ -702,9 +771,9 @@ const Services = WebexPlugin.extend({
   /**
    * Get the clusterId associated with a URL string.
    * @param {string} url
-   * @returns {string} - Cluster ID of url provided
+   * @returns {string | undefined} - Cluster ID of url provided
    */
-  getClusterId(url) {
+  getClusterId(url: string): string | undefined {
     const catalog = this._getCatalog();
 
     return catalog.findClusterId(url);
@@ -715,13 +784,15 @@ const Services = WebexPlugin.extend({
    * return an object containing both the name and url of a found service.
    * @param {object} params
    * @param {string} params.clusterId - clusterId of found service
-   * @param {boolean} [params.priorityHost] - returns priority host url if true
-   * @param {string} [params.serviceGroup] - specify service group
+   * @param {ServiceGroup} [params.serviceGroup] - specify service group
    * @returns {object} service
    * @returns {string} service.name
    * @returns {string} service.url
    */
-  getServiceFromClusterId(params) {
+  getServiceFromClusterId(params: {
+    clusterId: string;
+    serviceGroup?: ServiceGroup;
+  }): {name: string; url: string} | undefined {
     const catalog = this._getCatalog();
 
     return catalog.findServiceFromClusterId(params);
@@ -733,7 +804,7 @@ const Services = WebexPlugin.extend({
    *  If empty, just return the base URL.
    * @returns {String} url of the service
    */
-  getServiceUrlFromClusterId({cluster = 'us'} = {}) {
+  getServiceUrlFromClusterId({cluster = 'us'}: {cluster?: string} = {}): string {
     let clusterId = cluster === 'us' ? DEFAULT_CLUSTER_IDENTIFIER : cluster;
 
     // Determine if cluster has service name (non-US clusters from hydra do not)
@@ -758,20 +829,25 @@ const Services = WebexPlugin.extend({
    * @param {string} url - The url to be validated.
    * @returns {object} - Service object.
    * @returns {object.name} - The name of the service found.
-   * @returns {object.priorityUrl} - The priority url of the found service.
+   * @returns {object.priorityUrl} - The default url of the found service.
    * @returns {object.defaultUrl} - The default url of the found service.
    */
-  getServiceFromUrl(url = '') {
-    const service = this._getCatalog().findServiceUrlFromUrl(url);
+  getServiceFromUrl(url = ''): {name: string; priorityUrl: string; defaultUrl: string} | undefined {
+    const service = this._getCatalog().findServiceDetailFromUrl(url);
 
     if (!service) {
       return undefined;
     }
 
+    const priorityUrl = service.get();
+    const defaultUrl = new URL(
+      service.serviceUrls.find((serviceUrl) => url.startsWith(serviceUrl.baseUrl)).baseUrl
+    ).href;
+
     return {
-      name: service.name,
-      priorityUrl: service.get(true),
-      defaultUrl: service.get(),
+      name: service.serviceName,
+      priorityUrl,
+      defaultUrl,
     };
   },
 
@@ -781,7 +857,7 @@ const Services = WebexPlugin.extend({
    * @param {string} url - The url to match allowed domains against.
    * @returns {boolean} - True if the url provided is allowed.
    */
-  isAllowedDomainUrl(url) {
+  isAllowedDomainUrl(url: string): boolean {
     const catalog = this._getCatalog();
 
     return !!catalog.findAllowedDomain(url);
@@ -795,7 +871,7 @@ const Services = WebexPlugin.extend({
    * @returns {string} a service url that contains the top priority host.
    * @throws if url isn't a service url
    */
-  convertUrlToPriorityHostUrl(url = '') {
+  convertUrlToPriorityHostUrl(url = '' as string): string {
     const data = this.getServiceFromUrl(url);
 
     if (!data) {
@@ -818,10 +894,17 @@ const Services = WebexPlugin.extend({
    * @param {string} [param.token] - used for signin catalog
    * @returns {Promise<object>}
    */
-  _fetchNewServiceHostmap({from, query, token, forceRefresh} = {}) {
+  _fetchNewServiceHostmap(
+    {from, query, token, forceRefresh} = {} as {
+      from: string;
+      query: QueryOptions;
+      token: string;
+      forceRefresh: boolean;
+    }
+  ): Promise<object> {
     const service = 'u2c';
     const resource = from ? `/${from}/catalog` : '/catalog';
-    const qs = {...(query || {}), format: 'hostmap'};
+    const qs = {...(query || {}), format: 'U2CV2'};
 
     if (forceRefresh) {
       qs.timestamp = new Date().getTime();
@@ -832,6 +915,7 @@ const Services = WebexPlugin.extend({
       service,
       resource,
       qs,
+      headers: {},
     };
 
     if (token) {
@@ -848,7 +932,7 @@ const Services = WebexPlugin.extend({
    *
    * @returns {void}
    */
-  initConfig() {
+  initConfig(): void {
     // Get the catalog and destructure the services config.
     const catalog = this._getCatalog();
     const {services, fedramp} = this.webex.config;
@@ -905,10 +989,10 @@ const Services = WebexPlugin.extend({
 
   /**
    * Make the initial requests to collect the root catalogs.
-   *
+   * @param {boolean} refresh - Is need force update
    * @returns {Promise<void, Error>} - Errors if the token is unavailable.
    */
-  initServiceCatalogs() {
+  initServiceCatalogs(refresh = false): Promise<void> {
     this.logger.info('services: initializing initial service catalogs');
 
     // Destructure the credentials plugin.
@@ -921,12 +1005,12 @@ const Services = WebexPlugin.extend({
         // Get the user's OrgId.
         .then(() => credentials.getOrgId())
         // Begin collecting the preauth/limited catalog.
-        .then((orgId) => this.collectPreauthCatalog({orgId}))
+        .then((orgId) => this.collectPreauthCatalog({orgId}, refresh))
         .then(() => {
           // Validate if the token is authorized.
           if (credentials.canAuthorize) {
             // Attempt to collect the postauth catalog.
-            return this.updateServices().catch(() => {
+            return this.updateServices({forceRefresh: refresh}).catch(() => {
               this.initFailed = true;
               this.logger.warn('services: cannot retrieve postauth catalog');
             });
@@ -945,7 +1029,7 @@ const Services = WebexPlugin.extend({
    * @memberof Services
    * @returns {Services}
    */
-  initialize() {
+  initialize(): typeof Services {
     const catalog = new ServiceCatalog();
     this._catalogs.set(this.webex, catalog);
 

package/src/lib/services-v2/types.ts

@@ -1,3 +1,7 @@
+type ServiceName = string;
+type ClusterId = string;
+export type ServiceGroup = 'discovery' | 'override' | 'preauth' | 'postauth' | 'signin';
+
 export type ServiceUrl = {
   baseUrl: string;
   host: string;
@@ -5,9 +9,65 @@ export type ServiceUrl = {
   failed?: boolean;
 };
 
+export type ActiveServices = Record<ServiceName, ClusterId>;
+export type Service = {
+  id: ClusterId;
+  serviceName: ServiceName;
+  serviceUrls: Array<ServiceUrl>;
+};
+export type QueryOptions = {
+  email?: string;
+  orgId?: string;
+  userId?: string;
+  timestamp?: number;
+};
+
+export interface ServiceHostmap {
+  activeServices: ActiveServices;
+  services: Array<Service>;
+  timestamp: string;
+  orgId: string;
+  format: string;
+}
+
 export interface IServiceDetail {
-  id: string;
-  serviceName: string;
+  id: ClusterId;
+  serviceName: ServiceName;
   serviceUrls: Array<ServiceUrl>;
   failHost(url: string): boolean;
+  get(): string;
+}
+
+export interface IServiceCatalog {
+  serviceGroups: {
+    discovery: Array<IServiceDetail>;
+    override: Array<IServiceDetail>;
+    preauth: Array<IServiceDetail>;
+    postauth: Array<IServiceDetail>;
+    signin: Array<IServiceDetail>;
+  };
+  status: {
+    discovery: {ready: boolean; collecting: boolean};
+    override: {ready: boolean; collecting: boolean};
+    preauth: {ready: boolean; collecting: boolean};
+    postauth: {ready: boolean; collecting: boolean};
+    signin: {ready: boolean; collecting: boolean};
+  };
+  isReady: boolean;
+  allowedDomains: string[];
+  clean(): void;
+  findClusterId(url: string): string | undefined;
+  findServiceFromClusterId(params: {
+    clusterId: ClusterId;
+    serviceGroup?: ServiceGroup;
+  }): {name: string; url: string} | undefined;
+  findServiceDetailFromUrl(url: string): IServiceDetail | undefined;
+  findAllowedDomain(url: string): string | undefined;
+  get(clusterId: ClusterId, serviceGroup?: ServiceGroup): string | undefined;
+  getAllowedDomains(): string[];
+  markFailedServiceUrl(url: string): string | undefined;
+  setAllowedDomains(allowedDomains: string[]): void;
+  addAllowedDomains(newAllowedDomains: string[]): void;
+  updateServiceGroups(serviceGroup: ServiceGroup, serviceDetails: Array<IServiceDetail>): void;
+  waitForCatalog(serviceGroup: ServiceGroup, timeout?: number): Promise<void>;
 }