@stream-io/video-client 1.11.4 → 1.11.6

package/dist/src/StreamVideoClient.d.ts

@@ -21,8 +21,7 @@ export declare class StreamVideoClient {
     protected readonly writeableStateStore: StreamVideoWriteableStateStore;
     streamClient: StreamClient;
     protected eventHandlersToUnregister: Array<() => void>;
-    protected connectionPromise: Promise<void | ConnectedEvent> | undefined;
-    protected disconnectionPromise: Promise<void> | undefined;
+    private readonly connectionConcurrencyTag;
     private static _instanceMap;
     /**
      * You should create only one instance of `StreamVideoClient`.
@@ -159,5 +158,5 @@ export declare class StreamVideoClient {
      * @param user the user to connect.
      * @param tokenOrProvider a token or a function that returns a token.
      */
-    protected connectAnonymousUser: (user: UserWithId, tokenOrProvider: TokenOrProvider) => Promise<void | ConnectedEvent>;
+    protected connectAnonymousUser: (user: UserWithId, tokenOrProvider: TokenOrProvider) => Promise<void>;
 }

package/dist/src/coordinator/connection/client.d.ts

@@ -4,7 +4,7 @@ import { TokenManager } from './token_manager';
 import { WSConnectionFallback } from './connection_fallback';
 import { AllClientEvents, AllClientEventTypes, APIErrorResponse, ClientEventListener, ConnectAPIResponse, ErrorFromResponse, Logger, StreamClientOptions, StreamVideoEvent, TokenOrProvider, User, UserWithId } from './types';
 import { InsightMetrics } from './insights';
-import { CreateGuestResponse } from '../../gen/coordinator';
+import { ConnectedEvent, CreateGuestResponse } from '../../gen/coordinator';
 export declare class StreamClient {
     _user?: UserWithId;
     anonymous: boolean;
@@ -28,14 +28,14 @@ export declare class StreamClient {
     wsBaseURL?: string;
     wsConnection: StableWSConnection | null;
     wsFallback?: WSConnectionFallback;
-    wsPromise: ConnectAPIResponse | null;
+    private wsPromiseSafe;
     consecutiveFailures: number;
     insightMetrics: InsightMetrics;
     defaultWSTimeoutWithFallback: number;
     defaultWSTimeout: number;
     resolveConnectionId?: Function;
     rejectConnectionId?: Function;
-    connectionIdPromise?: Promise<string | undefined>;
+    private connectionIdPromiseSafe?;
     guestUserCreatePromise?: Promise<CreateGuestResponse>;
     /**
      * Initialize a client.
@@ -64,7 +64,7 @@ export declare class StreamClient {
      *
      * @return {ConnectAPIResponse} Returns a promise that resolves when the connection is setup
      */
-    connectUser: (user: UserWithId, userTokenOrProvider: TokenOrProvider) => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    connectUser: (user: UserWithId, userTokenOrProvider: TokenOrProvider) => Promise<void | ConnectedEvent>;
     _setToken: (user: UserWithId, userTokenOrProvider: TokenOrProvider, isAnonymous: boolean) => Promise<void>;
     _setUser: (user: UserWithId) => void;
     /**
@@ -84,7 +84,7 @@ export declare class StreamClient {
     /**
      * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
      */
-    openConnection: () => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    openConnection: () => Promise<ConnectedEvent | undefined>;
     /**
      * Disconnects the websocket and removes the user from client.
      *
@@ -94,7 +94,7 @@ export declare class StreamClient {
     disconnectUser: (timeout?: number) => Promise<void>;
     connectGuestUser: (user: User & {
         type: "guest";
-    }) => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    }) => Promise<void | ConnectedEvent>;
     /**
      * connectAnonymousUser - Set an anonymous user and open a WebSocket connection
      */
@@ -117,7 +117,10 @@ export declare class StreamClient {
     /**
      * sets up the this.connectionIdPromise
      */
-    _setupConnectionIdPromise: () => Promise<void>;
+    _setupConnectionIdPromise: () => void;
+    get connectionIdPromise(): Promise<string | undefined> | undefined;
+    get isConnectionIsPromisePending(): boolean;
+    get wsPromise(): Promise<ConnectedEvent | undefined> | undefined;
     _logApiRequest: (type: string, url: string, data: unknown, config: AxiosRequestConfig & {
         config?: AxiosRequestConfig & {
             maxBodyLength?: number;
@@ -143,7 +146,7 @@ export declare class StreamClient {
     /**
      * @private
      */
-    connect: () => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
+    connect: () => Promise<ConnectedEvent | undefined>;
     /**
      * Check the connectivity with server for warmup purpose.
      *

package/dist/src/coordinator/connection/connection.d.ts

@@ -1,6 +1,6 @@
 import WebSocket from 'isomorphic-ws';
 import { StreamClient } from './client';
-import type { ConnectAPIResponse, LogLevel, UR } from './types';
+import type { LogLevel, UR } from './types';
 import type { ConnectedEvent } from '../../gen/coordinator';
 /**
  * StableWSConnection - A WS connection that reconnects upon failure.
@@ -21,7 +21,7 @@ import type { ConnectedEvent } from '../../gen/coordinator';
  */
 export declare class StableWSConnection {
     connectionID?: string;
-    connectionOpen?: ConnectAPIResponse;
+    private connectionOpenSafe?;
     authenticationSent: boolean;
     consecutiveFailures: number;
     pingInterval: number;
@@ -52,13 +52,13 @@ export declare class StableWSConnection {
      * the default 15s timeout allows between 2~3 tries
      * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
      */
-    connect(timeout?: number): Promise<void | ConnectedEvent>;
+    connect(timeout?: number): Promise<ConnectedEvent | undefined>;
     /**
      * _waitForHealthy polls the promise connection to see if its resolved until it times out
      * the default 15s timeout allows between 2~3 tries
      * @param timeout duration(ms)
      */
-    _waitForHealthy(timeout?: number): Promise<void | ConnectedEvent>;
+    _waitForHealthy(timeout?: number): Promise<ConnectedEvent | undefined>;
     /**
      * Builds and returns the url for websocket.
      * @private
@@ -126,6 +126,7 @@ export declare class StableWSConnection {
      * _setupPromise - sets up the this.connectOpen promise
      */
     _setupConnectionPromise: () => void;
+    get connectionOpen(): Promise<ConnectedEvent> | undefined;
     /**
      * Schedules a next health check ping for websocket.
      */

package/dist/src/helpers/promise.d.ts

@@ -0,0 +1,18 @@
+export interface SafePromise<T> {
+    (): Promise<T>;
+    checkPending(): boolean;
+}
+/**
+ * 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
+ */
+export declare function makeSafePromise<T>(promise: Promise<T>): SafePromise<T>;

package/dist/src/rtc/codecs.d.ts

@@ -5,8 +5,9 @@ import type { PreferredCodec } from '../types';
  * @param kind the kind of codec to get.
  * @param preferredCodec the codec to prioritize (vp8, h264, vp9, av1...).
  * @param codecToRemove the codec to exclude from the list.
+ * @param codecPreferencesSource the source of the codec preferences.
  */
-export declare const getPreferredCodecs: (kind: "audio" | "video", preferredCodec: string, codecToRemove?: string) => RTCRtpCodecCapability[] | undefined;
+export declare const getPreferredCodecs: (kind: "audio" | "video", preferredCodec: string, codecToRemove?: string, codecPreferencesSource?: "sender" | "receiver") => RTCRtpCodec[] | undefined;
 /**
  * Returns a generic SDP for the given direction.
  * We use this SDP to send it as part of our JoinRequest so that the SFU

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.11.4",
+  "version": "1.11.6",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/StreamVideoClient.ts

@@ -30,6 +30,7 @@ import {
 import { getLogger, logToConsole, setLogger } from './logger';
 import { getSdkInfo } from './client-details';
 import { SdkType } from './gen/video/sfu/models/models';
+import { withoutConcurrency } from './helpers/concurrency';
 
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
@@ -51,8 +52,9 @@ export class StreamVideoClient {
   streamClient: StreamClient;
 
   protected eventHandlersToUnregister: Array<() => void> = [];
-  protected connectionPromise: Promise<void | ConnectedEvent> | undefined;
-  protected disconnectionPromise: Promise<void> | undefined;
+  private readonly connectionConcurrencyTag = Symbol(
+    'connectionConcurrencyTag',
+  );
 
   private static _instanceMap: Map<string, StreamVideoClient> = new Map();
 
@@ -209,12 +211,11 @@ export 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);
@@ -316,19 +317,15 @@ export class StreamVideoClient {
    *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
    */
   disconnectUser = async (timeout?: number) => {
-    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 withoutConcurrency(this.connectionConcurrencyTag, () =>
+      disconnectUser(),
     );
-    await this.disconnectionPromise;
     if (userId) {
       StreamVideoClient._instanceMap.delete(apiKey + userId);
     }
@@ -556,10 +553,8 @@ export class StreamVideoClient {
   ) => {
     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(),
+    );
   };
 }

package/src/__tests__/Call.test.ts

@@ -271,8 +271,8 @@ describe('muting logic', () => {
       .mockImplementation(() => Promise.resolve({ duration: '0ms' }));
   });
 
-  it('should mute self', () => {
-    call.muteSelf('audio');
+  it('should mute self', async () => {
+    await call.muteSelf('audio');
 
     expect(spy).toHaveBeenCalledWith(userId, 'audio');
   });

package/src/coordinator/connection/client.ts

@@ -38,7 +38,12 @@ import {
 } from './types';
 import { InsightMetrics, postInsights } from './insights';
 import { getLocationHint } from './location';
-import { CreateGuestRequest, CreateGuestResponse } from '../../gen/coordinator';
+import {
+  ConnectedEvent,
+  CreateGuestRequest,
+  CreateGuestResponse,
+} from '../../gen/coordinator';
+import { makeSafePromise, type SafePromise } from '../../helpers/promise';
 
 export class StreamClient {
   _user?: UserWithId;
@@ -67,14 +72,14 @@ export class StreamClient {
   wsBaseURL?: string;
   wsConnection: StableWSConnection | null;
   wsFallback?: WSConnectionFallback;
-  wsPromise: ConnectAPIResponse | null;
+  private wsPromiseSafe: SafePromise<ConnectedEvent | undefined> | null;
   consecutiveFailures: number;
   insightMetrics: InsightMetrics;
   defaultWSTimeoutWithFallback: number;
   defaultWSTimeout: number;
   resolveConnectionId?: Function;
   rejectConnectionId?: Function;
-  connectionIdPromise?: Promise<string | undefined>;
+  private connectionIdPromiseSafe?: SafePromise<string | undefined>;
   guestUserCreatePromise?: Promise<CreateGuestResponse>;
 
   /**
@@ -155,7 +160,7 @@ export 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
@@ -340,12 +345,13 @@ export class StreamClient {
       );
     }
 
-    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 (
@@ -357,14 +363,15 @@ export class StreamClient {
         '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;
   };
 
   /**
@@ -388,7 +395,7 @@ export class StreamClient {
 
     this.tokenManager.reset();
 
-    this.connectionIdPromise = undefined;
+    this.connectionIdPromiseSafe = undefined;
     this.rejectConnectionId = undefined;
     this.resolveConnectionId = undefined;
   };
@@ -481,16 +488,28 @@ export class StreamClient {
   /**
    * sets up the this.connectionIdPromise
    */
-  _setupConnectionIdPromise = async () => {
+  _setupConnectionIdPromise = () => {
     /** a promise that is resolved once connection id is set */
-    this.connectionIdPromise = new Promise<string | undefined>(
-      (resolve, reject) => {
+    this.connectionIdPromiseSafe = makeSafePromise(
+      new Promise<string | undefined>((resolve, reject) => {
         this.resolveConnectionId = resolve;
         this.rejectConnectionId = reject;
-      },
+      }),
     );
   };
 
+  get connectionIdPromise() {
+    return this.connectionIdPromiseSafe?.();
+  }
+
+  get isConnectionIsPromisePending() {
+    return this.connectionIdPromiseSafe?.checkPending() ?? false;
+  }
+
+  get wsPromise() {
+    return this.wsPromiseSafe?.();
+  }
+
   _logApiRequest = (
     type: string,
     url: string,

package/src/coordinator/connection/connection.ts

@@ -8,20 +8,15 @@ import {
 import {
   addConnectionEventListeners,
   convertErrorToJson,
-  isPromisePending,
   KnownCodes,
   randomId,
   removeConnectionEventListeners,
   retryInterval,
   sleep,
 } from './utils';
-import type {
-  ConnectAPIResponse,
-  LogLevel,
-  StreamVideoEvent,
-  UR,
-} from './types';
+import type { LogLevel, StreamVideoEvent, UR } from './types';
 import type { ConnectedEvent, WSAuthMessage } from '../../gen/coordinator';
+import { makeSafePromise, type SafePromise } from '../../helpers/promise';
 
 // Type guards to check WebSocket error type
 const isCloseEvent = (
@@ -54,7 +49,7 @@ const isErrorEvent = (
 export class StableWSConnection {
   // local vars
   connectionID?: string;
-  connectionOpen?: ConnectAPIResponse;
+  private connectionOpenSafe?: SafePromise<ConnectedEvent>;
   authenticationSent: boolean;
   consecutiveFailures: number;
   pingInterval: number;
@@ -338,13 +333,7 @@ export class StableWSConnection {
         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();
@@ -747,12 +736,18 @@ export class StableWSConnection {
   _setupConnectionPromise = () => {
     this.isResolved = false;
     /** a promise that is resolved once ws.open is called */
-    this.connectionOpen = new Promise<ConnectedEvent>((resolve, reject) => {
-      this.resolvePromise = resolve;
-      this.rejectPromise = reject;
-    });
+    this.connectionOpenSafe = makeSafePromise(
+      new Promise<ConnectedEvent>((resolve, reject) => {
+        this.resolvePromise = resolve;
+        this.rejectPromise = reject;
+      }),
+    );
   };
 
+  get connectionOpen() {
+    return this.connectionOpenSafe?.();
+  }
+
   /**
    * Schedules a next health check ping for websocket.
    */

package/src/helpers/promise.ts

@@ -0,0 +1,47 @@
+export interface SafePromise<T> {
+  (): Promise<T>;
+  checkPending(): boolean;
+}
+
+type Fulfillment<T> =
+  | {
+      status: 'resolved';
+      result: T;
+    }
+  | {
+      status: 'rejected';
+      error: unknown;
+    };
+
+/**
+ * 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
+ */
+export function makeSafePromise<T>(promise: Promise<T>): SafePromise<T> {
+  let isPending = true;
+
+  const safePromise: Promise<Fulfillment<T>> = promise
+    .then(
+      (result) => ({ status: 'resolved' as const, result }),
+      (error) => ({ status: 'rejected' as const, error }),
+    )
+    .finally(() => (isPending = false));
+
+  const unwrapPromise = () =>
+    safePromise.then((fulfillment) => {
+      if (fulfillment.status === 'rejected') throw fulfillment.error;
+      return fulfillment.result;
+    });
+
+  unwrapPromise.checkPending = () => isPending;
+  return unwrapPromise;
+}

package/src/rtc/Publisher.ts

@@ -459,9 +459,14 @@ export class Publisher {
   private getCodecPreferences = (
     trackType: TrackType,
     preferredCodec?: string,
+    codecPreferencesSource?: 'sender' | 'receiver',
   ) => {
     if (trackType === TrackType.VIDEO) {
-      return getPreferredCodecs('video', preferredCodec || 'vp8');
+      return getPreferredCodecs(
+        'video',
+        preferredCodec || 'vp8',
+        codecPreferencesSource,
+      );
     }
     if (trackType === TrackType.AUDIO) {
       const defaultAudioCodec = this.isRedEnabled ? 'red' : 'opus';
@@ -575,8 +580,8 @@ export class Publisher {
     const opts = this.publishOptsForTrack.get(trackType);
     if (!opts || !opts.forceSingleCodec) return sdp;
 
-    const codec = opts.forceCodec || opts.preferredCodec;
-    const orderedCodecs = this.getCodecPreferences(trackType, codec);
+    const codec = opts.forceCodec || getOptimalVideoCodec(opts.preferredCodec);
+    const orderedCodecs = this.getCodecPreferences(trackType, codec, 'sender');
     if (!orderedCodecs || orderedCodecs.length === 0) return sdp;
 
     const transceiver = this.transceiverCache.get(trackType);

package/src/rtc/codecs.ts

@@ -9,15 +9,19 @@ import type { PreferredCodec } from '../types';
  * @param kind the kind of codec to get.
  * @param preferredCodec the codec to prioritize (vp8, h264, vp9, av1...).
  * @param codecToRemove the codec to exclude from the list.
+ * @param codecPreferencesSource the source of the codec preferences.
  */
 export const getPreferredCodecs = (
   kind: 'audio' | 'video',
   preferredCodec: string,
   codecToRemove?: string,
-): RTCRtpCodecCapability[] | undefined => {
-  if (!('getCapabilities' in RTCRtpReceiver)) return;
+  codecPreferencesSource: 'sender' | 'receiver' = 'receiver',
+): RTCRtpCodec[] | undefined => {
+  const source =
+    codecPreferencesSource === 'receiver' ? RTCRtpReceiver : RTCRtpSender;
+  if (!('getCapabilities' in source)) return;
 
-  const capabilities = RTCRtpReceiver.getCapabilities(kind);
+  const capabilities = source.getCapabilities(kind);
   if (!capabilities) return;
 
   const preferred: RTCRtpCodecCapability[] = [];