@stream-io/video-client 1.18.2 → 1.18.4

package/src/coordinator/connection/connection.ts

@@ -3,7 +3,6 @@ import {
   addConnectionEventListeners,
   isCloseEvent,
   KnownCodes,
-  randomId,
   removeConnectionEventListeners,
   retryInterval,
   sleep,
@@ -44,19 +43,18 @@ export class StableWSConnection {
   isConnecting: boolean;
   isDisconnected: boolean;
   isHealthy: boolean;
-  isResolved?: boolean;
+  isConnectionOpenResolved?: boolean;
   lastEvent: Date | null;
   connectionCheckTimeout: number;
   connectionCheckTimeoutRef?: NodeJS.Timeout;
-  rejectPromise?: (
+  rejectConnectionOpen?: (
     reason?: Error & {
       code?: string | number;
       isWSFailure?: boolean;
       StatusCode?: string | number;
     },
   ) => void;
-  requestID: string | undefined;
-  resolvePromise?: (value: ConnectedEvent) => void;
+  resolveConnectionOpen?: (value: ConnectedEvent) => void;
   totalFailures: number;
   ws?: WebSocket;
   wsID: number;
@@ -74,7 +72,7 @@ export class StableWSConnection {
     /** To avoid reconnect if client is disconnected */
     this.isDisconnected = false;
     /** Boolean that indicates if the connection promise is resolved */
-    this.isResolved = false;
+    this.isConnectionOpenResolved = false;
     /** Boolean that indicates if we have a working connection to the server */
     this.isHealthy = false;
     /** Incremented when a new WS connection is made */
@@ -89,9 +87,7 @@ export class StableWSConnection {
   }
 
   _log = (msg: string, extra: UR = {}, level: LogLevel = 'info') => {
-    this.client.logger(level, 'connection:' + msg, {
-      ...extra,
-    });
+    this.client.logger(level, `connection:${msg}`, extra);
   };
 
   setClient = (client: StreamClient) => {
@@ -285,9 +281,8 @@ export class StableWSConnection {
    * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
    */
   async _connect() {
-    if (this.isConnecting) return; // simply ignore _connect if it's currently trying to connect
+    if (this.isConnecting) return; // ignore _connect if it's currently trying to connect
     this.isConnecting = true;
-    this.requestID = randomId();
     let isTokenReady = false;
     try {
       this._log(`_connect() - waiting for token`);
@@ -310,10 +305,7 @@ export class StableWSConnection {
       }
       this._setupConnectionPromise();
       const wsURL = this._buildUrl();
-      this._log(`_connect() - Connecting to ${wsURL}`, {
-        wsURL,
-        requestID: this.requestID,
-      });
+      this._log(`_connect() - Connecting to ${wsURL}`);
       const WS = this.client.options.WebSocketImpl ?? WebSocket;
       this.ws = new WS(wsURL);
       this.ws.onopen = this.onopen.bind(this, this.wsID);
@@ -459,7 +451,7 @@ export class StableWSConnection {
       return;
     }
 
-    const authMessage: WSAuthMessage = {
+    const authMessage = JSON.stringify({
       token,
       user_details: {
         id: user.id,
@@ -467,9 +459,11 @@ export class StableWSConnection {
         image: user.image,
         custom: user.custom,
       },
-    };
+    } as WSAuthMessage);
+
+    this._log(`onopen() - Sending auth message ${authMessage}`, {}, 'trace');
 
-    this.ws?.send(JSON.stringify(authMessage));
+    this.ws?.send(authMessage);
     this._log('onopen() - onopen callback', { wsID });
   };
 
@@ -485,10 +479,14 @@ export class StableWSConnection {
     // we wait till the first message before we consider the connection open.
     // the reason for this is that auth errors and similar errors trigger a ws.onopen and immediately
     // after that a ws.onclose.
-    if (!this.isResolved && data && data.type === 'connection.error') {
-      this.isResolved = true;
+    if (
+      !this.isConnectionOpenResolved &&
+      data &&
+      data.type === 'connection.error'
+    ) {
+      this.isConnectionOpenResolved = true;
       if (data.error) {
-        this.rejectPromise?.(this._errorFromWSEvent(data, false));
+        this.rejectConnectionOpen?.(this._errorFromWSEvent(data, false));
         return;
       }
     }
@@ -505,7 +503,7 @@ export class StableWSConnection {
     }
 
     if (data && data.type === 'connection.ok') {
-      this.resolvePromise?.(data);
+      this.resolveConnectionOpen?.(data);
       this._setHealth(true);
     }
 
@@ -554,7 +552,7 @@ export class StableWSConnection {
       // @ts-expect-error
       error.target = event.target;
 
-      this.rejectPromise?.(error);
+      this.rejectConnectionOpen?.(error);
       this._log(`onclose() - WS connection reject with error ${event.reason}`, {
         event,
       });
@@ -564,7 +562,7 @@ export class StableWSConnection {
       this._setHealth(false);
       this.isConnecting = false;
 
-      this.rejectPromise?.(this._errorFromWSEvent(event));
+      this.rejectConnectionOpen?.(this._errorFromWSEvent(event));
 
       this._log(`onclose() - WS connection closed. Calling reconnect ...`, {
         event,
@@ -582,7 +580,7 @@ export class StableWSConnection {
     this.totalFailures += 1;
     this._setHealth(false);
     this.isConnecting = false;
-    this.rejectPromise?.(new Error(`WebSocket error: ${event}`));
+    this.rejectConnectionOpen?.(new Error(`WebSocket error: ${event}`));
     this._log(`onerror() - WS connection resulted into error`, { event });
 
     this._reconnect();
@@ -676,12 +674,12 @@ export class StableWSConnection {
    * _setupPromise - sets up the this.connectOpen promise
    */
   _setupConnectionPromise = () => {
-    this.isResolved = false;
+    this.isConnectionOpenResolved = false;
     /** a promise that is resolved once ws.open is called */
     this.connectionOpenSafe = makeSafePromise(
       new Promise<ConnectedEvent>((resolve, reject) => {
-        this.resolvePromise = resolve;
-        this.rejectPromise = reject;
+        this.resolveConnectionOpen = resolve;
+        this.rejectConnectionOpen = reject;
       }),
     );
   };

package/src/coordinator/connection/token_manager.ts

@@ -8,8 +8,8 @@ import type { TokenOrProvider, UserWithId } from './types';
  * Handles all the operations around user token.
  */
 export class TokenManager {
-  private loadTokenPromise: Promise<string> | null;
-  private type: 'static' | 'provider';
+  private loadTokenPromise: Promise<string> | null = null;
+  private type: 'static' | 'provider' = 'static';
   private readonly secret?: string;
   private token?: string;
   private tokenProvider?: TokenOrProvider;
@@ -17,9 +17,7 @@ export class TokenManager {
   private isAnonymous?: boolean;
 
   constructor(secret?: string) {
-    this.loadTokenPromise = null;
     this.secret = secret;
-    this.type = 'static';
   }
 
   /**
@@ -74,11 +72,7 @@ export class TokenManager {
       throw new Error('User token can not be empty');
     }
 
-    if (
-      tokenOrProvider &&
-      typeof tokenOrProvider !== 'string' &&
-      !isFunction(tokenOrProvider)
-    ) {
+    if (typeof tokenOrProvider !== 'string' && !isFunction(tokenOrProvider)) {
       throw new Error('User token should either be a string or a function');
     }
 

package/src/coordinator/connection/types.ts

@@ -157,6 +157,23 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    * The client app identifier.
    */
   clientAppIdentifier?: ClientAppIdentifier;
+
+  /**
+   * The default timeout for WebSocket connections.
+   */
+  defaultWsTimeout?: number;
+
+  /**
+   * The maximum number of retries to connect a user.
+   */
+  maxConnectUserRetries?: number;
+
+  /**
+   * A callback to be called one the maxUserConnectRetries is exhausted.
+   * @param lastError the last error.
+   * @param allErrors all errors.
+   */
+  onConnectUserError?: (lastError: Error, allErrors: Error[]) => void;
 };
 
 export type ClientAppIdentifier = {

package/src/coordinator/connection/utils.ts

@@ -19,8 +19,6 @@ export function isFunction<T>(value: Function | T): value is Function {
 export const KnownCodes = {
   TOKEN_EXPIRED: 40,
   WS_CLOSED_SUCCESS: 1000,
-  WS_CLOSED_ABRUPTLY: 1006,
-  WS_POLICY_VIOLATION: 1008,
 };
 
 /**
@@ -28,17 +26,13 @@ export const KnownCodes = {
  *
  * @return {number} Duration to wait in milliseconds
  */
-export function retryInterval(numberOfFailures: number) {
+export function retryInterval(numberOfFailures: number): number {
   // try to reconnect in 0.25-5 seconds (random to spread out the load from failures)
   const max = Math.min(500 + numberOfFailures * 2000, 5000);
   const min = Math.min(Math.max(250, (numberOfFailures - 1) * 2000), 5000);
   return Math.floor(Math.random() * (max - min) + min);
 }
 
-export function randomId() {
-  return generateUUIDv4();
-}
-
 function hex(bytes: Uint8Array): string {
   let s = '';
   for (let i = 0; i < bytes.length; i++) {
@@ -53,38 +47,25 @@ export function generateUUIDv4() {
   bytes[6] = (bytes[6] & 0x0f) | 0x40; // version
   bytes[8] = (bytes[8] & 0xbf) | 0x80; // variant
 
-  return (
-    hex(bytes.subarray(0, 4)) +
-    '-' +
-    hex(bytes.subarray(4, 6)) +
-    '-' +
-    hex(bytes.subarray(6, 8)) +
-    '-' +
-    hex(bytes.subarray(8, 10)) +
-    '-' +
-    hex(bytes.subarray(10, 16))
-  );
+  return [
+    hex(bytes.subarray(0, 4)),
+    hex(bytes.subarray(4, 6)),
+    hex(bytes.subarray(6, 8)),
+    hex(bytes.subarray(8, 10)),
+    hex(bytes.subarray(10, 16)),
+  ].join('-');
 }
 
-function getRandomValuesWithMathRandom(bytes: Uint8Array): void {
-  const max = Math.pow(2, (8 * bytes.byteLength) / bytes.length);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = Math.random() * max;
-  }
-}
-declare const msCrypto: Crypto;
-
 const getRandomValues = (() => {
-  if (
-    typeof crypto !== 'undefined' &&
-    typeof crypto?.getRandomValues !== 'undefined'
-  ) {
+  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
     return crypto.getRandomValues.bind(crypto);
-  } else if (typeof msCrypto !== 'undefined') {
-    return msCrypto.getRandomValues.bind(msCrypto);
-  } else {
-    return getRandomValuesWithMathRandom;
   }
+  return function getRandomValuesWithMathRandom(bytes: Uint8Array): void {
+    const max = Math.pow(2, (8 * bytes.byteLength) / bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.random() * max;
+    }
+  };
 })();
 
 function getRandomBytes(length: number): Uint8Array {
@@ -93,17 +74,6 @@ function getRandomBytes(length: number): Uint8Array {
   return bytes;
 }
 
-/**
- * Informs if a promise is yet to be resolved or rejected
- */
-export async function isPromisePending<T>(promise: Promise<T>) {
-  const emptyObj = {};
-  return Promise.race([promise, emptyObj]).then(
-    (value) => value === emptyObj,
-    () => false,
-  );
-}
-
 /**
  * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
  */

package/src/devices/CameraManager.ts

@@ -40,10 +40,9 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
           this.logger('warn', 'No video track found to do direction selection');
           return;
         }
-        const constraints = {
+        await videoTrack.applyConstraints({
           facingMode: direction === 'front' ? 'user' : 'environment',
-        };
-        await videoTrack.applyConstraints(constraints);
+        });
         this.state.setDirection(direction);
         this.state.setDevice(undefined);
       } else {

package/src/rtc/Publisher.ts

@@ -227,11 +227,6 @@ export class Publisher extends BasePeerConnection {
     }
     for (const track of this.clonedTracks) {
       this.stopTrack(track);
-      // @ts-expect-error release() is present in react-native-webrtc
-      if (track && typeof track.release === 'function') {
-        // @ts-expect-error
-        track.release();
-      }
     }
   };