@stream-io/video-client 1.11.4 → 1.11.5

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.11.5](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.4...@stream-io/video-client-1.11.5) (2024-11-22)
+
+
+### Bug Fixes
+
+* unhandled promise rejections during reconnect ([#1585](https://github.com/GetStream/stream-video-js/issues/1585)) ([920c4ea](https://github.com/GetStream/stream-video-js/commit/920c4ea3b3f622430b35ac1bade74a6206ee17e5)), closes [/github.com/GetStream/stream-video-js/pull/1585/files#diff-420f6ddab47c1be72fd9ce8c99e1fa2b9f5f0495b7c367546ee0ff634beaed81](https://github.com/GetStream//github.com/GetStream/stream-video-js/pull/1585/files/issues/diff-420f6ddab47c1be72fd9ce8c99e1fa2b9f5f0495b7c367546ee0ff634beaed81)
+
 ## [1.11.4](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.3...@stream-io/video-client-1.11.4) (2024-11-21)
 
 

package/dist/index.browser.es.js

@@ -3190,13 +3190,6 @@ function convertErrorToJson(err) {
     }
     return jsonObj;
 }
-/**
- * Informs if a promise is yet to be resolved or rejected
- */
-async function isPromisePending(promise) {
-    const emptyObj = {};
-    return Promise.race([promise, emptyObj]).then((value) => (value === emptyObj ? true : false), () => false);
-}
 /**
  * isOnline safely return the navigator.online value for browser env
  * if navigator is not in global object, it always return true
@@ -3335,7 +3328,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.11.4";
+const version = "1.11.5";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -11569,6 +11562,33 @@ function buildWsSuccessAfterFailureInsight(connection) {
     return buildWsBaseInsight(connection);
 }
 
+/**
+ * Saving a long-lived reference to a promise that can reject can be unsafe,
+ * since rejecting the promise causes an unhandled rejection error (even if the
+ * rejection is handled everywhere promise result is expected).
+ *
+ * To avoid that, we add both resolution and rejection handlers to the promise.
+ * That way, the saved promise never rejects. A callback is provided as return
+ * value to build a *new* promise, that resolves and rejects along with
+ * the original promise.
+ * @param promise Promise to wrap, which possibly rejects
+ * @returns Callback to build a new promise, which resolves and rejects along
+ * with the original promise
+ */
+function makeSafePromise(promise) {
+    let isPending = true;
+    const safePromise = promise
+        .then((result) => ({ status: 'resolved', result }), (error) => ({ status: 'rejected', error }))
+        .finally(() => (isPending = false));
+    const unwrapPromise = () => safePromise.then((fulfillment) => {
+        if (fulfillment.status === 'rejected')
+            throw fulfillment.error;
+        return fulfillment.result;
+    });
+    unwrapPromise.checkPending = () => isPending;
+    return unwrapPromise;
+}
+
 // Type guards to check WebSocket error type
 const isCloseEvent = (res) => res.code !== undefined;
 const isErrorEvent = (res) => res.error !== undefined;
@@ -11817,10 +11837,10 @@ class StableWSConnection {
         this._setupConnectionPromise = () => {
             this.isResolved = false;
             /** a promise that is resolved once ws.open is called */
-            this.connectionOpen = new Promise((resolve, reject) => {
+            this.connectionOpenSafe = makeSafePromise(new Promise((resolve, reject) => {
                 this.resolvePromise = resolve;
                 this.rejectPromise = reject;
-            });
+            }));
         };
         /**
          * Schedules a next health check ping for websocket.
@@ -12041,13 +12061,7 @@ class StableWSConnection {
                 this._log(`_connect() - tokenProvider failed before, so going to retry`);
                 await this.client.tokenManager.loadToken();
             }
-            let mustSetupConnectionIdPromise = true;
-            if (this.client.connectionIdPromise) {
-                if (await isPromisePending(this.client.connectionIdPromise)) {
-                    mustSetupConnectionIdPromise = false;
-                }
-            }
-            if (mustSetupConnectionIdPromise) {
+            if (!this.client.isConnectionIsPromisePending) {
                 this.client._setupConnectionIdPromise();
             }
             this._setupConnectionPromise();
@@ -12167,6 +12181,9 @@ class StableWSConnection {
             // we don't care
         }
     }
+    get connectionOpen() {
+        return this.connectionOpenSafe?.();
+    }
 }
 
 function isString(arrayOrString) {
@@ -12730,19 +12747,21 @@ class StreamClient {
             if (!this.userID) {
                 throw Error('UserWithId is not set on client, use client.connectUser or client.connectAnonymousUser instead');
             }
-            if (this.wsConnection?.isConnecting && this.wsPromise) {
+            const wsPromise = this.wsPromiseSafe?.();
+            if (this.wsConnection?.isConnecting && wsPromise) {
                 this.logger('info', 'client:openConnection() - connection already in progress');
-                return this.wsPromise;
+                return await wsPromise;
             }
             if ((this.wsConnection?.isHealthy || this.wsFallback?.isHealthy()) &&
                 this._hasConnectionID()) {
                 this.logger('info', 'client:openConnection() - openConnection called twice, healthy connection already exists');
-                return Promise.resolve();
+                return;
             }
             this._setupConnectionIdPromise();
             this.clientID = `${this.userID}--${randomId()}`;
-            this.wsPromise = this.connect();
-            return this.wsPromise;
+            const newWsPromise = this.connect();
+            this.wsPromiseSafe = makeSafePromise(newWsPromise);
+            return await newWsPromise;
         };
         /**
          * Disconnects the websocket and removes the user from client.
@@ -12760,7 +12779,7 @@ class StreamClient {
             await this.closeConnection(timeout);
             removeConnectionEventListeners(this.updateNetworkConnectionStatus);
             this.tokenManager.reset();
-            this.connectionIdPromise = undefined;
+            this.connectionIdPromiseSafe = undefined;
             this.rejectConnectionId = undefined;
             this.resolveConnectionId = undefined;
         };
@@ -12821,12 +12840,12 @@ class StreamClient {
         /**
          * sets up the this.connectionIdPromise
          */
-        this._setupConnectionIdPromise = async () => {
+        this._setupConnectionIdPromise = () => {
             /** a promise that is resolved once connection id is set */
-            this.connectionIdPromise = new Promise((resolve, reject) => {
+            this.connectionIdPromiseSafe = makeSafePromise(new Promise((resolve, reject) => {
                 this.resolveConnectionId = resolve;
                 this.rejectConnectionId = reject;
-            });
+            }));
         };
         this._logApiRequest = (type, url, data, config) => {
             this.logger('trace', `client: ${type} - Request - ${url}`, {
@@ -13044,7 +13063,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.11.4";
+            const version = "1.11.5";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -13158,7 +13177,7 @@ class StreamClient {
         });
         // WS connection is initialized when setUser is called
         this.wsConnection = null;
-        this.wsPromise = null;
+        this.wsPromiseSafe = null;
         this.setUserPromise = null;
         // mapping between channel groups and configs
         this.anonymous = false;
@@ -13175,6 +13194,15 @@ class StreamClient {
             ? inputOptions.logger
             : () => null;
     }
+    get connectionIdPromise() {
+        return this.connectionIdPromiseSafe?.();
+    }
+    get isConnectionIsPromisePending() {
+        return this.connectionIdPromiseSafe?.checkPending() ?? false;
+    }
+    get wsPromise() {
+        return this.wsPromiseSafe?.();
+    }
 }
 
 /**
@@ -13184,6 +13212,7 @@ class StreamVideoClient {
     constructor(apiKeyOrArgs, opts) {
         this.logLevel = 'warn';
         this.eventHandlersToUnregister = [];
+        this.connectionConcurrencyTag = Symbol('connectionConcurrencyTag');
         /**
          * Connects the given user to the client.
          * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
@@ -13205,11 +13234,7 @@ class StreamVideoClient {
                     return this.streamClient.connectGuestUser(user);
                 };
             }
-            this.connectionPromise = this.disconnectionPromise
-                ? this.disconnectionPromise.then(() => connectUser())
-                : connectUser();
-            this.connectionPromise?.finally(() => (this.connectionPromise = undefined));
-            const connectUserResponse = await this.connectionPromise;
+            const connectUserResponse = await withoutConcurrency(this.connectionConcurrencyTag, () => connectUser());
             // connectUserResponse will be void if connectUser called twice for the same user
             if (connectUserResponse?.me) {
                 this.writeableStateStore.setConnectedUser(connectUserResponse.me);
@@ -13286,17 +13311,13 @@ class StreamVideoClient {
          *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
          */
         this.disconnectUser = async (timeout) => {
-            if (!this.streamClient.user && !this.connectionPromise) {
+            if (!this.streamClient.user) {
                 return;
             }
             const userId = this.streamClient.user?.id;
             const apiKey = this.streamClient.key;
             const disconnectUser = () => this.streamClient.disconnectUser(timeout);
-            this.disconnectionPromise = this.connectionPromise
-                ? this.connectionPromise.then(() => disconnectUser())
-                : disconnectUser();
-            this.disconnectionPromise.finally(() => (this.disconnectionPromise = undefined));
-            await this.disconnectionPromise;
+            await withoutConcurrency(this.connectionConcurrencyTag, () => disconnectUser());
             if (userId) {
                 StreamVideoClient._instanceMap.delete(apiKey + userId);
             }
@@ -13471,11 +13492,7 @@ class StreamVideoClient {
          */
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
             const connectAnonymousUser = () => this.streamClient.connectAnonymousUser(user, tokenOrProvider);
-            this.connectionPromise = this.disconnectionPromise
-                ? this.disconnectionPromise.then(() => connectAnonymousUser())
-                : connectAnonymousUser();
-            this.connectionPromise.finally(() => (this.connectionPromise = undefined));
-            return this.connectionPromise;
+            return await withoutConcurrency(this.connectionConcurrencyTag, () => connectAnonymousUser());
         };
         let logger = logToConsole;
         let logLevel = 'warn';