@stream-io/video-client 1.39.2 → 1.40.0

package/dist/index.es.js

@@ -3717,7 +3717,35 @@ const withHeaders = (headers) => {
         },
     };
 };
-const withRequestLogger = (logger, level) => {
+const TIMEOUT_SYMBOL = '@@stream-io/timeout';
+const withTimeout = (timeoutMs, trace) => {
+    const scheduleTimeout = (methodName) => {
+        const controller = new AbortController();
+        // aborts with specially crafted error that can be reliably recognized by
+        // @protobuf-ts/twirp-transport and our internal retry logic.
+        // https://github.com/timostamm/protobuf-ts/blob/657e64e80009e503e94f608fda423fbcbf4fb5a7/packages/twirp-transport/src/twirp-transport.ts#L102-L107
+        const timeoutId = setTimeout(() => {
+            trace?.(`${methodName}Timeout`, [timeoutMs]);
+            const error = new Error(TIMEOUT_SYMBOL);
+            error.name = 'AbortError';
+            controller.abort(error);
+        }, timeoutMs);
+        return [controller.signal, () => clearTimeout(timeoutId)];
+    };
+    return {
+        interceptUnary(next, method, input, options) {
+            // respect external abort signals if provided
+            if (options.abort)
+                return next(method, input, options);
+            // set up a custom abort signal for the RPC call
+            const [signal, cancel] = scheduleTimeout(method.name);
+            const invocation = next(method, input, { ...options, abort: signal });
+            invocation.then(cancel, cancel);
+            return invocation;
+        },
+    };
+};
+const withRequestLogger = (logger, level = 'trace') => {
     return {
         interceptUnary: (next, method, input, options) => {
             const invocation = next(method, input, options);
@@ -3736,18 +3764,21 @@ const withRequestTracer = (trace) => {
     const traceError = (name, input, err) => trace(`${name}OnFailure`, [err, input]);
     return {
         interceptUnary(next, method, input, options) {
-            const name = method.name;
-            if (exclusions.has(name))
+            const methodName = method.name;
+            if (exclusions.has(methodName))
                 return next(method, input, options);
-            trace(name, input);
+            const { invocationMeta: { attempt = 0 } = {} } = options;
+            const traceName = attempt === 0 ? methodName : `${methodName}(${attempt})`;
+            trace(traceName, input);
             const unaryCall = next(method, input, options);
             unaryCall.then((invocation) => {
                 const response = invocation.response;
                 if (response.error)
-                    traceError(name, input, response.error);
-                if (responseInclusions.has(name))
-                    trace(`${name}Response`, response);
-            }, (error) => traceError(name, input, error));
+                    traceError(traceName, input, response.error);
+                if (responseInclusions.has(methodName)) {
+                    trace(`${traceName}Response`, response);
+                }
+            }, (error) => traceError(methodName, input, error));
             return unaryCall;
         },
     };
@@ -3899,22 +3930,26 @@ const videoLoggerSystem = scopedLogger.createLoggerSystem();
  *
  * @param rpc the closure around the RPC call to execute.
  * @param signal the signal to abort the RPC call and retries loop.
+ * @param maxRetries the maximum number of retries to perform. Defaults to `Number.POSITIVE_INFINITY`.
  */
-const retryable = async (rpc, signal) => {
+const retryable = async (rpc, signal, maxRetries = Number.POSITIVE_INFINITY) => {
     let attempt = 0;
     let result = undefined;
     do {
         if (attempt > 0)
             await sleep(retryInterval(attempt));
         try {
-            result = await rpc();
+            result = await rpc({ attempt });
         }
         catch (err) {
             const isRequestCancelled = err instanceof RpcError &&
+                err.message !== TIMEOUT_SYMBOL &&
                 err.code === TwirpErrorCode[TwirpErrorCode.cancelled];
             const isAborted = signal?.aborted ?? false;
             if (isRequestCancelled || isAborted)
                 throw err;
+            if (attempt + 1 >= maxRetries)
+                throw err;
             videoLoggerSystem
                 .getLogger('sfu-client', { tags: ['rpc'] })
                 .debug(`rpc failed (${attempt})`, err);
@@ -6026,7 +6061,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.39.2";
+const version = "1.40.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8264,7 +8299,7 @@ class StreamSfuClient {
     /**
      * Constructs a new SFU client.
      */
-    constructor({ dispatcher, credentials, sessionId, cid, tag, joinResponseTimeout = 5000, onSignalClose, streamClient, enableTracing, }) {
+    constructor({ dispatcher, credentials, sessionId, cid, tag, joinResponseTimeout = 5000, rpcRequestTimeout = 5000, onSignalClose, streamClient, enableTracing, }) {
         /**
          * A buffer for ICE Candidates that are received before
          * the Publisher and Subscriber Peer Connections are ready to handle them.
@@ -8393,27 +8428,27 @@ class StreamSfuClient {
         };
         this.updateSubscriptions = async (tracks) => {
             await this.joinTask;
-            return retryable(() => this.rpc.updateSubscriptions({ sessionId: this.sessionId, tracks }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.updateSubscriptions({ sessionId: this.sessionId, tracks }, { invocationMeta }), this.abortController.signal);
         };
         this.setPublisher = async (data) => {
             await this.joinTask;
-            return retryable(() => this.rpc.setPublisher({ ...data, sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.setPublisher({ ...data, sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal, 3);
         };
         this.sendAnswer = async (data) => {
             await this.joinTask;
-            return retryable(() => this.rpc.sendAnswer({ ...data, sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.sendAnswer({ ...data, sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal);
         };
         this.iceTrickle = async (data) => {
             await this.joinTask;
-            return retryable(() => this.rpc.iceTrickle({ ...data, sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.iceTrickle({ ...data, sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal);
         };
         this.iceRestart = async (data) => {
             await this.joinTask;
-            return retryable(() => this.rpc.iceRestart({ ...data, sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.iceRestart({ ...data, sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal);
         };
         this.updateMuteStates = async (muteStates) => {
             await this.joinTask;
-            return retryable(() => this.rpc.updateMuteStates({ muteStates, sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.updateMuteStates({ muteStates, sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal);
         };
         this.sendStats = async (stats) => {
             await this.joinTask;
@@ -8422,11 +8457,11 @@ class StreamSfuClient {
         };
         this.startNoiseCancellation = async () => {
             await this.joinTask;
-            return retryable(() => this.rpc.startNoiseCancellation({ sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.startNoiseCancellation({ sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal);
         };
         this.stopNoiseCancellation = async () => {
             await this.joinTask;
-            return retryable(() => this.rpc.stopNoiseCancellation({ sessionId: this.sessionId }), this.abortController.signal);
+            return retryable((invocationMeta) => this.rpc.stopNoiseCancellation({ sessionId: this.sessionId }, { invocationMeta }), this.abortController.signal);
         };
         this.enterMigration = async (opts = {}) => {
             this.isLeaving = true;
@@ -8551,8 +8586,8 @@ class StreamSfuClient {
             interceptors: [
                 withHeaders({ Authorization: `Bearer ${token}` }),
                 this.tracer && withRequestTracer(this.tracer.trace),
-                this.logger.getLogLevel() === 'trace' &&
-                    withRequestLogger(this.logger, 'trace'),
+                this.logger.getLogLevel() === 'trace' && withRequestLogger(this.logger),
+                withTimeout(rpcRequestTimeout, this.tracer?.trace),
             ].filter((v) => !!v),
         });
         // Special handling for the ICETrickle kind of events.
@@ -12362,12 +12397,14 @@ class Call {
          *
          * @returns a promise which resolves once the call join-flow has finished.
          */
-        this.join = async ({ maxJoinRetries = 3, ...data } = {}) => {
+        this.join = async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, ...data } = {}) => {
             await this.setup();
             const callingState = this.state.callingState;
             if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
                 throw new Error(`Illegal State: call.join() shall be called only once`);
             }
+            this.joinResponseTimeout = joinResponseTimeout;
+            this.rpcRequestTimeout = rpcRequestTimeout;
             // we will count the number of join failures per SFU.
             // once the number of failures reaches 2, we will piggyback on the `migrating_from`
             // field to force the coordinator to provide us another SFU
@@ -12448,6 +12485,8 @@ class Call {
                     credentials: this.credentials,
                     streamClient: this.streamClient,
                     enableTracing: statsOptions.enable_rtc_stats,
+                    joinResponseTimeout: this.joinResponseTimeout,
+                    rpcRequestTimeout: this.rpcRequestTimeout,
                     // a new session_id is necessary for the REJOIN strategy.
                     // we use the previous session_id if available
                     sessionId: performingRejoin ? undefined : previousSessionId,
@@ -13716,6 +13755,15 @@ class Call {
                 },
             });
         };
+        /**
+         * Retrieves the call stats for the current call session in a format suitable
+         * for displaying in map-like UIs.
+         */
+        this.getCallStatsMap = async (params = {}, callSessionId = this.state.session?.id) => {
+            if (!callSessionId)
+                throw new Error('callSessionId is required');
+            return this.streamClient.get(`${this.streamClient.baseURL}/call_stats/${this.type}/${this.id}/${callSessionId}/map`, params);
+        };
         /**
          * Sends a custom event to all call participants.
          *
@@ -15041,7 +15089,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.39.2", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.40.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15599,7 +15647,6 @@ class StreamVideoClient {
                 return false;
             return this.state.calls.some((c) => c.cid !== currentCallId &&
                 c.ringing &&
-                !c.isCreatedByMe &&
                 c.state.callingState !== CallingState.IDLE &&
                 c.state.callingState !== CallingState.LEFT &&
                 c.state.callingState !== CallingState.RECONNECTING_FAILED);