@stream-io/video-client 1.4.8 → 1.5.0-0

package/src/StreamVideoClient.ts

@@ -84,29 +84,30 @@ export class StreamVideoClient {
 
     setLogger(logger, logLevel);
     this.logger = getLogger(['client']);
+    const coordinatorLogger = getLogger(['coordinator']);
 
     if (typeof apiKeyOrArgs === 'string') {
       this.streamClient = new StreamClient(apiKeyOrArgs, {
         persistUserOnConnectionFailure: true,
         ...opts,
         logLevel,
-        logger: this.logger,
+        logger: coordinatorLogger,
       });
     } else {
       this.streamClient = new StreamClient(apiKeyOrArgs.apiKey, {
         persistUserOnConnectionFailure: true,
         ...apiKeyOrArgs.options,
         logLevel,
-        logger: this.logger,
+        logger: coordinatorLogger,
       });
 
       const sdkInfo = getSdkInfo();
       if (sdkInfo) {
+        const sdkName = SdkType[sdkInfo.type].toLowerCase();
+        const sdkVersion = `${sdkInfo.major}.${sdkInfo.minor}.${sdkInfo.patch}`;
+        const userAgent = this.streamClient.getUserAgent();
         this.streamClient.setUserAgent(
-          this.streamClient.getUserAgent() +
-            `-video-${SdkType[sdkInfo.type].toLowerCase()}-sdk-${
-              sdkInfo.major
-            }.${sdkInfo.minor}.${sdkInfo.patch}`,
+          `${userAgent}-video-${sdkName}-sdk-${sdkVersion}`,
         );
       }
     }
@@ -142,10 +143,10 @@ export class StreamVideoClient {
    * @param user the user to connect.
    * @param token a token or a function that returns a token.
    */
-  async connectUser(
+  connectUser = async (
     user: User,
     token?: TokenOrProvider,
-  ): Promise<void | ConnectedEvent> {
+  ): Promise<void | ConnectedEvent> => {
     if (user.type === 'anonymous') {
       user.id = '!anon';
       return this.connectAnonymousUser(user as UserWithId, token);
@@ -254,7 +255,7 @@ export class StreamVideoClient {
     );
 
     return connectUserResponse;
-  }
+  };
 
   /**
    * Disconnects the currently connected user from the client.
@@ -359,7 +360,7 @@ export class StreamVideoClient {
         clientStore: this.writeableStateStore,
       });
       call.state.updateFromCallResponse(c.call);
-      await call.applyDeviceConfig();
+      await call.applyDeviceConfig(false);
       if (data.watch) {
         this.writeableStateStore.registerCall(call);
       }
@@ -424,12 +425,12 @@ export class StreamVideoClient {
    * @param {string} push_provider_name user provided push provider name
    * @param {string} [userID] the user id (defaults to current user)
    */
-  async addVoipDevice(
+  addVoipDevice = async (
     id: string,
     push_provider: string,
     push_provider_name: string,
     userID?: string,
-  ) {
+  ) => {
     return await this.addDevice(
       id,
       push_provider,
@@ -437,7 +438,7 @@ export class StreamVideoClient {
       userID,
       true,
     );
-  }
+  };
 
   /**
    * getDevices - Returns the devices associated with a current user
@@ -471,9 +472,7 @@ export class StreamVideoClient {
   onRingingCall = async (call_cid: string) => {
     // if we find the call and is already ringing, we don't need to create a new call
     // as client would have received the call.ring state because the app had WS alive when receiving push notifications
-    let call = this.readOnlyStateStore.calls.find(
-      (c) => c.cid === call_cid && c.ringing,
-    );
+    let call = this.state.calls.find((c) => c.cid === call_cid && c.ringing);
     if (!call) {
       // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
       const [callType, callId] = call_cid.split(':');

package/src/__tests__/Call.test.ts

@@ -1,10 +1,21 @@
-import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  MockInstance,
+  vi,
+} from 'vitest';
 import { StreamVideoClient } from '../StreamVideoClient';
 import 'dotenv/config';
 import { StreamClient } from '@stream-io/node-sdk';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import { CallingState } from '../store';
 import { Dispatcher } from '../rtc';
+import { Call } from '../Call';
+import { StreamVideoParticipant } from '../types';
+import { TrackType } from '../gen/video/sfu/models/models';
 
 const apiKey = process.env.STREAM_API_KEY!;
 const secret = process.env.STREAM_SECRET!;
@@ -15,13 +26,15 @@ const tokenProvider = async () =>
 
 let client: StreamVideoClient;
 
-beforeEach(() => {
+beforeEach(async () => {
   client = new StreamVideoClient({
     apiKey,
     options: { browser: true },
     tokenProvider,
     user: { id: 'jane' },
   });
+
+  await client.streamClient.wsPromise;
 });
 
 it('can get a call', async () => {
@@ -109,6 +122,136 @@ it("doesn't break when joining and leaving the same instance in quick succession
   ]);
 });
 
+describe('state updates in reponse to coordinator API', () => {
+  let call: Call;
+
+  beforeEach(() => {
+    call = client.call('default', generateUUIDv4());
+  });
+
+  it('should create and update state', async () => {
+    await call.create({
+      data: {
+        members: [{ user_id: 'sara' }],
+        settings_override: {
+          screensharing: {
+            enabled: false,
+          },
+          audio: {
+            default_device: 'earpiece',
+          },
+        },
+      },
+    });
+
+    expect(call.state.settings?.screensharing.enabled).toBe(false);
+    expect(call.state.settings?.audio.default_device).toBe('earpiece');
+    expect(call.state.members.length).toBe(1);
+    expect(call.state.members[0].user_id).toBe('sara');
+    expect(call.isCreatedByMe).toBe(true);
+  });
+
+  it('should get or create and update state', async () => {
+    await call.create({
+      data: {
+        members: [{ user_id: 'sara', role: 'admin' }],
+        settings_override: {
+          limits: {
+            max_participants: 5,
+          },
+        },
+      },
+    });
+
+    expect(call.state.settings?.limits.max_participants).toBe(5);
+    expect(call.state.members.length).toBe(1);
+    expect(call.state.members[0].user_id).toBe('sara');
+    expect(call.state.members[0].role).toBe('admin');
+  });
+
+  it('should get or create and update state', async () => {
+    await call.getOrCreate({
+      data: {
+        members: [{ user_id: 'sara', role: 'admin' }],
+        settings_override: {
+          limits: {
+            max_participants: 5,
+          },
+        },
+      },
+    });
+
+    expect(call.state.settings?.limits.max_participants).toBe(5);
+    expect(call.state.members.length).toBe(1);
+    expect(call.state.members[0].user_id).toBe('sara');
+    expect(call.state.members[0].role).toBe('admin');
+  });
+
+  it('should get and update state', async () => {
+    await serverClient.video.call(call.type, call.id).create({
+      data: {
+        settings_override: {
+          limits: { max_duration_seconds: 180 },
+        },
+        created_by_id: userId,
+      },
+    });
+
+    await call.get();
+
+    expect(call.state.settings?.limits.max_duration_seconds).toBe(180);
+  });
+
+  it('should ring', async () => {
+    await call.getOrCreate({ ring: true });
+
+    expect(call.ringing).toBe(true);
+
+    await call.leave();
+  });
+
+  afterEach(async () => {
+    await serverClient.video.call(call.type, call.id).delete({ hard: true });
+  });
+});
+
+describe('muting logic', () => {
+  let call: Call;
+  let spy: MockInstance;
+
+  beforeEach(async () => {
+    call = client.call('default', generateUUIDv4());
+    call.state.updateOrAddParticipant('1', {
+      userId: 'sara',
+      publishedTracks: [TrackType.AUDIO],
+    } as StreamVideoParticipant);
+
+    spy = vi
+      .spyOn(call, 'muteUser')
+      .mockImplementation(() => Promise.resolve({ duration: '0ms' }));
+  });
+
+  it('should mute self', () => {
+    call.muteSelf('audio');
+
+    expect(spy).toHaveBeenCalledWith(userId, 'audio');
+  });
+
+  it('should mute others', () => {
+    call.muteOthers('video');
+
+    expect(spy).not.toHaveBeenCalled();
+
+    call.muteOthers('audio');
+
+    expect(spy).toHaveBeenCalledWith(['sara'], 'audio');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+});
+
 afterEach(() => {
   client.disconnectUser();
 });

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

@@ -0,0 +1,168 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { StreamVideoClient } from '../StreamVideoClient';
+import 'dotenv/config';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { StreamClient } from '@stream-io/node-sdk';
+import { CreateDeviceRequest } from '../gen/coordinator';
+
+const apiKey = process.env.STREAM_API_KEY!;
+const secret = process.env.STREAM_SECRET!;
+
+const serverClient = new StreamClient(apiKey, secret);
+
+const tokenProvider = (userId: string) => {
+  return async () => {
+    return new Promise<string>((resolve) => {
+      setTimeout(() => {
+        const token = serverClient.createToken(
+          userId,
+          undefined,
+          Math.round(Date.now() / 1000 - 10),
+        );
+        resolve(token);
+      }, 100);
+    });
+  };
+};
+
+describe('StreamVideoClient - coordinator API', () => {
+  let client: StreamVideoClient;
+  const user = {
+    id: 'sara',
+  };
+
+  beforeAll(() => {
+    client = new StreamVideoClient(apiKey, {
+      // tests run in node, so we have to fake being in browser env
+      browser: true,
+    });
+    client.connectUser(user, tokenProvider(user.id));
+  });
+
+  it('query calls', async () => {
+    let response = await client.queryCalls();
+
+    let calls = response.calls;
+    expect(calls.length).toBeGreaterThanOrEqual(1);
+
+    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);
+  });
+
+  it('query calls - ongoing', async () => {
+    const response = await client.queryCalls({
+      filter_conditions: { ongoing: { $eq: true } },
+    });
+
+    // Dummy test
+    expect(response.calls).toBeDefined();
+  });
+
+  it('query calls - upcoming', async () => {
+    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() },
+      },
+    });
+
+    // Dummy test
+    expect(response.calls).toBeDefined();
+  });
+
+  it('query call stats', async () => {
+    const response = await client.queryCallStats({
+      filter_conditions: { call_cid: 'default:test' },
+    });
+
+    expect(response.reports).toBeDefined();
+  });
+
+  it('edges', async () => {
+    const response = await client.edges();
+
+    expect(response.edges).toBeDefined();
+  });
+
+  describe('devices', () => {
+    const device: CreateDeviceRequest = {
+      id: generateUUIDv4(),
+      push_provider: 'firebase',
+      push_provider_name: 'firebase',
+    };
+
+    it('add device', async () => {
+      expect(
+        async () =>
+          await client.addDevice(
+            device.id,
+            device.push_provider,
+            device.push_provider_name,
+          ),
+      ).not.toThrowError();
+    });
+
+    it('add voip device', async () => {
+      expect(
+        async () =>
+          await client.addVoipDevice(
+            device.id + 'voip',
+            device.push_provider,
+            device.push_provider_name!,
+          ),
+      ).not.toThrowError();
+    });
+
+    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);
+      });
+
+      const response = await client.getDevices();
+
+      expect(response.devices.find((d) => d.id === device.id)).toBeDefined();
+      expect(
+        response.devices.find((d) => d.id === device.id + 'voip'),
+      ).toBeDefined();
+    });
+
+    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);
+      });
+
+      expect(
+        async () => await client.removeDevice(device.id),
+      ).not.toThrowError();
+      expect(
+        async () => await client.removeDevice(device.id + 'void'),
+      ).not.toThrowError();
+    });
+  });
+
+  afterAll(() => {
+    client.disconnectUser();
+  });
+});

package/src/coordinator/connection/client.ts

@@ -12,10 +12,12 @@ import { TokenManager } from './token_manager';
 import { WSConnectionFallback } from './connection_fallback';
 import { isErrorResponse, isWSFailure } from './errors';
 import {
+  addConnectionEventListeners,
   isFunction,
   isOnline,
   KnownCodes,
   randomId,
+  removeConnectionEventListeners,
   retryInterval,
   sleep,
 } from './utils';
@@ -131,11 +133,19 @@ export class StreamClient {
       this.options.baseURL || 'https://video.stream-io-api.com/video',
     );
 
-    if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_RUN) {
+    if (
+      typeof process !== 'undefined' &&
+      'env' in process &&
+      process.env.STREAM_LOCAL_TEST_RUN
+    ) {
       this.setBaseURL('http://localhost:3030/video');
     }
 
-    if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_HOST) {
+    if (
+      typeof process !== 'undefined' &&
+      'env' in process &&
+      process.env.STREAM_LOCAL_TEST_HOST
+    ) {
       this.setBaseURL(`http://${process.env.STREAM_LOCAL_TEST_HOST}/video`);
     }
 
@@ -265,6 +275,7 @@ export class StreamClient {
     );
 
     try {
+      addConnectionEventListeners(this.updateNetworkConnectionStatus);
       return await this.setUserPromise;
     } catch (err) {
       if (this.persistUserOnConnectionFailure) {
@@ -398,6 +409,7 @@ export class StreamClient {
     this.anonymous = false;
 
     await this.closeConnection(timeout);
+    removeConnectionEventListeners(this.updateNetworkConnectionStatus);
 
     this.tokenManager.reset();
 
@@ -436,6 +448,7 @@ export class StreamClient {
     user: UserWithId,
     tokenOrProvider: TokenOrProvider,
   ) => {
+    addConnectionEventListeners(this.updateNetworkConnectionStatus);
     this.connectionIdPromise = new Promise<string | undefined>(
       (resolve, reject) => {
         this.resolveConnectionId = resolve;
@@ -661,7 +674,6 @@ export class StreamClient {
   };
 
   dispatchEvent = (event: StreamVideoEvent) => {
-    if (!event.received_at) event.received_at = new Date();
     this.logger('debug', `Dispatching event: ${event.type}`, event);
     if (!this.listeners) return;
 
@@ -855,10 +867,15 @@ export class StreamClient {
     });
   };
 
-  /**
-   * creates an abort controller that will be used by the next HTTP Request.
-   */
-  createAbortControllerForNextRequest = () => {
-    return (this.nextRequestAbortController = new AbortController());
+  updateNetworkConnectionStatus = (
+    event: { type: 'online' | 'offline' } | Event,
+  ) => {
+    if (event.type === 'offline') {
+      this.logger('debug', 'device went offline');
+      this.dispatchEvent({ type: 'network.changed', online: false });
+    } else if (event.type === 'online') {
+      this.logger('debug', 'device went online');
+      this.dispatchEvent({ type: 'network.changed', online: true });
+    }
   };
 }

package/src/coordinator/connection/connection.ts

@@ -382,7 +382,7 @@ export class StableWSConnection {
         );
         postInsights?.('ws_fatal', insights);
       }
-      this.client.rejectConnectionId?.();
+      this.client.rejectConnectionId?.(err);
       throw err;
     }
   }
@@ -578,6 +578,7 @@ export class StableWSConnection {
     }
 
     if (data) {
+      data.received_at = new Date();
       this.client.dispatchEvent(data);
     }
     this.scheduleConnectionCheck();

package/src/coordinator/connection/types.ts

@@ -52,6 +52,11 @@ export type ConnectionChangedEvent = {
   online: boolean;
 };
 
+export type NetworkChangedEvent = {
+  type: 'network.changed';
+  online: boolean;
+};
+
 export type TransportChangedEvent = {
   type: 'transport.changed';
   mode: 'longpoll';
@@ -63,6 +68,7 @@ export type ConnectionRecoveredEvent = {
 
 export type StreamVideoEvent = (
   | WSEvent
+  | NetworkChangedEvent
   | ConnectionChangedEvent
   | TransportChangedEvent
   | ConnectionRecoveredEvent

package/src/devices/BrowserPermission.ts

@@ -29,7 +29,7 @@ export class BrowserPermission {
         this.setState('granted');
       };
 
-      if (!canQueryPermissions()) {
+      if (!canQueryPermissions() && !isReactNative()) {
         return assumeGranted();
       }
 

package/src/devices/CameraManager.ts

@@ -61,7 +61,7 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
         this.logger('warn', 'could not apply target resolution', error);
       }
     }
-    if (this.state.status === 'enabled') {
+    if (this.enabled) {
       const { width, height } = this.state
         .mediaStream!.getVideoTracks()[0]
         ?.getSettings();

package/src/devices/InputMediaDeviceManager.ts

@@ -63,6 +63,13 @@ export abstract class InputMediaDeviceManager<
     return this.getDevices();
   }
 
+  /**
+   * Returns `true` when this device is in enabled state.
+   */
+  get enabled() {
+    return this.state.status === 'enabled';
+  }
+
   /**
    * Starts stream.
    */
@@ -216,7 +223,7 @@ export abstract class InputMediaDeviceManager<
   };
 
   protected async applySettingsToStream() {
-    if (this.state.status === 'enabled') {
+    if (this.enabled) {
       await this.muteStream();
       await this.unmuteStream();
     }
@@ -374,7 +381,7 @@ export abstract class InputMediaDeviceManager<
             .then(chainWith(parent), (error) => {
               this.logger(
                 'warn',
-                'Fitler failed to start and will be ignored',
+                'Filter failed to start and will be ignored',
                 error,
               );
               return parent;
@@ -384,13 +391,15 @@ export abstract class InputMediaDeviceManager<
     }
     if (this.call.state.callingState === CallingState.JOINED) {
       await this.publishStream(stream);
+    } else {
+      this.logger('debug', 'Stream is not published as the call is not joined');
     }
     if (this.state.mediaStream !== stream) {
       this.state.setMediaStream(stream, await rootStream);
       this.getTracks().forEach((track) => {
         track.addEventListener('ended', async () => {
           await this.statusChangeSettled();
-          if (this.state.status === 'enabled') {
+          if (this.enabled) {
             this.isTrackStoppedDueToTrackEnd = true;
             setTimeout(() => {
               this.isTrackStoppedDueToTrackEnd = false;

package/src/devices/MicrophoneManager.ts

@@ -25,7 +25,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   private noiseCancellation: INoiseCancellation | undefined;
   private noiseCancellationChangeUnsubscribe: (() => void) | undefined;
   private noiseCancellationRegistration?: Promise<void>;
-  private uregisterNoiseCancellation?: () => Promise<void>;
+  private unregisterNoiseCancellation?: () => Promise<void>;
 
   constructor(
     call: Call,
@@ -144,7 +144,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
         noiseCancellation.toFilter(),
       );
       this.noiseCancellationRegistration = registrationResult.registered;
-      this.uregisterNoiseCancellation = registrationResult.unregister;
+      this.unregisterNoiseCancellation = registrationResult.unregister;
       await this.noiseCancellationRegistration;
 
       // handles an edge case where a noise cancellation is enabled after
@@ -173,7 +173,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     if (isReactNative()) {
       throw new Error('Noise cancellation is not supported in React Native');
     }
-    await (this.uregisterNoiseCancellation?.() ?? Promise.resolve())
+    await (this.unregisterNoiseCancellation?.() ?? Promise.resolve())
       .then(() => this.noiseCancellation?.disable())
       .then(() => this.noiseCancellationChangeUnsubscribe?.())
       .catch((err) => {

package/src/devices/devices.ts

@@ -16,7 +16,7 @@ import { lazy } from '../helpers/lazy';
  * Returns an Observable that emits the list of available devices
  * that meet the given constraints.
  *
- * @param constraints the constraints to use when requesting the devices.
+ * @param permission a BrowserPermission instance.
  * @param kind the kind of devices to enumerate.
  */
 const getDevices = (permission: BrowserPermission, kind: MediaDeviceKind) => {