@stream-io/video-client 0.2.2 → 0.3.0

package/src/Call.ts

@@ -28,6 +28,7 @@ import {
   GetCallResponse,
   GetOrCreateCallRequest,
   GetOrCreateCallResponse,
+  GoLiveRequest,
   GoLiveResponse,
   ListRecordingsResponse,
   MuteUsersRequest,
@@ -104,6 +105,7 @@ import {
   CallEventHandler,
   CallEventTypes,
   EventHandler,
+  EventTypes,
   Logger,
   StreamCallEvent,
 } from './coordinator/connection/types';
@@ -199,7 +201,6 @@ export class Call {
     type,
     id,
     streamClient,
-    metadata,
     members,
     ownCapabilities,
     sortParticipantsBy,
@@ -224,13 +225,17 @@ export class Call {
       this.state.setSortParticipantsBy(participantSorter);
     }
 
-    this.state.setMetadata(metadata);
     this.state.setMembers(members || []);
     this.state.setOwnCapabilities(ownCapabilities || []);
     this.state.setCallingState(
       ringing ? CallingState.RINGING : CallingState.IDLE,
     );
 
+    this.on('all', (event) => {
+      // update state with the latest event data
+      this.state.updateFromEvent(event);
+    });
+
     this.leaveCallHooks.push(
       registerEventHandlers(this, this.state, this.dispatcher),
     );
@@ -249,10 +254,10 @@ export class Call {
 
   private registerEffects() {
     this.leaveCallHooks.push(
-      // handles updating the permissions context when the metadata changes.
-      createSubscription(this.state.metadata$, (metadata) => {
-        if (!metadata) return;
-        this.permissionsContext.setCallSettings(metadata.settings);
+      // handles updating the permissions context when the settings change.
+      createSubscription(this.state.settings$, (settings) => {
+        if (!settings) return;
+        this.permissionsContext.setCallSettings(settings);
       }),
 
       // handle the case when the user permissions are modified.
@@ -283,13 +288,10 @@ export class Call {
       }),
 
       // handles the case when the user is blocked by the call owner.
-      createSubscription(this.state.metadata$, async (metadata) => {
-        if (!metadata) return;
+      createSubscription(this.state.blockedUserIds$, async (blockedUserIds) => {
+        if (!blockedUserIds) return;
         const currentUserId = this.currentUserId;
-        if (
-          currentUserId &&
-          metadata.blocked_user_ids.includes(currentUserId)
-        ) {
+        if (currentUserId && blockedUserIds.includes(currentUserId)) {
           this.logger('info', 'Leaving call because of being blocked');
           await this.leave();
         }
@@ -328,9 +330,9 @@ export class Call {
    * @returns a function which can be called to unsubscribe from the given event(s)
    */
   on(eventName: SfuEventKinds, fn: SfuEventListener): () => void;
-  on(eventName: CallEventTypes, fn: CallEventHandler): () => void;
+  on(eventName: EventTypes, fn: CallEventHandler): () => void;
   on(
-    eventName: SfuEventKinds | CallEventTypes,
+    eventName: SfuEventKinds | EventTypes,
     fn: SfuEventListener | CallEventHandler,
   ) {
     if (isSfuEvent(eventName)) {
@@ -419,13 +421,6 @@ export class Call {
     this.state.setCallingState(CallingState.LEFT);
   };
 
-  /**
-   * A getter for the call metadata.
-   */
-  get data() {
-    return this.state.metadata;
-  }
-
   /**
    * A flag indicating whether the call is "ringing" type of call.
    */
@@ -444,7 +439,7 @@ export class Call {
    * A flag indicating whether the call was created by the current user.
    */
   get isCreatedByMe() {
-    return this.state.metadata?.created_by.id === this.currentUserId;
+    return this.state.createdBy?.id === this.currentUserId;
   }
 
   /**
@@ -468,7 +463,7 @@ export class Call {
       this.ringingSubject.next(true);
     }
 
-    this.state.setMetadata(response.call);
+    this.state.updateFromCallResponse(response.call);
     this.state.setMembers(response.members);
     this.state.setOwnCapabilities(response.own_capabilities);
 
@@ -495,7 +490,7 @@ export class Call {
       this.ringingSubject.next(true);
     }
 
-    this.state.setMetadata(response.call);
+    this.state.updateFromCallResponse(response.call);
     this.state.setMembers(response.members);
     this.state.setOwnCapabilities(response.own_capabilities);
 
@@ -597,7 +592,7 @@ export class Call {
     let connectionConfig: RTCConfiguration | undefined;
     try {
       const call = await join(this.streamClient, this.type, this.id, data);
-      this.state.setMetadata(call.metadata);
+      this.state.updateFromCallResponse(call.metadata);
       this.state.setMembers(call.members);
       this.state.setOwnCapabilities(call.ownCapabilities);
       connectionConfig = call.connectionConfig;
@@ -814,7 +809,7 @@ export class Call {
       });
     }
 
-    const audioSettings = this.data?.settings.audio;
+    const audioSettings = this.state.settings?.audio;
     const isDtxEnabled = !!audioSettings?.opus_dtx_enabled;
     const isRedEnabled = !!audioSettings?.redundant_coding_enabled;
 
@@ -1461,11 +1456,14 @@ export class Call {
 
   /**
    * Starts the livestreaming of the call.
+   *
+   * @param data the request data.
+   * @param params the request params.
    */
-  goLive = async (params?: { notify?: boolean }) => {
-    return this.streamClient.post<GoLiveResponse>(
+  goLive = async (data: GoLiveRequest = {}, params?: { notify?: boolean }) => {
+    return this.streamClient.post<GoLiveResponse, GoLiveRequest>(
       `${this.streamClientBasePath}/go_live`,
-      {},
+      data,
       params,
     );
   };
@@ -1512,7 +1510,7 @@ export class Call {
     >(`${this.streamClientBasePath}`, updates);
 
     const { call, members, own_capabilities } = response;
-    this.state.setMetadata(call);
+    this.state.updateFromCallResponse(call);
     this.state.setMembers(members);
     this.state.setOwnCapabilities(own_capabilities);
 
@@ -1613,23 +1611,23 @@ export class Call {
 
   private scheduleAutoDrop = () => {
     if (this.dropTimeout) clearTimeout(this.dropTimeout);
-    const subscription = this.state.metadata$
+    const subscription = this.state.settings$
       .pipe(
         pairwise(),
-        tap(([prevMeta, currentMeta]) => {
-          if (!(currentMeta && this.clientStore.connectedUser)) return;
+        tap(([prevSettings, currentSettings]) => {
+          if (!currentSettings || !this.clientStore.connectedUser) return;
 
           const isOutgoingCall =
-            this.currentUserId === currentMeta.created_by.id;
+            this.currentUserId === this.state.createdBy?.id;
 
           const [prevTimeoutMs, timeoutMs] = isOutgoingCall
             ? [
-                prevMeta?.settings.ring.auto_cancel_timeout_ms,
-                currentMeta.settings.ring.auto_cancel_timeout_ms,
+                prevSettings?.ring.auto_cancel_timeout_ms,
+                currentSettings.ring.auto_cancel_timeout_ms,
               ]
             : [
-                prevMeta?.settings.ring.incoming_call_timeout_ms,
-                currentMeta.settings.ring.incoming_call_timeout_ms,
+                prevSettings?.ring.incoming_call_timeout_ms,
+                currentSettings.ring.incoming_call_timeout_ms,
               ];
           if (
             typeof timeoutMs === 'undefined' ||
@@ -1654,7 +1652,6 @@ export class Call {
 
   /**
    * Retrieves the list of recordings for the current call or call session.
-   * Updates the call state with the returned array of CallRecording objects.
    *
    * If `callSessionId` is provided, it will return the recordings for that call session.
    * Otherwise, all recordings for the current call will be returned.
@@ -1668,13 +1665,9 @@ export class Call {
     if (callSessionId) {
       endpoint = `${endpoint}/${callSessionId}`;
     }
-    const response = await this.streamClient.get<ListRecordingsResponse>(
+    return this.streamClient.get<ListRecordingsResponse>(
       `${endpoint}/recordings`,
     );
-
-    this.state.setCallRecordingsList(response.recordings);
-
-    return response;
   };
 
   /**

package/src/StreamVideoClient.ts

@@ -217,16 +217,15 @@ export class StreamVideoClient {
         }
 
         this.logger('info', `New call created and registered: ${call.cid}`);
-        this.writeableStateStore.registerCall(
-          new Call({
-            streamClient: this.streamClient,
-            type: call.type,
-            id: call.id,
-            metadata: call,
-            members,
-            clientStore: this.writeableStateStore,
-          }),
-        );
+        const newCall = new Call({
+          streamClient: this.streamClient,
+          type: call.type,
+          id: call.id,
+          members,
+          clientStore: this.writeableStateStore,
+        });
+        newCall.state.updateFromCallResponse(call);
+        this.writeableStateStore.registerCall(newCall);
       }),
     );
 
@@ -246,7 +245,6 @@ export class StreamVideoClient {
         // if `call.created` was received before `call.ring`.
         // In that case, we cleanup the already tracked call.
         const prevCall = this.writeableStateStore.findCall(call.type, call.id);
-        const prevMetadata = prevCall?.state.metadata;
         await prevCall?.leave();
         // we create a new call
         const theCall = new Call({
@@ -256,8 +254,8 @@ export class StreamVideoClient {
           members,
           clientStore: this.writeableStateStore,
           ringing: true,
-          metadata: prevMetadata,
         });
+        theCall.state.updateFromCallResponse(call);
         // we fetch the latest metadata for the call from the server
         await theCall.get();
         this.writeableStateStore.registerCall(theCall);
@@ -357,12 +355,12 @@ export class StreamVideoClient {
         streamClient: this.streamClient,
         id: c.call.id,
         type: c.call.type,
-        metadata: c.call,
         members: c.members,
         ownCapabilities: c.own_capabilities,
         watching: data.watch,
         clientStore: this.writeableStateStore,
       });
+      call.state.updateFromCallResponse(c.call);
       if (data.watch) {
         this.writeableStateStore.registerCall(call);
       }
@@ -374,10 +372,9 @@ export class StreamVideoClient {
     };
   };
 
-  queryUsers = async () => {
-    console.log('Querying users is not implemented yet.');
-  };
-
+  /**
+   * Returns a list of available data centers available for hosting calls.
+   */
   edges = async () => {
     return this.streamClient.get<GetEdgesResponse>(`/edges`);
   };

package/src/events/__tests__/call-permissions.test.ts

@@ -1,69 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import { CallState } from '../../store';
-import {
-  watchCallGrantsUpdated,
-  watchCallPermissionsUpdated,
-} from '../call-permissions';
+import { watchCallGrantsUpdated } from '../call-permissions';
 import { OwnCapability } from '../../gen/coordinator';
-import { ConnectionQuality } from '../../gen/video/sfu/models/models';
 
 describe('Call Permission Events', () => {
-  it('handles call.permissions_updated', () => {
-    const state = new CallState();
-    state.setParticipants([
-      {
-        userId: 'test',
-        name: 'test',
-        sessionId: 'test',
-        isDominantSpeaker: false,
-        isSpeaking: false,
-        audioLevel: 0,
-        image: '',
-        publishedTracks: [],
-        connectionQuality: ConnectionQuality.EXCELLENT,
-        roles: [],
-        trackLookupPrefix: '',
-        isLocalParticipant: true,
-      },
-    ]);
-    const handler = watchCallPermissionsUpdated(state);
-    handler({
-      type: 'call.permissions_updated',
-      created_at: '',
-      call_cid: 'development:12345',
-      own_capabilities: [OwnCapability.SEND_AUDIO, OwnCapability.SEND_VIDEO],
-      user: {
-        id: 'test',
-        created_at: '',
-        role: '',
-        updated_at: '',
-        custom: {},
-        teams: [],
-      },
-    });
-
-    expect(state.ownCapabilities).toEqual([
-      OwnCapability.SEND_AUDIO,
-      OwnCapability.SEND_VIDEO,
-    ]);
-
-    handler({
-      type: 'call.permissions_updated',
-      created_at: '',
-      call_cid: 'development:12345',
-      own_capabilities: [OwnCapability.SEND_VIDEO],
-      user: {
-        id: 'test',
-        created_at: '',
-        role: '',
-        updated_at: '',
-        custom: {},
-        teams: [],
-      },
-    });
-    expect(state.ownCapabilities).toEqual([OwnCapability.SEND_VIDEO]);
-  });
-
   it('handles sfu.callGrantsUpdated', () => {
     const state = new CallState();
     const handler = watchCallGrantsUpdated(state);

package/src/events/__tests__/call.test.ts

@@ -1,60 +1,15 @@
 import { describe, expect, it, vi } from 'vitest';
-import {
-  CallingState,
-  CallState,
-  StreamVideoWriteableStateStore,
-} from '../../store';
-import {
-  watchCallAccepted,
-  watchCallEnded,
-  watchCallRejected,
-  watchCallUpdated,
-} from '../call';
+import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { watchCallAccepted, watchCallEnded, watchCallRejected } from '../call';
 import {
   CallAcceptedEvent,
   CallEndedEvent,
   CallResponse,
-  CallUpdatedEvent,
 } from '../../gen/coordinator';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 
 describe('Call ringing events', () => {
-  describe('call.updated', () => {
-    it(`will update the call's metadata`, () => {
-      const state = new CallState();
-      const handler = watchCallUpdated(state);
-      const event: CallUpdatedEvent = {
-        type: 'call.updated',
-        call_cid: 'development:12345',
-        // @ts-expect-error
-        call: {
-          cid: 'development:12345',
-        },
-      };
-
-      // @ts-ignore
-      handler(event);
-      expect(state.metadata).toEqual(event.call);
-    });
-
-    it(`will ignore unknown events`, () => {
-      const state = new CallState();
-      const handler = watchCallUpdated(state);
-      const event = {
-        type: 'call.updated.unknown',
-        call_cid: 'development:12345',
-        call: {
-          cid: 'development:12345',
-        },
-      };
-
-      // @ts-ignore
-      handler(event);
-      expect(state.metadata).toBeUndefined();
-    });
-  });
-
   describe(`call.accepted`, () => {
     it(`will ignore events from the current user`, async () => {
       const call = fakeCall();
@@ -96,7 +51,7 @@ describe('Call ringing events', () => {
   describe(`call.rejected`, () => {
     it(`caller will leave the call if all callees have rejected`, async () => {
       const call = fakeCall({ currentUserId: 'm1' });
-      call.state.setMetadata({
+      call.state.updateFromCallResponse({
         ...fakeMetadata(),
         // @ts-ignore
         created_by: { id: 'm1' },
@@ -141,7 +96,7 @@ describe('Call ringing events', () => {
 
     it(`caller will not leave the call if only one callee rejects`, async () => {
       const call = fakeCall();
-      call.state.setMetadata({
+      call.state.updateFromCallResponse({
         ...fakeMetadata(),
         // @ts-ignore
         created_by: { id: 'm0' },
@@ -182,7 +137,7 @@ describe('Call ringing events', () => {
 
     it('callee will leave the call if caller rejects', async () => {
       const call = fakeCall({ currentUserId: 'm1' });
-      call.state.setMetadata({
+      call.state.updateFromCallResponse({
         ...fakeMetadata(),
         // @ts-ignore
         created_by: { id: 'm0' },

package/src/events/call-permissions.ts

@@ -1,21 +1,7 @@
-import { StreamVideoEvent } from '../coordinator/connection/types';
 import { CallState } from '../store';
 import { SfuEvent } from '../gen/video/sfu/event/events';
 import { OwnCapability } from '../gen/coordinator';
 
-/**
- * Event handler that watches for `call.permissions_updated` events
- */
-export const watchCallPermissionsUpdated = (state: CallState) => {
-  return function onCallPermissionsUpdated(event: StreamVideoEvent) {
-    if (event.type !== 'call.permissions_updated') return;
-    const { localParticipant } = state;
-    if (event.user.id === localParticipant?.userId) {
-      state.setOwnCapabilities(event.own_capabilities);
-    }
-  };
-};
-
 /**
  * Event handler that watches for `callGrantsUpdated` events.
  *

package/src/events/call.ts

@@ -1,4 +1,4 @@
-import { CallingState, CallState } from '../store';
+import { CallingState } from '../store';
 import { StreamVideoEvent } from '../coordinator/connection/types';
 import { Call } from '../Call';
 
@@ -76,24 +76,13 @@ export const watchCallRejected = (call: Call) => {
 export const watchCallEnded = (call: Call) => {
   return async function onCallCancelled(event: StreamVideoEvent) {
     if (event.type !== 'call.ended') return;
+    const { callingState } = call.state;
     if (
-      call.state.callingState === CallingState.RINGING ||
-      call.state.callingState === CallingState.JOINED ||
-      call.state.callingState === CallingState.JOINING
+      callingState === CallingState.RINGING ||
+      callingState === CallingState.JOINED ||
+      callingState === CallingState.JOINING
     ) {
-      call.state.setMetadata(event.call);
       await call.leave();
     }
   };
 };
-
-/**
- * An event handler which listens to `call.updated` events
- * and updates the given call state accordingly.
- */
-export const watchCallUpdated = (state: CallState) => {
-  return function onCallUpdated(event: StreamVideoEvent) {
-    if (event.type !== 'call.updated') return;
-    state.setMetadata(event.call);
-  };
-};

package/src/events/callEventHandlers.ts

@@ -3,31 +3,14 @@ import { Dispatcher } from '../rtc';
 import { CallState } from '../store';
 import {
   watchAudioLevelChanged,
-  watchBlockedUser,
   watchCallAccepted,
-  watchCallBroadcastingStarted,
-  watchCallBroadcastingStopped,
   watchCallEnded,
   watchCallGrantsUpdated,
-  watchCallLiveStarted,
-  watchCallMemberAdded,
-  watchCallMemberRemoved,
-  watchCallMemberUpdated,
-  watchCallMemberUpdatedPermission,
-  watchCallPermissionsUpdated,
-  watchCallRecordingStarted,
-  watchCallRecordingStopped,
   watchCallRejected,
-  watchCallSessionEnded,
-  watchCallSessionParticipantJoined,
-  watchCallSessionParticipantLeft,
-  watchCallSessionStarted,
-  watchCallUpdated,
   watchChangePublishQuality,
   watchConnectionQualityChanged,
   watchDominantSpeakerChanged,
   watchLiveEnded,
-  watchNewReactions,
   watchParticipantCountChanged,
   watchParticipantJoined,
   watchParticipantLeft,
@@ -35,7 +18,6 @@ import {
   watchSfuErrorReports,
   watchTrackPublished,
   watchTrackUnpublished,
-  watchUnblockedUser,
 } from '../events';
 import {
   CallEventTypes,
@@ -47,16 +29,6 @@ type RingCallEvents = Extract<
   'call.accepted' | 'call.rejected'
 >;
 
-type AllCallEvents = Exclude<
-  CallEventTypes,
-  | 'call.created' // handled by StreamVideoClient
-  | 'call.ring' // handled by StreamVideoClient
-  | 'call.notification' // not used currently
-  | 'call.permission_request' // should be handled by the SDK component
-  | 'custom' // integrators should handle custom events
-  | RingCallEvents // handled by registerRingingCallEventHandlers
->;
-
 /**
  * Registers the default event handlers for a call during its lifecycle.
  *
@@ -69,31 +41,9 @@ export const registerEventHandlers = (
   state: CallState,
   dispatcher: Dispatcher,
 ) => {
-  const coordinatorEvents: {
-    [key in AllCallEvents]: (e: StreamCallEvent) => any;
-  } = {
-    'call.blocked_user': watchBlockedUser(state),
-    'call.broadcasting_started': watchCallBroadcastingStarted(state),
-    'call.broadcasting_stopped': watchCallBroadcastingStopped(state),
-    'call.ended': watchCallEnded(call),
-    'call.live_started': watchCallLiveStarted(state),
-    'call.member_added': watchCallMemberAdded(state),
-    'call.member_removed': watchCallMemberRemoved(state),
-    'call.member_updated': watchCallMemberUpdated(state),
-    'call.member_updated_permission': watchCallMemberUpdatedPermission(state),
-    'call.permissions_updated': watchCallPermissionsUpdated(state),
-    'call.reaction_new': watchNewReactions(state),
-    'call.recording_started': watchCallRecordingStarted(state),
-    'call.recording_stopped': watchCallRecordingStopped(state),
-    'call.session_started': watchCallSessionStarted(state),
-    'call.session_ended': watchCallSessionEnded(state),
-    'call.session_participant_joined': watchCallSessionParticipantJoined(state),
-    'call.session_participant_left': watchCallSessionParticipantLeft(state),
-    'call.unblocked_user': watchUnblockedUser(state),
-    'call.updated': watchCallUpdated(state),
-    'call.user_muted': () => console.log('call.user_muted received'),
-  };
   const eventHandlers = [
+    call.on('call.ended', watchCallEnded(call)),
+
     watchLiveEnded(dispatcher, call),
     watchSfuErrorReports(dispatcher),
     watchChangePublishQuality(dispatcher, call),
@@ -113,11 +63,6 @@ export const registerEventHandlers = (
     call.on('pinsUpdated', watchPinsUpdated(state)),
   ];
 
-  Object.keys(coordinatorEvents).forEach((event) => {
-    const eventName = event as AllCallEvents;
-    eventHandlers.push(call.on(eventName, coordinatorEvents[eventName]));
-  });
-
   if (call.ringing) {
     // these events are only relevant when the call is ringing
     eventHandlers.push(registerRingingCallEventHandlers(call));

package/src/events/index.ts

@@ -1,11 +1,5 @@
-export * from './backstage';
 export * from './call';
 export * from './call-permissions';
 export * from './internal';
-export * from './members';
 export * from './participant';
-export * from './reactions';
-export * from './recording';
 export * from './speaker';
-export * from './sessions';
-export * from './moderation';

package/src/gen/coordinator/index.ts

@@ -2412,6 +2412,31 @@ export interface GetOrCreateCallResponse {
    */
   own_capabilities: Array<OwnCapability>;
 }
+/**
+ *
+ * @export
+ * @interface GoLiveRequest
+ */
+export interface GoLiveRequest {
+  /**
+   *
+   * @type {boolean}
+   * @memberof GoLiveRequest
+   */
+  start_hls?: boolean;
+  /**
+   *
+   * @type {boolean}
+   * @memberof GoLiveRequest
+   */
+  start_recording?: boolean;
+  /**
+   *
+   * @type {boolean}
+   * @memberof GoLiveRequest
+   */
+  start_transcription?: boolean;
+}
 /**
  *
  * @export

package/src/rtc/Dispatcher.ts

@@ -1,4 +1,4 @@
-import { CallEventTypes, Logger } from '../coordinator/connection/types';
+import { EventTypes, Logger } from '../coordinator/connection/types';
 import type { SfuEvent } from '../gen/video/sfu/event/events';
 import { getLogger } from '../logger';
 
@@ -26,7 +26,7 @@ const sfuEventKinds: { [key in SfuEventKinds]: undefined } = {
 };
 
 export const isSfuEvent = (
-  eventName: SfuEventKinds | CallEventTypes,
+  eventName: SfuEventKinds | EventTypes,
 ): eventName is SfuEventKinds => {
   return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
 };