@stream-io/video-client 1.54.0 → 1.55.0

package/src/__tests__/StreamVideoClient.api.test.ts

@@ -1,94 +1,122 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  type Mock,
+  vi,
+} from 'vitest';
 import { StreamVideoClient } from '../StreamVideoClient';
-import 'dotenv/config';
+import { Call } from '../Call';
+import { CallCreatedPayload } from './data';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
-import { StreamClient } from '@stream-io/node-sdk';
-import { CreateDeviceRequest } from '../gen/coordinator';
+import type { StreamClient } from '../coordinator/connection/client';
+import type {
+  CreateDeviceRequest,
+  GetEdgesResponse,
+  ListDevicesResponse,
+  QueryCallsResponse,
+  QueryCallStatsResponse,
+} from '../gen/coordinator';
 
-const apiKey = process.env.STREAM_API_KEY!;
-const secret = process.env.STREAM_SECRET!;
-
-const serverClient = new StreamClient(apiKey, secret);
+const apiKey = 'mock-api-key';
 
 describe('StreamVideoClient - coordinator API', () => {
   let client: StreamVideoClient;
+  // the client only talks to the backend through streamClient.post/get/delete,
+  // so we spy on those and assert against them instead of a live backend.
+  let post: Mock<StreamClient['post']>;
+  let get: Mock<StreamClient['get']>;
+  let del: Mock<StreamClient['delete']>;
+
+  beforeEach(() => {
+    client = new StreamVideoClient(apiKey, { browser: true });
+    post = vi.spyOn(client.streamClient, 'post');
+    get = vi.spyOn(client.streamClient, 'get');
+    del = vi.spyOn(client.streamClient, 'delete');
+  });
 
-  beforeAll(() => {
-    const user = { id: 'sara' };
-    client = new StreamVideoClient(apiKey, {
-      // tests run in node, so we have to fake being in browser env
-      browser: true,
-      timeout: 15000,
-    });
-    client.connectUser(
-      user,
-      serverClient.generateUserToken({ user_id: user.id }),
-    );
+  afterEach(() => {
+    vi.restoreAllMocks();
   });
 
-  it('query calls', { retry: 3, timeout: 20000 }, async () => {
-    let response = await client.queryCalls();
+  it('query calls', async () => {
+    const response: QueryCallsResponse = {
+      duration: '1ms',
+      next: 'next-page-token',
+      calls: [
+        {
+          call: CallCreatedPayload.call,
+          members: CallCreatedPayload.members,
+          own_capabilities: [],
+        },
+      ],
+    };
+    post.mockResolvedValue(response);
 
-    let calls = response.calls;
-    expect(calls.length).toBeGreaterThanOrEqual(1);
+    await client.queryCalls();
+    expect(post).toHaveBeenCalledWith('/calls', {});
 
     const queryCallsReq = {
       sort: [{ field: 'starts_at', direction: -1 }],
       limit: 2,
     };
-    response = await client.queryCalls(queryCallsReq);
-
-    calls = response.calls;
-    expect(calls.length).toBe(2);
-
-    response = await client.queryCalls({
-      ...queryCallsReq,
-      next: response.next,
-    });
-
-    expect(response.calls.length).toBeLessThanOrEqual(2);
-
-    response = await client.queryCalls({
-      filter_conditions: { backstage: { $eq: false } },
-    });
-
-    expect(response.calls.length).toBeGreaterThanOrEqual(1);
+    const result = await client.queryCalls(queryCallsReq);
+    expect(post).toHaveBeenCalledWith('/calls', queryCallsReq);
+
+    // each response entry is wrapped into a Call instance
+    expect(result.next).toBe('next-page-token');
+    expect(result.calls).toHaveLength(1);
+    const [call] = result.calls;
+    expect(call).toBeInstanceOf(Call);
+    expect(call.cid).toBe(CallCreatedPayload.call.cid);
   });
 
   it('query calls - ongoing', async () => {
-    const response = await client.queryCalls({
-      filter_conditions: { ongoing: { $eq: true } },
-    });
+    post.mockResolvedValue({ duration: '1ms', calls: [] });
+
+    const queryCallsReq = { filter_conditions: { ongoing: { $eq: true } } };
+    await client.queryCalls(queryCallsReq);
 
-    // Dummy test
-    expect(response.calls).toBeDefined();
+    expect(post).toHaveBeenCalledWith('/calls', queryCallsReq);
   });
 
   it('query calls - upcoming', async () => {
+    post.mockResolvedValue({ duration: '1ms', calls: [] });
+
     const mins30 = 1000 * 60 * 60 * 30;
     const inNext30mins = new Date(Date.now() + mins30);
-    const response = await client.queryCalls({
-      filter_conditions: {
-        starts_at: { $gt: inNext30mins.toISOString() },
-      },
-    });
+    const queryCallsReq = {
+      filter_conditions: { starts_at: { $gt: inNext30mins.toISOString() } },
+    };
+    await client.queryCalls(queryCallsReq);
 
-    // Dummy test
-    expect(response.calls).toBeDefined();
+    expect(post).toHaveBeenCalledWith('/calls', queryCallsReq);
   });
 
   it('query call stats', async () => {
-    const response = await client.queryCallStats({
+    const response: QueryCallStatsResponse = { duration: '1ms', reports: [] };
+    post.mockResolvedValue(response);
+
+    const result = await client.queryCallStats({
       filter_conditions: { call_cid: 'default:test' },
     });
 
-    expect(response.reports).toBeDefined();
+    expect(post).toHaveBeenCalledWith('/call/stats', {
+      filter_conditions: { call_cid: 'default:test' },
+    });
+    expect(result).toBe(response);
   });
 
   it('edges', async () => {
-    const response = await client.edges();
+    const response: GetEdgesResponse = { duration: '1ms', edges: [] };
+    get.mockResolvedValue(response);
+
+    const result = await client.edges();
 
-    expect(response.edges).toBeDefined();
+    expect(get).toHaveBeenCalledWith('/edges');
+    expect(result).toBe(response);
   });
 
   describe('devices', () => {
@@ -99,57 +127,55 @@ describe('StreamVideoClient - coordinator API', () => {
     };
 
     it('add device', async () => {
-      expect(
-        async () =>
-          await client.addDevice(
-            device.id,
-            device.push_provider,
-            device.push_provider_name,
-          ),
-      ).not.toThrowError();
+      post.mockResolvedValue(undefined);
+
+      await client.addDevice(
+        device.id,
+        device.push_provider,
+        device.push_provider_name,
+      );
+
+      expect(post).toHaveBeenCalledWith('/devices', {
+        id: device.id,
+        push_provider: device.push_provider,
+        voip_token: undefined,
+        push_provider_name: device.push_provider_name,
+      });
     });
 
     it('add voip device', async () => {
-      expect(
-        async () =>
-          await client.addVoipDevice(
-            device.id + 'voip',
-            device.push_provider,
-            device.push_provider_name!,
-          ),
-      ).not.toThrowError();
+      post.mockResolvedValue(undefined);
+
+      await client.addVoipDevice(
+        device.id + 'voip',
+        device.push_provider,
+        device.push_provider_name!,
+      );
+
+      expect(post).toHaveBeenCalledWith('/devices', {
+        id: device.id + 'voip',
+        push_provider: device.push_provider,
+        voip_token: true,
+        push_provider_name: device.push_provider_name,
+      });
     });
 
-    it('get devices', { retry: 3, timeout: 15000 }, async () => {
-      // Wait a little bit, because if we query devices too soon backend will return 404
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, 5000);
-      });
+    it('get devices', async () => {
+      const response: ListDevicesResponse = { duration: '1ms', devices: [] };
+      get.mockResolvedValue(response);
 
-      const response = await client.getDevices();
+      const result = await client.getDevices();
 
-      expect(response.devices.find((d) => d.id === device.id)).toBeDefined();
-      expect(
-        response.devices.find((d) => d.id === device.id + 'voip'),
-      ).toBeDefined();
+      expect(get).toHaveBeenCalledWith('/devices', {});
+      expect(result).toBe(response);
     });
 
-    it('remove device', { retry: 3, timeout: 15000 }, async () => {
-      // Wait a little bit, because if we query devices too soon backend will return 404
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, 5000);
-      });
+    it('remove device', async () => {
+      del.mockResolvedValue(undefined);
 
-      expect(
-        async () => await client.removeDevice(device.id),
-      ).not.toThrowError();
-      expect(
-        async () => await client.removeDevice(device.id + 'void'),
-      ).not.toThrowError();
-    });
-  });
+      await client.removeDevice(device.id);
 
-  afterAll(() => {
-    client.disconnectUser();
+      expect(del).toHaveBeenCalledWith('/devices', { id: device.id });
+    });
   });
 });

package/src/coordinator/connection/__tests__/connection.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { StreamClient } from '../client';
 import { StableWSConnection } from '../connection';
 import type { WSConnectionError } from '../types';
+import { getTimers } from '../../../timers';
 
 class StuckWebSocket {
   static CONNECTING = 0;
@@ -108,6 +109,27 @@ const buildClient = () => {
   return client;
 };
 
+describe('StableWSConnection connection-check timer source', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('arms the connection-check watchdog on the worker timer, not the main-thread setTimeout', () => {
+    const client = buildClient();
+    const wsConnection = new StableWSConnection(client);
+    const workerSetTimeout = vi
+      .spyOn(getTimers(), 'setTimeout')
+      .mockReturnValue(1 as unknown as number);
+    const mainSetTimeout = vi.spyOn(globalThis, 'setTimeout');
+
+    wsConnection.scheduleConnectionCheck();
+
+    expect(workerSetTimeout).toHaveBeenCalledTimes(1);
+    expect(mainSetTimeout).not.toHaveBeenCalled();
+  });
+});
+
 describe('StableWSConnection - silent handshake hang', () => {
   beforeEach(() => {
     StuckWebSocket.instances = [];

package/src/coordinator/connection/connection.ts

@@ -72,7 +72,7 @@ export class StableWSConnection {
   pingInterval = 25 * 1000;
   healthCheckTimeoutRef?: number;
   connectionCheckTimeout = this.pingInterval + 10 * 1000;
-  connectionCheckTimeoutRef?: NodeJS.Timeout;
+  connectionCheckTimeoutRef?: number;
   /** Store the last event time for health checks */
   lastEvent: Date | null = null;
 
@@ -174,6 +174,7 @@ export class StableWSConnection {
             await sleep(interval);
           }
         }
+        return undefined;
       })(),
       (async () => {
         await sleep(timeout);
@@ -221,7 +222,7 @@ export class StableWSConnection {
       getTimers().clearInterval(this.healthCheckTimeoutRef);
     }
     if (this.connectionCheckTimeoutRef) {
-      clearInterval(this.connectionCheckTimeoutRef);
+      getTimers().clearTimeout(this.connectionCheckTimeoutRef);
     }
 
     removeConnectionEventListeners(this.onlineStatusChanged);
@@ -372,6 +373,7 @@ export class StableWSConnection {
         this.client.resolveConnectionId?.(this.connectionID);
         return response;
       }
+      return undefined;
     } catch (caught) {
       const err = caught as WSConnectionError;
       this.isConnecting = false;
@@ -579,7 +581,7 @@ export class StableWSConnection {
         code === KnownCodes.TOKEN_EXPIRED &&
         !this.client.tokenManager.isStatic()
       ) {
-        clearTimeout(this.connectionCheckTimeoutRef);
+        getTimers().clearTimeout(this.connectionCheckTimeoutRef);
         this._log(
           'connect() - WS failure due to expired token, so going to try to reload token and reconnect',
         );
@@ -769,8 +771,9 @@ export class StableWSConnection {
    * to be reconnected.
    */
   scheduleConnectionCheck = () => {
-    clearTimeout(this.connectionCheckTimeoutRef);
-    this.connectionCheckTimeoutRef = setTimeout(() => {
+    const timers = getTimers();
+    timers.clearTimeout(this.connectionCheckTimeoutRef);
+    this.connectionCheckTimeoutRef = timers.setTimeout(() => {
       const now = new Date();
       if (
         this.lastEvent &&

package/src/gen/google/protobuf/struct.ts

@@ -1,10 +1,4 @@
 /* eslint-disable */
-import type {
-  JsonObject,
-  JsonReadOptions,
-  JsonValue,
-  JsonWriteOptions,
-} from '@protobuf-ts/runtime';
 // @generated by protobuf-ts 2.10.0 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
 // @generated from protobuf file "google/protobuf/struct.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
@@ -39,12 +33,13 @@ import type {
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-import {
-  isJsonObject,
-  MessageType,
-  typeofJsonValue,
-} from '@protobuf-ts/runtime';
-
+import { isJsonObject } from '@protobuf-ts/runtime';
+import { typeofJsonValue } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonObject } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
 /**
  * `Struct` represents a structured data value, consisting of fields
  * which map to dynamically typed values. In some languages, `Struct`

package/src/gen/google/protobuf/timestamp.ts

@@ -1,9 +1,4 @@
 /* eslint-disable */
-import type {
-  JsonReadOptions,
-  JsonValue,
-  JsonWriteOptions,
-} from '@protobuf-ts/runtime';
 // @generated by protobuf-ts 2.10.0 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
@@ -38,8 +33,12 @@ import type {
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-import { MessageType, PbLong, typeofJsonValue } from '@protobuf-ts/runtime';
-
+import { typeofJsonValue } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import { PbLong } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
 /**
  * A Timestamp represents a point in time independent of any time zone or local
  * calendar, encoded as a count of seconds and fractions of seconds at

package/src/gen/video/sfu/event/events.ts

@@ -2,32 +2,29 @@
 // @generated from protobuf file "video/sfu/event/events.proto" (package "stream.video.sfu.event", syntax proto3)
 // tslint:disable
 import { MessageType } from '@protobuf-ts/runtime';
-import {
-  CallEndedReason,
-  CallGrants,
-  CallState,
-  ClientCapability,
-  ClientDetails,
-  Codec,
-  ConnectionQuality,
-  DegradationPreference,
-  Error as Error$,
-  GoAwayReason,
-  ICETrickle as ICETrickle$,
-  Participant,
-  ParticipantCount,
-  ParticipantSource,
-  PeerType,
-  Pin,
-  PublishOption,
-  SubscribeOption,
-  TrackInfo,
-  TrackType,
-  TrackUnpublishReason,
-  WebsocketReconnectStrategy,
-} from '../models/models';
+import { CallEndedReason } from '../models/models';
+import { GoAwayReason } from '../models/models';
+import { CallGrants } from '../models/models';
+import { DegradationPreference } from '../models/models';
+import { Codec } from '../models/models';
+import { ConnectionQuality } from '../models/models';
+import { CallState } from '../models/models';
 import { TrackSubscriptionDetails } from '../signal_rpc/signal';
-
+import { TrackInfo } from '../models/models';
+import { ParticipantSource } from '../models/models';
+import { ClientCapability } from '../models/models';
+import { SubscribeOption } from '../models/models';
+import { ClientDetails } from '../models/models';
+import { TrackUnpublishReason } from '../models/models';
+import { Participant } from '../models/models';
+import { TrackType } from '../models/models';
+import { ParticipantCount } from '../models/models';
+import { PeerType } from '../models/models';
+import { WebsocketReconnectStrategy } from '../models/models';
+import { Error as Error$ } from '../models/models';
+import { Pin } from '../models/models';
+import { PublishOption } from '../models/models';
+import { ICETrickle as ICETrickle$ } from '../models/models';
 /**
  * SFUEvent is a message that is sent from the SFU to the client.
  *

package/src/gen/video/sfu/models/models.ts

@@ -4,7 +4,6 @@
 import { MessageType } from '@protobuf-ts/runtime';
 import { Struct } from '../../../google/protobuf/struct';
 import { Timestamp } from '../../../google/protobuf/timestamp';
-
 /**
  * CallState is the current state of the call
  * as seen by an SFU.
@@ -415,6 +414,10 @@ export interface TrackInfo {
    * @generated from protobuf field: int32 publish_option_id = 12;
    */
   publishOptionId: number;
+  /**
+   * @generated from protobuf field: bool self_sub_audio_video = 13;
+   */
+  selfSubAudioVideo: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Error
@@ -1770,6 +1773,12 @@ class TrackInfo$Type extends MessageType<TrackInfo> {
         kind: 'scalar',
         T: 5 /*ScalarType.INT32*/,
       },
+      {
+        no: 13,
+        name: 'self_sub_audio_video',
+        kind: 'scalar',
+        T: 8 /*ScalarType.BOOL*/,
+      },
     ]);
   }
 }

package/src/gen/video/sfu/signal_rpc/signal.client.ts

@@ -1,37 +1,32 @@
 // @generated by protobuf-ts 2.10.0 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
 // @generated from protobuf file "video/sfu/signal_rpc/signal.proto" (package "stream.video.sfu.signal", syntax proto3)
 // tslint:disable
-import type {
-  RpcOptions,
-  RpcTransport,
-  ServiceInfo,
-  UnaryCall,
-} from '@protobuf-ts/runtime-rpc';
-import { stackIntercept } from '@protobuf-ts/runtime-rpc';
-import type {
-  ICERestartRequest,
-  ICERestartResponse,
-  ICETrickleResponse,
-  SendAnswerRequest,
-  SendAnswerResponse,
-  SendMetricsRequest,
-  SendMetricsResponse,
-  SendStatsRequest,
-  SendStatsResponse,
-  SetPublisherRequest,
-  SetPublisherResponse,
-  StartNoiseCancellationRequest,
-  StartNoiseCancellationResponse,
-  StopNoiseCancellationRequest,
-  StopNoiseCancellationResponse,
-  UpdateMuteStatesRequest,
-  UpdateMuteStatesResponse,
-  UpdateSubscriptionsRequest,
-  UpdateSubscriptionsResponse,
-} from './signal';
+import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
+import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
 import { SignalServer } from './signal';
+import type { StopNoiseCancellationResponse } from './signal';
+import type { StopNoiseCancellationRequest } from './signal';
+import type { StartNoiseCancellationResponse } from './signal';
+import type { StartNoiseCancellationRequest } from './signal';
+import type { SendMetricsResponse } from './signal';
+import type { SendMetricsRequest } from './signal';
+import type { SendStatsResponse } from './signal';
+import type { SendStatsRequest } from './signal';
+import type { ICERestartResponse } from './signal';
+import type { ICERestartRequest } from './signal';
+import type { UpdateMuteStatesResponse } from './signal';
+import type { UpdateMuteStatesRequest } from './signal';
+import type { UpdateSubscriptionsResponse } from './signal';
+import type { UpdateSubscriptionsRequest } from './signal';
+import type { ICETrickleResponse } from './signal';
 import type { ICETrickle } from '../models/models';
-
+import type { SendAnswerResponse } from './signal';
+import type { SendAnswerRequest } from './signal';
+import { stackIntercept } from '@protobuf-ts/runtime-rpc';
+import type { SetPublisherResponse } from './signal';
+import type { SetPublisherRequest } from './signal';
+import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
  */

package/src/helpers/MediaPlaybackWatchdog.ts

@@ -93,6 +93,7 @@ export class MediaPlaybackWatchdog {
     const HAVE_CURRENT_DATA = 2;
     if (this.element.readyState < HAVE_CURRENT_DATA) return 'notReady';
     if (!this.element.paused) return 'notPaused';
+    return undefined;
   };
 
   private attemptPlay = async () => {