@webex/webex-core 3.12.0-next.9 → 3.12.0-webex-services-ready.1

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

@@ -32,6 +32,12 @@ const DEFAULT_CLUSTER_IDENTIFIER =
 const CATALOG_CACHE_KEY_V2 = 'services.v2.u2cHostMap';
 const CATALOG_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
+// Maximum time we will wait for the initial catalog collection before letting
+// `services.ready` (and therefore `webex.ready`) fire anyway. A hung request
+// must never leave the app on a permanent spinner - past this point downstream
+// consumers must fall through to their normal error/login paths.
+const SERVICES_INIT_TIMEOUT_MS = 15_000;
+
 /* eslint-disable no-underscore-dangle */
 /**
  * @class
@@ -44,6 +50,20 @@ const Services = WebexPlugin.extend({
     initFailed: ['boolean', false, false],
   },
 
+  session: {
+    /**
+     * Becomes `true` once services initialization has completed.
+     * This blocks `webex.ready` until services are initialized.
+     * @instance
+     * @memberof Services
+     * @type {boolean}
+     */
+    ready: {
+      default: false,
+      type: 'boolean',
+    },
+  },
+
   _catalogs: new WeakMap(),
 
   _activeServices: {},
@@ -1337,6 +1357,30 @@ const Services = WebexPlugin.extend({
     );
   },
 
+  /**
+   * 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>}
+   */
+  async _finalizeReady(): Promise<void> {
+    const {credentials} = this.webex;
+
+    if (credentials && credentials.isRefreshing) {
+      await new Promise<void>((resolve) => {
+        credentials.once('change:isRefreshing', resolve);
+      });
+    }
+
+    this.ready = true;
+    this.trigger('services:initialized');
+  },
+
   /**
    * Initializer
    *
@@ -1353,19 +1397,32 @@ const Services = WebexPlugin.extend({
       this.initConfig();
     });
 
-    // wait for webex instance to be ready before attempting
-    // to update the service catalogs
-    this.listenToOnce(this.webex, 'ready', async () => {
+    // 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', async () => {
       const warmed = await this._loadCatalogFromCache();
       if (warmed) {
         catalog.isReady = true;
+        await this._finalizeReady();
 
         return;
       }
       const {supertoken} = this.webex.credentials;
+
+      // Race init against a hard timeout so a hung request never leaves
+      // `services.ready` false forever - that would stall `webex.ready` and
+      // leave the app on a permanent spinner.
+      const timeout = new Promise<never>((_, reject) => {
+        setTimeout(
+          () => reject(new Error(`services: init timed out after ${SERVICES_INIT_TIMEOUT_MS}ms`)),
+          SERVICES_INIT_TIMEOUT_MS
+        );
+      });
+
       // Validate if the supertoken exists.
       if (supertoken && supertoken.access_token) {
-        this.initServiceCatalogs()
+        Promise.race([this.initServiceCatalogs(), timeout])
           .then(() => {
             catalog.isReady = true;
           })
@@ -1374,15 +1431,33 @@ const Services = WebexPlugin.extend({
             this.logger.error(
               `services: failed to init initial services when credentials available, ${error?.message}`
             );
-          });
+          })
+          .finally(() => this._finalizeReady());
       } else {
         const {email} = this.webex.config;
 
-        this.collectPreauthCatalog(email ? {email} : undefined).catch((error) => {
-          this.initFailed = true;
-          this.logger.error(
-            `services: failed to init initial services when no credentials available, ${error?.message}`
-          );
+        Promise.race([this.collectPreauthCatalog(email ? {email} : undefined), timeout])
+          .catch((error) => {
+            this.initFailed = true;
+            this.logger.error(
+              `services: failed to init initial services when no credentials available, ${error?.message}`
+            );
+          })
+          .finally(() => this._finalizeReady());
+        // Listen for when credentials become available to fetch the full catalog.
+        // This handles fresh login where 'loaded' fires before OAuth completes.
+        this.listenToOnce(this.webex, 'change:canAuthorize', () => {
+          if (this.webex.canAuthorize && !catalog.status.postauth.ready) {
+            this.initServiceCatalogs()
+              .then(() => {
+                catalog.isReady = true;
+              })
+              .catch((error) => {
+                this.logger.error(
+                  `services: failed to init service catalogs after auth, ${error?.message}`
+                );
+              });
+          }
         });
       }
     });

package/test/integration/spec/services/service-catalog.js

@@ -23,13 +23,12 @@ describe('webex-core', () => {
         .then(
           ([user]) =>
             new Promise((resolve) => {
-              setTimeout(() => {
-                webexUser = user;
-                webex = new WebexCore({credentials: user.token});
-                services = webex.internal.services;
-                catalog = services._getCatalog();
-                resolve();
-              }, 1000);
+              webexUser = user;
+              webex = new WebexCore({credentials: user.token});
+              services = webex.internal.services;
+              catalog = services._getCatalog();
+              // Wait for webex ready event before registering device to ensure newMetrics.callDiagnosticMetrics is initialized
+              webex.once('ready', resolve);
             })
         )
         .then(() => webex.internal.device.register())

package/test/integration/spec/services/services.js

@@ -404,15 +404,26 @@ describe('webex-core', () => {
         assert.isTrue(catalog.isReady);
       });
 
-      it('should call services#initServiceCatalogs() on webex ready', async () => {
-        services._loadCatalogFromCache = sinon.stub().resolves(false);
+      it('should call services#initServiceCatalogs() on webex loaded', async () => {
         services.initServiceCatalogs = sinon.stub().resolves();
         services.initialize();
-        webex.trigger('ready');
-        // Wait for the async 'ready' handler to complete
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        webex.trigger('loaded');
+        // Wait for the async callback to execute
+        await new Promise((resolve) => setTimeout(resolve, 10));
         assert.called(services.initServiceCatalogs);
-        assert.isTrue(catalog.isReady);
+      });
+
+      it('should set services.ready to true after initialization completes', async () => {
+        // services.ready starts as false
+        const newWebex = new WebexCore({credentials: {supertoken: webexUser.token}});
+        const newServices = newWebex.internal.services;
+
+        // Wait for initialization to complete
+        await new Promise((resolve) => {
+          newServices.on('services:initialized', resolve);
+        });
+
+        assert.isTrue(newServices.ready);
       });
 
       it('should collect different catalogs based on OrgId region', () =>

package/test/integration/spec/services-v2/services-v2.js

@@ -316,15 +316,26 @@ describe('webex-core', () => {
         assert.isTrue(catalog.isReady);
       });
 
-      it('should call services#initServiceCatalogs() on webex ready', async () => {
-        services._loadCatalogFromCache = sinon.stub().resolves(false);
+      it('should call services#initServiceCatalogs() on webex loaded', async () => {
         services.initServiceCatalogs = sinon.stub().resolves();
         services.initialize();
-        webex.trigger('ready');
-        // Wait for the async 'ready' handler to complete
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        webex.trigger('loaded');
+        // Wait for the async callback to execute
+        await new Promise((resolve) => setTimeout(resolve, 10));
         assert.called(services.initServiceCatalogs);
-        assert.isTrue(catalog.isReady);
+      });
+
+      it('should set services.ready to true after initialization completes', async () => {
+        // services.ready starts as false
+        const newWebex = new WebexCore({credentials: {supertoken: webexUser.token}});
+        const newServices = newWebex.internal.services;
+
+        // Wait for initialization to complete
+        await new Promise((resolve) => {
+          newServices.on('services:initialized', resolve);
+        });
+
+        assert.isTrue(newServices.ready);
       });
 
       it('should collect different catalogs based on OrgId region', () =>

package/test/unit/spec/credentials/credentials.js

@@ -183,6 +183,10 @@ describe('webex-core', () => {
           webex.credentials.buildLoginUrl({state: 'state'});
         }, /if specified, `options.state` must be an object/);
 
+        assert.throws(() => {
+          webex.credentials.buildLoginUrl({state: null});
+        }, /if specified, `options.state` must be an object/);
+
         assert.doesNotThrow(() => {
           webex.credentials.buildLoginUrl({state: {}});
         }, /if specified, `options.state` must be an object/);
@@ -232,6 +236,132 @@ describe('webex-core', () => {
       });
     });
 
+    describe('#buildThirdPartyLoginUrl()', () => {
+      it('throws if both `oauth2provider` and `returnURL` are missing', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({});
+        }, /`options.oauth2provider` is required/);
+      });
+
+      it('throws if `oauth2provider` is missing', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({returnURL: 'https://web.webex.com'});
+        }, /`options.oauth2provider` is required/);
+      });
+
+      it('throws if `returnURL` is missing', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({oauth2provider: 'google'});
+        }, /`options.returnURL` is required/);
+      });
+
+      skipInBrowser(it)('generates the third-party login url', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.equal(
+          credentials.buildThirdPartyLoginUrl({
+            oauth2provider: 'google',
+            returnURL: 'https://web.webex.com',
+          }),
+          `${
+            process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+          }/idb/ThirdPartyLogin?oauth2provider=google&returnURL=https%3A%2F%2Fweb.webex.com`
+        );
+      });
+
+      skipInBrowser(it)('generates the url with different parameter values', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.equal(
+          credentials.buildThirdPartyLoginUrl({
+            oauth2provider: 'apple',
+            returnURL: 'https://example.com/callback',
+          }),
+          `${
+            process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+          }/idb/ThirdPartyLogin?oauth2provider=apple&returnURL=https%3A%2F%2Fexample.com%2Fcallback`
+        );
+      });
+
+      it('throws if `state` is not an object', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        assert.throws(() => {
+          credentials.buildThirdPartyLoginUrl({
+            oauth2provider: 'google',
+            returnURL: 'https://web.webex.com',
+            state: 'not-an-object',
+          });
+        }, /`options.state` must be an object/);
+      });
+
+      skipInBrowser(it)('omits `state` when an empty object is provided', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        const result = credentials.buildThirdPartyLoginUrl({
+          oauth2provider: 'google',
+          returnURL: 'https://web.webex.com',
+          state: {},
+        });
+
+        const parsed = new URL(result);
+
+        assert.isFalse(parsed.searchParams.has('state'));
+      });
+
+      skipInBrowser(it)('base64url-encodes a non-empty `state` and emits it as a top-level query param', () => {
+        const webex = new MockWebex();
+        const credentials = new Credentials(undefined, {parent: webex});
+
+        webex.trigger('change:config');
+
+        const result = credentials.buildThirdPartyLoginUrl({
+          oauth2provider: 'google',
+          returnURL: 'https://web.webex.com',
+          state: {csrf_token: 'abc', popUpSignIn: true},
+        });
+
+        // Literal base64url of '{"csrf_token":"abc","popUpSignIn":true}'
+        const expectedState = 'eyJjc3JmX3Rva2VuIjoiYWJjIiwicG9wVXBTaWduSW4iOnRydWV9';
+
+        assert.equal(
+          result,
+          `${
+            process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+          }/idb/ThirdPartyLogin?oauth2provider=google&returnURL=${encodeURIComponent(
+            'https://web.webex.com'
+          )}&state=${expectedState}`
+        );
+      });
+    });
+
     describe('#buildLogoutUrl()', () => {
       skipInBrowser(it)('generates the logout url', () => {
         const webex = new MockWebex();
@@ -368,7 +498,9 @@ describe('webex-core', () => {
       });
 
       it('should throw when provided an invalid token', () =>
-        expect(() => credentials.extractOrgIdFromUserToken()).toThrow('the provided token is not a valid format, token has 1 sections'));
+        expect(() => credentials.extractOrgIdFromUserToken()).toThrow(
+          'the provided token is not a valid format, token has 1 sections'
+        ));
 
       it('should throw when no token is provided', () =>
         expect(() => credentials.extractOrgIdFromUserToken()).toThrow());
@@ -799,7 +931,6 @@ describe('webex-core', () => {
           .then(() => assert.isRejected(webex.boundedStorage.get('Credentials', '@'), /NotFound/));
       });
 
-
       // it('does not induce any token refreshes');
 
       it('prevents #getUserToken() from being invoked', () => {

package/test/unit/spec/lib/batcher.js

@@ -7,6 +7,7 @@ import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import {Batcher} from '@webex/webex-core';
+import WebexHttpError from '../../../../src/lib/webex-http-error';
 
 function promiseTick(count) {
   let promise = Promise.resolve();
@@ -154,6 +155,61 @@ describe('webex-core', () => {
               return Promise.all([assert.isRejected(p1), assert.isRejected(p2)]);
             });
         });
+
+        it('does not trigger unhandledRejection when caller handles rejection', () => {
+          const unhandled = [];
+          const onUnhandledRejection = (reason) => {
+            unhandled.push(reason);
+          };
+
+          process.on('unhandledRejection', onUnhandledRejection);
+
+          const p = webex.internal.batcher.request(1);
+
+          // eslint-disable-next-line prefer-promise-reject-errors
+          webex.request.returns(Promise.reject({statusCode: 0}));
+
+          return promiseTick(50)
+            .then(() => clock.tick(2))
+            .then(() => promiseTick(50))
+            .then(() => assert.isRejected(p))
+            .then(() => promiseTick(50))
+            .then(() => {
+              assert.lengthOf(unhandled, 0);
+            })
+            .finally(() => {
+              process.removeListener('unhandledRejection', onUnhandledRejection);
+            });
+        });
+
+        it('fails queued deferreds for webex http errors without request body', () => {
+          const p1 = webex.internal.batcher.request(1);
+          const p2 = webex.internal.batcher.request(2);
+          const reason = new WebexHttpError.BadRequest({
+            statusCode: 400,
+            body: {message: 'simulated failure'},
+            options: {
+              method: 'GET',
+              uri: 'https://example.com/v1/mock/batch',
+              headers: {trackingid: 'test-tracking-id'},
+            },
+            headers: {},
+          });
+
+          webex.request.returns(Promise.reject(reason));
+
+          return promiseTick(50)
+            .then(() => clock.tick(2))
+            .then(() => promiseTick(50))
+            .then(() => {
+              assert.calledOnce(webex.request);
+
+              return Promise.all([
+                assert.isRejected(p1, /simulated failure/),
+                assert.isRejected(p2, /simulated failure/),
+              ]);
+            });
+        });
       });
 
       describe('when the number of request attempts exceeds a given threshold', () => {