@webex/webex-core 3.11.0-webex-services-ready.1 → 3.12.0-auth-prejoin-fetch.1

package/dist/lib/services/services.js

@@ -31,7 +31,7 @@ var _serviceState = _interopRequireDefault(require("./service-state"));
 var _serviceFedRamp = _interopRequireDefault(require("./service-fed-ramp"));
 var _constants = require("../constants");
 function ownKeys(e, r) { var t = _Object$keys2(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; } /* eslint-disable no-console */
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
 var trailingSlashes = /(?:^\/)|(?:\/$)/;
 
 // The default cluster when one is not provided (usually as 'US' from hydra)
@@ -75,8 +75,10 @@ var Services = _webexPlugin.default.extend({
   },
   session: {
     /**
-     * Becomes `true` once service catalog initialization has completed.
-     * Blocks `webex.ready` until services are initialized.
+     * Becomes `true` once the initial catalog collection has completed
+     * (successfully or otherwise) and any in-flight credentials refresh has
+     * settled. Blocks `webex.ready` so consumers can rely on `webex.ready`
+     * implying "catalogs populated AND credential state stable".
      * @instance
      * @memberof Services
      * @type {boolean}
@@ -256,6 +258,24 @@ var Services = _webexPlugin.default.extend({
     var hostCatalog = this._hostCatalog || {};
     return !!((_hostCatalog$host = hostCatalog[host]) !== null && _hostCatalog$host !== void 0 && _hostCatalog$host.length);
   },
+  /**
+   * Checks if the current environment is an integration (INT) environment
+   * by examining the u2c discovery URL from webex config.
+   * INT environments use discovery URLs containing 'intb' (e.g., u2c-intb.ciscospark.com).
+   * @returns {boolean} True if INT environment, false otherwise
+   */
+  isIntegrationEnvironment: function isIntegrationEnvironment() {
+    try {
+      var _this$webex, _this$webex$config, _this$webex$config$se, _this$webex$config$se2;
+      var u2cUrl = ((_this$webex = this.webex) === null || _this$webex === void 0 ? void 0 : (_this$webex$config = _this$webex.config) === null || _this$webex$config === void 0 ? void 0 : (_this$webex$config$se = _this$webex$config.services) === null || _this$webex$config$se === void 0 ? void 0 : (_this$webex$config$se2 = _this$webex$config$se.discovery) === null || _this$webex$config$se2 === void 0 ? void 0 : _this$webex$config$se2.u2c) || '';
+      var isInt = u2cUrl.includes('intb');
+      this.logger.info("services: isIntegrationEnvironment: ".concat(isInt));
+      return isInt;
+    } catch (error) {
+      this.logger.error('services: failed to determine integration environment', error);
+      return false;
+    }
+  },
   /**
    * Merge provided active cluster mappings into current state.
    * @param {Record<string,string>} activeServices
@@ -1055,9 +1075,11 @@ var Services = _webexPlugin.default.extend({
         authorization: token
       };
     }
-    return this.webex.internal.newMetrics.callDiagnosticLatencies.measureLatency(function () {
+    var sendRequest = function sendRequest() {
       return _this7.request(requestObject);
-    }, 'internal.get.u2c.time').then(function (_ref12) {
+    };
+    var responsePromise = this.webex.internal.newMetrics ? this.webex.internal.newMetrics.callDiagnosticLatencies.measureLatency(sendRequest, 'internal.get.u2c.time') : sendRequest();
+    return responsePromise.then(function (_ref12) {
       var body = _ref12.body;
       return body;
     });
@@ -1284,9 +1306,9 @@ var Services = _webexPlugin.default.extend({
   initConfig: function initConfig() {
     // Get the catalog and destructure the services config.
     var catalog = this._getCatalog();
-    var _this$webex$config = this.webex.config,
-      services = _this$webex$config.services,
-      fedramp = _this$webex$config.fedramp;
+    var _this$webex$config2 = this.webex.config,
+      services = _this$webex$config2.services,
+      fedramp = _this$webex$config2.fedramp;
 
     // Validate that the services configuration exists.
     if (services) {
@@ -1345,6 +1367,7 @@ var Services = _webexPlugin.default.extend({
 
     // Destructure the credentials plugin.
     var credentials = this.webex.credentials;
+    var catalog = this._getCatalog();
 
     // Init a promise chain. Must be done as a Promise.resolve() to allow
     // credentials#getOrgId() to properly throw.
@@ -1361,9 +1384,13 @@ var Services = _webexPlugin.default.extend({
     }).then(function () {
       // Validate if the token is authorized.
       if (credentials.canAuthorize) {
-        // Attempt to collect the postauth catalog.
-
-        return _this0.updateServices().catch(function () {
+        // Attempt to collect the postauth catalog, then mark the catalog
+        // ready. Setting `isReady` here - rather than only in the init
+        // callers - means a slow postauth fetch that loses the gated-init
+        // timeout race still marks the catalog ready once it completes.
+        return _this0.updateServices().then(function () {
+          catalog.isReady = true;
+        }).catch(function () {
           _this0.initFailed = true;
           _this0.logger.warn('services: cannot retrieve postauth catalog');
         });
@@ -1373,6 +1400,62 @@ var Services = _webexPlugin.default.extend({
       return _promise.default.resolve();
     });
   },
+  /**
+   * Await any in-flight credentials refresh, then flip `services.ready` so
+   * `webex.ready` can fire. Closes the parallel-refresh window: if a credential
+   * refresh is in flight when initial catalog collection settles, we must not
+   * signal ready until the refresh has resolved - otherwise downstream
+   * consumers may observe `canAuthorize`/token state that is about to change
+   * under them.
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  _finalizeReady: function _finalizeReady() {
+    var _this1 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var credentials;
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            credentials = _this1.webex.credentials;
+            if (!(credentials && credentials.isRefreshing)) {
+              _context4.next = 1;
+              break;
+            }
+            _context4.next = 1;
+            return new _promise.default(function (resolve) {
+              credentials.once('change:isRefreshing', resolve);
+            });
+          case 1:
+            _this1.ready = true;
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  },
+  /**
+   * Build a promise that rejects once the catalog init timeout elapses. Race
+   * this against catalog collection so a hung request never leaves
+   * `services.ready` false forever - that would stall `webex.ready` and leave
+   * consumers waiting on it indefinitely. Timeout is configurable via
+   * `config.services.catalogInitTimeout` (defaults to 15s in config). Created
+   * lazily so paths that skip catalog collection never schedule a stray timer.
+   *
+   * @private
+   * @returns {Promise<never>}
+   */
+  _makeInitTimeout: function _makeInitTimeout() {
+    var _this$webex$config3, _this$webex$config3$s;
+    var initTimeoutMs = (_this$webex$config3 = this.webex.config) === null || _this$webex$config3 === void 0 ? void 0 : (_this$webex$config3$s = _this$webex$config3.services) === null || _this$webex$config3$s === void 0 ? void 0 : _this$webex$config3$s.catalogInitTimeout;
+    return new _promise.default(function (_, reject) {
+      setTimeout(function () {
+        return reject(new Error("services: init timed out after ".concat(initTimeoutMs, "ms")));
+      }, initTimeoutMs);
+    });
+  },
   /**
    * Initializer
    *
@@ -1381,7 +1464,7 @@ var Services = _webexPlugin.default.extend({
    * @returns {Services}
    */
   initialize: function initialize() {
-    var _this1 = this;
+    var _this10 = this;
     var catalog = new _serviceCatalog.default();
     var registry = new _serviceRegistry.default();
     var state = new _serviceState.default();
@@ -1389,72 +1472,176 @@ var Services = _webexPlugin.default.extend({
     this.registries.set(this.webex, registry);
     this.states.set(this.webex, state);
 
-    // Listen for configuration changes once.
+    // Listen for configuration changes once. The config is not populated on the
+    // webex instance until the `change:config` event fires, so any decision that
+    // depends on config values (such as the gated-vs-ungated init below) must be
+    // made from within this handler rather than synchronously in `initialize()`.
     this.listenToOnce(this.webex, 'change:config', function () {
-      _this1.initConfig();
-    });
+      var _this10$webex$config, _this10$webex$config$;
+      _this10.initConfig();
 
-    // Wait for storage to be loaded before attempting to update the service catalogs.
-    // We listen for 'loaded' instead of 'ready' because services.ready is a dependency
-    // of webex.ready - listening to 'ready' would cause a deadlock.
-    this.listenToOnce(this.webex, 'loaded', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
-      var cachedCatalog, supertoken, email;
-      return _regenerator.default.wrap(function (_context4) {
-        while (1) switch (_context4.prev = _context4.next) {
+      // Feature flag: when enabled, `webex.ready` is blocked until the initial
+      // catalog collection has settled AND any in-flight credentials refresh has
+      // completed. When disabled (the default), preserves the pre-existing
+      // behavior where `webex.ready` fires as soon as `webex.loaded` does and
+      // the catalog is collected out-of-band.
+      var waitForCatalogInit = ((_this10$webex$config = _this10.webex.config) === null || _this10$webex$config === void 0 ? void 0 : (_this10$webex$config$ = _this10$webex$config.services) === null || _this10$webex$config$ === void 0 ? void 0 : _this10$webex$config$.waitForCatalogInit) === true;
+      if (waitForCatalogInit) {
+        _this10._initializeCatalogsGated(catalog);
+      } else {
+        // Not gating - immediately mark ready so we do not block webex.ready.
+        _this10.ready = true;
+        _this10._initializeCatalogsUngated(catalog);
+      }
+    });
+  },
+  /**
+   * Original (pre-verified-ready) initialization path. Runs on `webex.ready`
+   * and collects catalogs opportunistically without blocking anything.
+   *
+   * @private
+   * @param {ServiceCatalog} catalog
+   * @returns {void}
+   */
+  _initializeCatalogsUngated: function _initializeCatalogsUngated(catalog) {
+    var _this11 = this;
+    // wait for webex instance to be ready before attempting
+    // to update the service catalogs
+    // this can cause a race condition because credentials may
+    // not be valid when services is initialized
+    this.listenToOnce(this.webex, 'ready', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var cachedCatalog, supertoken, _this11$webex$config, _this11$webex$config$, email;
+      return _regenerator.default.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
           case 0:
-            _context4.next = 1;
-            return _this1._loadCatalogFromCache();
+            _context5.next = 1;
+            return _this11._loadCatalogFromCache();
+          case 1:
+            cachedCatalog = _context5.sent;
+            if (!cachedCatalog) {
+              _context5.next = 2;
+              break;
+            }
+            catalog.isReady = true;
+            return _context5.abrupt("return");
+          case 2:
+            supertoken = _this11.webex.credentials.supertoken; // Validate if the supertoken exists.
+            if (!(supertoken && supertoken.access_token)) {
+              _context5.next = 3;
+              break;
+            }
+            // `initServiceCatalogs` marks the catalog ready internally once the
+            // postauth catalog is collected.
+            _this11.initServiceCatalogs().catch(function (error) {
+              _this11.initFailed = true;
+              _this11.logger.error("services: failed to init initial services when credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+            });
+            _context5.next = 5;
+            break;
+          case 3:
+            email = _this11.webex.config.email;
+            if (!(((_this11$webex$config = _this11.webex.config) === null || _this11$webex$config === void 0 ? void 0 : (_this11$webex$config$ = _this11$webex$config.services) === null || _this11$webex$config$ === void 0 ? void 0 : _this11$webex$config$.skipPreauthCatalogOnUnauthenticated) === true)) {
+              _context5.next = 4;
+              break;
+            }
+            _this11.logger.info('services: skipping preauth catalog collection while unauthenticated as per the config');
+            return _context5.abrupt("return");
+          case 4:
+            _this11.collectPreauthCatalog(email ? {
+              email: email
+            } : undefined).catch(function (error) {
+              _this11.initFailed = true;
+              _this11.logger.error("services: failed to init initial services when no credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+            });
+          case 5:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+  },
+  /**
+   * Verified-ready initialization path. Blocks `webex.ready` until the initial
+   * catalog fetch has settled (or timed out) AND any in-flight credentials
+   * refresh has completed. Also handles the fresh-login case where OAuth
+   * completes after `loaded` fires.
+   *
+   * @private
+   * @param {ServiceCatalog} catalog
+   * @returns {void}
+   */
+  _initializeCatalogsGated: function _initializeCatalogsGated(catalog) {
+    var _this12 = this;
+    // Wait for storage to be loaded before attempting to update the service
+    // catalogs. We listen for 'loaded' instead of 'ready' because `services.ready`
+    // now blocks `webex.ready` - listening to 'ready' would deadlock.
+    this.listenToOnce(this.webex, 'loaded', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      var cachedCatalog, supertoken, _this12$webex$config, _this12$webex$config$, email;
+      return _regenerator.default.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 1;
+            return _this12._loadCatalogFromCache();
           case 1:
-            cachedCatalog = _context4.sent;
+            cachedCatalog = _context6.sent;
             if (!cachedCatalog) {
-              _context4.next = 2;
+              _context6.next = 3;
               break;
             }
             catalog.isReady = true;
-            return _context4.abrupt("return");
+            _context6.next = 2;
+            return _this12._finalizeReady();
           case 2:
-            supertoken = _this1.webex.credentials.supertoken; // Validate if the supertoken exists.
+            return _context6.abrupt("return");
+          case 3:
+            supertoken = _this12.webex.credentials.supertoken; // Validate if the supertoken exists.
             if (supertoken && supertoken.access_token) {
-              _this1.initServiceCatalogs().then(function () {
-                catalog.isReady = true;
-              }).catch(function (error) {
-                _this1.initFailed = true;
-                _this1.logger.error("services: failed to init initial services when credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+              // `initServiceCatalogs` marks the catalog ready internally once the
+              // postauth catalog is collected - even if it loses the timeout race
+              // below, so a slow fetch still eventually flips `catalog.isReady`.
+              _promise.default.race([_this12.initServiceCatalogs(), _this12._makeInitTimeout()]).catch(function (error) {
+                _this12.initFailed = true;
+                _this12.logger.error("services: failed to init initial services when credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
               }).finally(function () {
-                _this1.ready = true;
-                _this1.trigger('services:initialized');
+                return _this12._finalizeReady();
               });
             } else {
-              email = _this1.webex.config.email;
-              _this1.collectPreauthCatalog(email ? {
-                email: email
-              } : undefined).catch(function (error) {
-                _this1.initFailed = true;
-                _this1.logger.error("services: failed to init initial services when no credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
-              }).finally(function () {
-                _this1.ready = true;
-                _this1.trigger('services:initialized');
-              });
-              // Listen for when credentials become available to fetch the full catalog.
-              // This handles fresh login where 'loaded' fires before OAuth completes.
-              _this1.listenToOnce(_this1.webex, 'change:canAuthorize', function () {
-                if (_this1.webex.canAuthorize && !catalog.status.postauth.ready) {
-                  _this1.initServiceCatalogs().then(function () {
-                    catalog.isReady = true;
-                  }).catch(function (error) {
-                    _this1.logger.error("services: failed to init service catalogs after auth, ".concat(error === null || error === void 0 ? void 0 : error.message));
+              email = _this12.webex.config.email; // Handle fresh login: 'loaded' fires before OAuth completes, so listen
+              // for `canAuthorize` flipping true and then collect the postauth catalog.
+              _this12.listenToOnce(_this12.webex, 'change:canAuthorize', function () {
+                if (_this12.webex.canAuthorize && !catalog.status.postauth.ready) {
+                  // `initServiceCatalogs` marks the catalog ready internally.
+                  _this12.initServiceCatalogs().catch(function (error) {
+                    _this12.logger.error("services: failed to init service catalogs after auth, ".concat(error === null || error === void 0 ? void 0 : error.message));
                   });
                 }
               });
+              if (((_this12$webex$config = _this12.webex.config) === null || _this12$webex$config === void 0 ? void 0 : (_this12$webex$config$ = _this12$webex$config.services) === null || _this12$webex$config$ === void 0 ? void 0 : _this12$webex$config$.skipPreauthCatalogOnUnauthenticated) === true) {
+                // Skip the preauth catalog fetch (it will be collected manually
+                // later), but still finalize `services.ready` so `webex.ready` is not
+                // stalled while unauthenticated. No timeout is created here so there
+                // is no stray timer or unhandled rejection.
+                _this12.logger.info('services: skipping preauth catalog collection while unauthenticated as per the config');
+                _this12._finalizeReady();
+              } else {
+                _promise.default.race([_this12.collectPreauthCatalog(email ? {
+                  email: email
+                } : undefined), _this12._makeInitTimeout()]).catch(function (error) {
+                  _this12.initFailed = true;
+                  _this12.logger.error("services: failed to init initial services when no credentials available, ".concat(error === null || error === void 0 ? void 0 : error.message));
+                }).finally(function () {
+                  return _this12._finalizeReady();
+                });
+              }
             }
-          case 3:
+          case 4:
           case "end":
-            return _context4.stop();
+            return _context6.stop();
         }
-      }, _callee4);
+      }, _callee6);
     })));
   },
-  version: "3.11.0-webex-services-ready.1"
+  version: "3.12.0-auth-prejoin-fetch.1"
 });
 /* eslint-enable no-underscore-dangle */
 var _default = exports.default = Services;