@stream-io/video-client 1.11.11 → 1.11.12

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.11.12](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.11...@stream-io/video-client-1.11.12) (2024-12-03)
+
+
+### Bug Fixes
+
+* handle timeout on SFU WS connections ([#1600](https://github.com/GetStream/stream-video-js/issues/1600)) ([5f2db7b](https://github.com/GetStream/stream-video-js/commit/5f2db7bd5cfdf57cdc04d6a6ed752f43e5b06657))
+
 ## [1.11.11](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.10...@stream-io/video-client-1.11.11) (2024-11-29)
 
 

package/dist/index.browser.es.js

@@ -3297,7 +3297,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.11.11";
+const version = "1.11.12";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6374,6 +6374,32 @@ const createWebSocketSignalChannel = (opts) => {
     return ws;
 };
 
+/**
+ * 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;
+}
 /**
  * Creates a new promise with resolvers.
  *
@@ -6426,7 +6452,6 @@ class StreamSfuClient {
         this.isLeaving = false;
         this.pingIntervalInMs = 10 * 1000;
         this.unhealthyTimeoutInMs = this.pingIntervalInMs + 5 * 1000;
-        this.restoreWebSocketConcurrencyTag = Symbol('recoverWebSocket');
         /**
          * Promise that resolves when the JoinResponse is received.
          * Rejects after a certain threshold if the response is not received.
@@ -6447,28 +6472,22 @@ class StreamSfuClient {
                 },
             });
             this.signalWs.addEventListener('close', this.handleWebSocketClose);
-            this.signalWs.addEventListener('error', this.restoreWebSocket);
-            this.signalReady = new Promise((resolve) => {
-                const onOpen = () => {
-                    this.signalWs.removeEventListener('open', onOpen);
-                    resolve(this.signalWs);
-                };
-                this.signalWs.addEventListener('open', onOpen);
-            });
+            this.signalReady = makeSafePromise(Promise.race([
+                new Promise((resolve) => {
+                    const onOpen = () => {
+                        this.signalWs.removeEventListener('open', onOpen);
+                        resolve(this.signalWs);
+                    };
+                    this.signalWs.addEventListener('open', onOpen);
+                }),
+                new Promise((resolve, reject) => {
+                    setTimeout(() => reject(new Error('SFU WS connection timed out')), this.joinResponseTimeout);
+                }),
+            ]));
         };
         this.cleanUpWebSocket = () => {
-            this.signalWs.removeEventListener('error', this.restoreWebSocket);
             this.signalWs.removeEventListener('close', this.handleWebSocketClose);
         };
-        this.restoreWebSocket = () => {
-            withoutConcurrency(this.restoreWebSocketConcurrencyTag, async () => {
-                await this.networkAvailableTask?.promise;
-                this.logger('debug', 'Restoring SFU WS connection');
-                this.cleanUpWebSocket();
-                await sleep(500);
-                this.createWebSocket();
-            }).catch((err) => this.logger('debug', `Can't restore WS connection`, err));
-        };
         this.handleWebSocketClose = () => {
             this.signalWs.removeEventListener('close', this.handleWebSocketClose);
             clearInterval(this.keepAliveInterval);
@@ -6562,7 +6581,7 @@ class StreamSfuClient {
         };
         this.join = async (data) => {
             // wait for the signal web socket to be ready before sending "joinRequest"
-            await this.signalReady;
+            await this.signalReady();
             if (this.joinResponseTask.isResolved || this.joinResponseTask.isRejected) {
                 // we need to lock the RPC requests until we receive a JoinResponse.
                 // that's why we have this primitive lock mechanism.
@@ -6617,7 +6636,7 @@ class StreamSfuClient {
             }));
         };
         this.send = async (message) => {
-            await this.signalReady; // wait for the signal ws to be open
+            await this.signalReady(); // wait for the signal ws to be open
             const msgJson = SfuRequest.toJson(message);
             if (this.signalWs.readyState !== WebSocket.OPEN) {
                 this.logger('debug', 'Signal WS is not open. Skipping message', msgJson);
@@ -9834,6 +9853,7 @@ class Call {
         this.reconnectAttempts = 0;
         this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
         this.fastReconnectDeadlineSeconds = 0;
+        this.disconnectionTimeoutSeconds = 0;
         this.lastOfflineTimestamp = 0;
         // maintain the order of publishing tracks to restore them after a reconnection
         // it shouldn't contain duplicates
@@ -10350,6 +10370,10 @@ class Call {
          */
         this.handleSfuSignalClose = (sfuClient) => {
             this.logger('debug', '[Reconnect] SFU signal connection closed');
+            // SFU WS closed before we finished current join, no need to schedule reconnect
+            // because join operation will fail
+            if (this.state.callingState === CallingState.JOINING)
+                return;
             // normal close, no need to reconnect
             if (sfuClient.isLeaving)
                 return;
@@ -10365,10 +10389,21 @@ class Call {
          * @param strategy the reconnection strategy to use.
          */
         this.reconnect = async (strategy) => {
+            if (this.state.callingState === CallingState.RECONNECTING ||
+                this.state.callingState === CallingState.RECONNECTING_FAILED)
+                return;
             return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
                 this.logger('info', `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[strategy]}`);
+                let reconnectStartTime = Date.now();
                 this.reconnectStrategy = strategy;
                 do {
+                    if (this.disconnectionTimeoutSeconds > 0 &&
+                        (Date.now() - reconnectStartTime) / 1000 >
+                            this.disconnectionTimeoutSeconds) {
+                        this.logger('warn', '[Reconnect] Stopping reconnection attempts after reaching disconnection timeout');
+                        this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+                        return;
+                    }
                     // we don't increment reconnect attempts for the FAST strategy.
                     if (this.reconnectStrategy !== WebsocketReconnectStrategy.FAST) {
                         this.reconnectAttempts++;
@@ -10468,7 +10503,7 @@ class Call {
             const currentPublisher = this.publisher;
             currentSubscriber?.detachEventHandlers();
             currentPublisher?.detachEventHandlers();
-            const migrationTask = currentSfuClient.enterMigration();
+            const migrationTask = makeSafePromise(currentSfuClient.enterMigration());
             try {
                 const currentSfu = currentSfuClient.edgeName;
                 await this.join({ ...this.joinCallData, migrating_from: currentSfu });
@@ -10484,7 +10519,7 @@ class Call {
                 // Wait for the migration to complete, then close the previous SFU client
                 // and the peer connection instances. In case of failure, the migration
                 // task would throw an error and REJOIN would be attempted.
-                await migrationTask;
+                await migrationTask();
                 // in MIGRATE, we can consider the call as joined only after
                 // `participantMigrationComplete` event is received, signaled by
                 // the `migrationTask`
@@ -11340,6 +11375,14 @@ class Call {
             this.dynascaleManager.setVideoTrackSubscriptionOverrides(enabled ? undefined : { enabled: false });
             this.dynascaleManager.applyTrackSubscriptions();
         };
+        /**
+         * Sets the maximum amount of time a user can remain waiting for a reconnect
+         * after a network disruption
+         * @param timeoutSeconds Timeout in seconds, or 0 to keep reconnecting indefinetely
+         */
+        this.setDisconnectionTimeout = (timeoutSeconds) => {
+            this.disconnectionTimeoutSeconds = timeoutSeconds;
+        };
         this.type = type;
         this.id = id;
         this.cid = `${type}:${id}`;
@@ -11495,33 +11538,6 @@ class Call {
 
 var https = null;
 
-/**
- * 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;
-}
-
 /**
  * StableWSConnection - A WS connection that reconnects upon failure.
  * - the browser will sometimes report that you're online or offline
@@ -12620,7 +12636,7 @@ class StreamClient {
             return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getUserAgent = () => {
-            const version = "1.11.11";
+            const version = "1.11.12";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };