@signalwire/js 3.2.1 → 3.4.0-dev.202110121150.a4432f2.0

package/src/{Room.test.ts → BaseRoomSession.test.ts}

@@ -1,19 +1,22 @@
 import { EventEmitter, actions } from '@signalwire/core'
-import { createRoomSessionObject } from './Room'
+import { createBaseRoomSessionObject } from './BaseRoomSession'
+import type { RoomSession } from './RoomSession'
 import { configureJestStore, configureFullStack } from './testUtils'
 
 describe('Room Object', () => {
   let store: any
-  let room: any
+  let room: RoomSession
 
   beforeEach(() => {
     store = configureJestStore()
-    room = createRoomSessionObject({
+    room = createBaseRoomSessionObject<RoomSession>({
       store,
       emitter: new EventEmitter(),
     })
+    // @ts-expect-error
     room.execute = jest.fn()
     // mock a room.subscribed event
+    // @ts-expect-error
     room.onRoomSubscribed({
       nodeId: 'node-id',
       roomId: 'room-id',
@@ -29,6 +32,8 @@ describe('Room Object', () => {
     expect(room.videoUnmute).toBeDefined()
     expect(room.deaf).toBeDefined()
     expect(room.undeaf).toBeDefined()
+    expect(room.setInputVolume).toBeDefined()
+    expect(room.setOutputVolume).toBeDefined()
     expect(room.setMicrophoneVolume).toBeDefined()
     expect(room.setSpeakerVolume).toBeDefined()
     expect(room.setInputSensitivity).toBeDefined()
@@ -40,6 +45,8 @@ describe('Room Object', () => {
     expect(room.showVideoMuted).toBeDefined()
     expect(room.getRecordings).toBeDefined()
     expect(room.startRecording).toBeDefined()
+    expect(room.getPlaybacks).toBeDefined()
+    expect(room.play).toBeDefined()
   })
 
   describe('getRecordings', () => {
@@ -53,12 +60,13 @@ describe('Room Object', () => {
         recordings: recordingList,
       })
 
-      room = createRoomSessionObject({
+      room = createBaseRoomSessionObject({
         store,
         // @ts-expect-error
         emitter,
       })
       // mock a room.subscribed event
+      // @ts-expect-error
       room.onRoomSubscribed({
         nodeId: 'node-id',
         roomId: '6e83849b-5cc2-4fc6-80ed-448113c8a426',
@@ -75,6 +83,7 @@ describe('Room Object', () => {
 
   describe('startRecording', () => {
     it('should return an interactive object', async () => {
+      // @ts-expect-error
       ;(room.execute as jest.Mock).mockResolvedValueOnce({
         code: '200',
         message: 'Recording started',
@@ -82,6 +91,7 @@ describe('Room Object', () => {
       })
 
       const recording = await room.startRecording()
+      // @ts-expect-error
       recording.execute = jest.fn()
       expect(recording.id).toEqual('c22d7223-5a01-49fe-8da0-46bec8e75e32')
       expect(recording.roomSessionId).toEqual('room-session-id')
@@ -97,16 +107,19 @@ describe('Room Object', () => {
         },
       }
       await recording.pause()
+      // @ts-expect-error
       expect(recording.execute).toHaveBeenLastCalledWith({
         ...baseExecuteParams,
         method: 'video.recording.pause',
       })
       await recording.resume()
+      // @ts-expect-error
       expect(recording.execute).toHaveBeenLastCalledWith({
         ...baseExecuteParams,
         method: 'video.recording.resume',
       })
       await recording.stop()
+      // @ts-expect-error
       expect(recording.execute).toHaveBeenLastCalledWith({
         ...baseExecuteParams,
         method: 'video.recording.stop',
@@ -114,11 +127,13 @@ describe('Room Object', () => {
     })
 
     it('should work with simulataneous recordings', async () => {
+      // @ts-expect-error
       ;(room.execute as jest.Mock).mockResolvedValueOnce({
         code: '200',
         message: 'Recording started',
         recording_id: 'first-recording',
       })
+      // @ts-expect-error
       ;(room.execute as jest.Mock).mockResolvedValueOnce({
         code: '200',
         message: 'Recording started',
@@ -126,13 +141,16 @@ describe('Room Object', () => {
       })
 
       const firstRecording = await room.startRecording()
+      // @ts-expect-error
       firstRecording.execute = jest.fn()
       const secondRecording = await room.startRecording()
+      // @ts-expect-error
       secondRecording.execute = jest.fn()
 
       expect(firstRecording.id).toEqual('first-recording')
       expect(firstRecording.roomSessionId).toEqual('room-session-id')
       await firstRecording.stop()
+      // @ts-expect-error
       expect(firstRecording.execute).toHaveBeenLastCalledWith({
         method: 'video.recording.stop',
         params: {
@@ -144,6 +162,7 @@ describe('Room Object', () => {
       expect(secondRecording.id).toEqual('second-recording')
       expect(secondRecording.roomSessionId).toEqual('room-session-id')
       await secondRecording.stop()
+      // @ts-expect-error
       expect(secondRecording.execute).toHaveBeenLastCalledWith({
         method: 'video.recording.stop',
         params: {
@@ -154,16 +173,180 @@ describe('Room Object', () => {
     })
   })
 
+  describe('playback methods', () => {
+    it('getPlaybacks should return an array of playbacks', async () => {
+      const { store, session, emitter } = configureFullStack()
+      const playbacks = [{ id: 'playbackOne' }, { id: 'playbackTwo' }]
+
+      session.execute = jest.fn().mockResolvedValue({
+        code: '200',
+        message: 'OK',
+        playbacks,
+      })
+
+      room = createBaseRoomSessionObject({
+        store,
+        // @ts-expect-error
+        emitter,
+      })
+      // mock a room.subscribed event
+      // @ts-expect-error
+      room.onRoomSubscribed({
+        nodeId: 'node-id',
+        roomId: '6e83849b-5cc2-4fc6-80ed-448113c8a426',
+        roomSessionId: '8e03ac25-8622-411a-95fc-f897b34ac9e7',
+        memberId: 'member-id',
+      })
+
+      const result = await room.getPlaybacks()
+      expect(result).toStrictEqual({
+        playbacks,
+      })
+    })
+
+    it('play should return an interactive object', async () => {
+      // @ts-expect-error
+      ;(room.execute as jest.Mock).mockResolvedValueOnce({
+        code: '200',
+        message: 'Playback started',
+        playback: {
+          id: 'c22d7223-5a01-49fe-8da0-46bec8e75e32',
+          state: 'playing',
+          started_at: 1234,
+        },
+      })
+
+      const playback = await room.play({
+        url: 'rtmp://jest.example.com/bla',
+        volume: 5,
+      })
+      // @ts-expect-error
+      playback.execute = jest.fn()
+
+      // @ts-expect-error
+      expect(room.execute).toHaveBeenLastCalledWith({
+        method: 'video.playback.start',
+        params: {
+          room_session_id: 'room-session-id',
+          url: 'rtmp://jest.example.com/bla',
+          volume: 5,
+        },
+      })
+
+      expect(playback.id).toEqual('c22d7223-5a01-49fe-8da0-46bec8e75e32')
+      expect(playback.roomSessionId).toEqual('room-session-id')
+      expect(playback.pause).toBeDefined()
+      expect(playback.resume).toBeDefined()
+      expect(playback.stop).toBeDefined()
+
+      const baseExecuteParams = {
+        method: '',
+        params: {
+          room_session_id: 'room-session-id',
+          playback_id: 'c22d7223-5a01-49fe-8da0-46bec8e75e32',
+        },
+      }
+      await playback.pause()
+      // @ts-expect-error
+      expect(playback.execute).toHaveBeenLastCalledWith({
+        ...baseExecuteParams,
+        method: 'video.playback.pause',
+      })
+      await playback.resume()
+      // @ts-expect-error
+      expect(playback.execute).toHaveBeenLastCalledWith({
+        ...baseExecuteParams,
+        method: 'video.playback.resume',
+      })
+      await playback.stop()
+      // @ts-expect-error
+      expect(playback.execute).toHaveBeenLastCalledWith({
+        ...baseExecuteParams,
+        method: 'video.playback.stop',
+      })
+      await playback.setVolume(30)
+      // @ts-expect-error
+      expect(playback.execute).toHaveBeenLastCalledWith({
+        method: 'video.playback.set_volume',
+        params: {
+          room_session_id: 'room-session-id',
+          playback_id: 'c22d7223-5a01-49fe-8da0-46bec8e75e32',
+          volume: 30,
+        },
+      })
+    })
+
+    it('play should work with simulataneous playbacks', async () => {
+      // @ts-expect-error
+      ;(room.execute as jest.Mock).mockResolvedValueOnce({
+        code: '200',
+        message: 'Playback started',
+        playback: {
+          id: 'first-playback',
+          state: 'playing',
+          started_at: 1234,
+        },
+      })
+      // @ts-expect-error
+      ;(room.execute as jest.Mock).mockResolvedValueOnce({
+        code: '200',
+        message: 'Playback started',
+        playback: {
+          id: 'second-playback',
+          state: 'playing',
+          started_at: 1234,
+        },
+      })
+
+      const firstPlayback = await room.play({
+        url: 'url-one',
+      })
+      // @ts-expect-error
+      firstPlayback.execute = jest.fn()
+      const secondPlayback = await room.play({
+        url: 'url-two',
+      })
+      // @ts-expect-error
+      secondPlayback.execute = jest.fn()
+
+      expect(firstPlayback.id).toEqual('first-playback')
+      expect(firstPlayback.roomSessionId).toEqual('room-session-id')
+      await firstPlayback.stop()
+      // @ts-expect-error
+      expect(firstPlayback.execute).toHaveBeenLastCalledWith({
+        method: 'video.playback.stop',
+        params: {
+          room_session_id: 'room-session-id',
+          playback_id: 'first-playback',
+        },
+      })
+
+      expect(secondPlayback.id).toEqual('second-playback')
+      expect(secondPlayback.roomSessionId).toEqual('room-session-id')
+      await secondPlayback.stop()
+      // @ts-expect-error
+      expect(secondPlayback.execute).toHaveBeenLastCalledWith({
+        method: 'video.playback.stop',
+        params: {
+          room_session_id: 'room-session-id',
+          playback_id: 'second-playback',
+        },
+      })
+    })
+  })
+
   describe('as event emitter', () => {
     it('should listen on the talking events', () => {
       const { store, session, emitter } = configureFullStack()
-      room = createRoomSessionObject({
+      room = createBaseRoomSessionObject({
         store,
         // @ts-expect-error
         emitter,
       })
+      // @ts-expect-error
       room.execute = jest.fn()
       // mock a room.subscribed event
+      // @ts-expect-error
       room.onRoomSubscribed({
         nodeId: 'node-id',
         roomId: '6e83849b-5cc2-4fc6-80ed-448113c8a426',

package/src/{Room.ts → BaseRoomSession.ts}

@@ -6,6 +6,8 @@ import {
   extendComponent,
   BaseComponentOptions,
   BaseConnectionContract,
+  toLocalEvent,
+  toExternalJSON,
 } from '@signalwire/core'
 import {
   getDisplayMedia,
@@ -13,14 +15,15 @@ import {
   BaseConnectionOptions,
   BaseConnectionStateEventTypes,
 } from '@signalwire/webrtc'
-import {
-  RoomObjectEvents,
+import type {
+  RoomSessionObjectEvents,
   CreateScreenShareObjectOptions,
   AddDeviceOptions,
   AddCameraOptions,
   AddMicrophoneOptions,
   BaseRoomInterface,
   RoomMethods,
+  StartScreenShareOptions,
 } from './utils/interfaces'
 import {
   ROOM_COMPONENT_LISTENERS,
@@ -28,25 +31,29 @@ import {
 } from './utils/constants'
 import { audioSetSpeakerAction } from './features/actions'
 import {
-  RoomScreenShareAPI,
-  RoomScreenShareConnection,
-  RoomScreenShare,
-} from './RoomScreenShare'
-import { RoomDeviceAPI, RoomDeviceConnection, RoomDevice } from './RoomDevice'
+  RoomSessionScreenShareAPI,
+  RoomSessionScreenShareConnection,
+  RoomSessionScreenShare,
+} from './RoomSessionScreenShare'
+import {
+  RoomSessionDeviceAPI,
+  RoomSessionDeviceConnection,
+  RoomSessionDevice,
+} from './RoomSessionDevice'
 
-export interface Room
+export interface BaseRoomSession<T>
   extends RoomMethods,
-    BaseConnectionContract<RoomObjectEvents> {
-  join(): Promise<Room>
+    BaseConnectionContract<RoomSessionObjectEvents> {
+  join(): Promise<T>
   leave(): Promise<void>
 }
 
-export class RoomConnection
-  extends BaseConnection<RoomObjectEvents>
+export class RoomSessionConnection
+  extends BaseConnection<RoomSessionObjectEvents>
   implements BaseRoomInterface
 {
-  private _screenShareList = new Set<RoomScreenShare>()
-  private _deviceList = new Set<RoomDevice>()
+  private _screenShareList = new Set<RoomSessionScreenShare>()
+  private _deviceList = new Set<RoomSessionDevice>()
 
   get screenShareList() {
     return Array.from(this._screenShareList)
@@ -61,12 +68,13 @@ export class RoomConnection
     return new Map<string | string[], EventTransform>([
       [
         [
-          'video.__internal__.recording.start',
+          toLocalEvent('video.recording.start'),
           'video.recording.started',
           'video.recording.updated',
           'video.recording.ended',
         ],
         {
+          type: 'roomSessionRecording',
           instanceFactory: (_payload: any) => {
             return Rooms.createRoomSessionRecordingObject({
               store: this.store,
@@ -76,31 +84,61 @@ export class RoomConnection
           },
           payloadTransform: (payload: any) => {
             if (payload?.recording) {
-              return {
-                ...payload?.recording,
-                roomSessionId: this.roomSessionId,
-              }
+              return toExternalJSON({
+                ...payload.recording,
+                room_session_id: this.roomSessionId,
+              })
             }
-            return {
+
+            return toExternalJSON({
               id: payload.recording_id,
-              roomSessionId: this.roomSessionId,
-            }
+              room_session_id: this.roomSessionId,
+            })
+          },
+        },
+      ],
+      [
+        [
+          toLocalEvent('video.playback.start'),
+          'video.playback.started',
+          'video.playback.updated',
+          'video.playback.ended',
+        ],
+        {
+          type: 'roomSessionPlayback',
+          instanceFactory: (_payload: any) => {
+            return Rooms.createRoomSessionPlaybackObject({
+              store: this.store,
+              // @ts-expect-error
+              emitter: this.emitter,
+            })
+          },
+          payloadTransform: (payload: any) => {
+            return toExternalJSON({
+              ...payload.playback,
+              room_session_id: this.roomSessionId,
+            })
           },
         },
       ],
     ])
   }
 
+  /** @deprecated Use {@link startScreenShare} instead. */
+  async createScreenShareObject(opts: CreateScreenShareObjectOptions = {}) {
+    return this.startScreenShare(opts)
+  }
+
   /**
    * Allow sharing the screen within the room.
    */
-  async createScreenShareObject(opts: CreateScreenShareObjectOptions = {}) {
+  async startScreenShare(opts: StartScreenShareOptions = {}) {
     const { autoJoin = true, audio = false, video = true } = opts
     const displayStream: MediaStream = await getDisplayMedia({
       audio: audio === true ? SCREENSHARE_AUDIO_CONSTRAINTS : audio,
       video,
     })
-    const options: BaseConnectionOptions<RoomObjectEvents> = {
+    const options: BaseConnectionOptions<RoomSessionObjectEvents> = {
       ...this.options,
       screenShare: true,
       recoverCall: false,
@@ -115,11 +153,11 @@ export class RoomConnection
 
     const screenShare = connect<
       BaseConnectionStateEventTypes,
-      RoomScreenShareConnection,
-      RoomScreenShare
+      RoomSessionScreenShareConnection,
+      RoomSessionScreenShare
     >({
       store: this.store,
-      Component: RoomScreenShareAPI,
+      Component: RoomSessionScreenShareAPI,
       componentListeners: ROOM_COMPONENT_LISTENERS,
     })(options)
 
@@ -184,7 +222,7 @@ export class RoomConnection
       )
     }
 
-    const options: BaseConnectionOptions<RoomObjectEvents> = {
+    const options: BaseConnectionOptions<RoomSessionObjectEvents> = {
       ...this.options,
       localStream: undefined,
       remoteStream: undefined,
@@ -201,11 +239,11 @@ export class RoomConnection
 
     const roomDevice = connect<
       BaseConnectionStateEventTypes,
-      RoomDeviceConnection,
-      RoomDevice
+      RoomSessionDeviceConnection,
+      RoomSessionDevice
     >({
       store: this.store,
-      Component: RoomDeviceAPI,
+      Component: RoomSessionDeviceAPI,
       componentListeners: ROOM_COMPONENT_LISTENERS,
     })(options)
 
@@ -226,7 +264,7 @@ export class RoomConnection
   }
 
   join() {
-    return super.invite<Room>()
+    return super.invite<BaseRoomSession<this>>()
   }
 
   leave() {
@@ -276,40 +314,48 @@ export class RoomConnection
   }
 }
 
-export const RoomAPI = extendComponent<RoomConnection, RoomMethods>(
-  RoomConnection,
-  {
-    audioMute: Rooms.audioMuteMember,
-    audioUnmute: Rooms.audioUnmuteMember,
-    videoMute: Rooms.videoMuteMember,
-    videoUnmute: Rooms.videoUnmuteMember,
-    deaf: Rooms.deafMember,
-    undeaf: Rooms.undeafMember,
-    setMicrophoneVolume: Rooms.setInputVolumeMember,
-    setSpeakerVolume: Rooms.setOutputVolumeMember,
-    setInputSensitivity: Rooms.setInputSensitivityMember,
-    removeMember: Rooms.removeMember,
-    getMembers: Rooms.getMembers,
-    getLayouts: Rooms.getLayouts,
-    setLayout: Rooms.setLayout,
-    hideVideoMuted: Rooms.hideVideoMuted,
-    showVideoMuted: Rooms.showVideoMuted,
-    getRecordings: Rooms.getRecordings,
-    startRecording: Rooms.startRecording,
-  }
-)
+export const RoomSessionAPI = extendComponent<
+  RoomSessionConnection,
+  RoomMethods
+>(RoomSessionConnection, {
+  audioMute: Rooms.audioMuteMember,
+  audioUnmute: Rooms.audioUnmuteMember,
+  videoMute: Rooms.videoMuteMember,
+  videoUnmute: Rooms.videoUnmuteMember,
+  deaf: Rooms.deafMember,
+  undeaf: Rooms.undeafMember,
+  setInputVolume: Rooms.setInputVolumeMember,
+  setOutputVolume: Rooms.setOutputVolumeMember,
+  setMicrophoneVolume: Rooms.setInputVolumeMember,
+  setSpeakerVolume: Rooms.setOutputVolumeMember,
+  setInputSensitivity: Rooms.setInputSensitivityMember,
+  removeMember: Rooms.removeMember,
+  getMembers: Rooms.getMembers,
+  getLayouts: Rooms.getLayouts,
+  setLayout: Rooms.setLayout,
+  hideVideoMuted: Rooms.hideVideoMuted,
+  showVideoMuted: Rooms.showVideoMuted,
+  getRecordings: Rooms.getRecordings,
+  startRecording: Rooms.startRecording,
+  getPlaybacks: Rooms.getPlaybacks,
+  play: Rooms.play,
+})
 
-type RoomObjectEventsHandlerMapping = RoomObjectEvents &
+type RoomSessionObjectEventsHandlerMapping = RoomSessionObjectEvents &
   BaseConnectionStateEventTypes
 
 /** @internal */
-export const createRoomSessionObject = (
-  params: BaseComponentOptions<RoomObjectEventsHandlerMapping>
-): Room => {
-  const room = connect<RoomObjectEventsHandlerMapping, RoomConnection, Room>({
+export const createBaseRoomSessionObject = <RoomSessionType>(
+  params: BaseComponentOptions<RoomSessionObjectEventsHandlerMapping>
+): BaseRoomSession<RoomSessionType> => {
+  const room = connect<
+    RoomSessionObjectEventsHandlerMapping,
+    RoomSessionConnection,
+    BaseRoomSession<RoomSessionType>
+  >({
     store: params.store,
     customSagas: params.customSagas,
-    Component: RoomAPI,
+    Component: RoomSessionAPI,
     componentListeners: ROOM_COMPONENT_LISTENERS,
   })(params)
 

package/src/Client.ts

@@ -7,48 +7,56 @@ import {
 import type { CustomSaga } from '@signalwire/core'
 import { ConnectionOptions } from '@signalwire/webrtc'
 import { makeMediaElementsSaga } from './features/mediaElements/mediaElementsSagas'
-import { RoomConnection, createRoomSessionObject } from './Room'
+import { RoomSession } from './RoomSession'
+import {
+  createBaseRoomSessionObject,
+  RoomSessionConnection,
+} from './BaseRoomSession'
 
-export interface Client extends ClientContract<Client, ClientEvents> {
-  rooms: ClientAPI['rooms']
+export interface Client<RoomSessionType = RoomSession>
+  extends ClientContract<Client<RoomSessionType>, ClientEvents> {
+  rooms: ClientAPI<RoomSessionType>['rooms']
 }
 
 export interface MakeRoomOptions extends ConnectionOptions {
-  rootElementId?: string
+  rootElement?: HTMLElement
   applyLocalVideoOverlay?: boolean
   stopCameraWhileMuted?: boolean
   stopMicrophoneWhileMuted?: boolean
 }
 
-export class ClientAPI extends BaseClient<ClientEvents> {
+export class ClientAPI<
+  RoomSessionType = RoomSession
+> extends BaseClient<ClientEvents> {
   get rooms() {
     return {
       makeRoomObject: (makeRoomOptions: MakeRoomOptions) => {
         const {
-          rootElementId,
+          rootElement,
           applyLocalVideoOverlay = true,
           stopCameraWhileMuted = true,
           stopMicrophoneWhileMuted = true,
           ...options
         } = makeRoomOptions
 
-        const customSagas: Array<CustomSaga<RoomConnection>> = []
+        const customSagas: Array<CustomSaga<RoomSessionConnection>> = []
 
         /**
-         * If the user provides a `roomElementId` we'll automatically
-         * handle the Audio and Video elements for them
+         * If the user provides a `roomElement` we'll
+         * automatically handle the Audio and Video elements
+         * for them
          */
-        if (rootElementId) {
+        if (rootElement) {
           customSagas.push(
             makeMediaElementsSaga({
-              rootElementId,
+              rootElement,
               applyLocalVideoOverlay,
               speakerId: options.speakerId,
             })
           )
         }
 
-        const room = createRoomSessionObject({
+        const room = createBaseRoomSessionObject<RoomSessionType>({
           ...options,
           store: this.store,
           // @ts-expect-error

package/src/RoomSession.test.ts

@@ -0,0 +1,28 @@
+import { RoomSession, UNSAFE_PROP_ACCESS } from './RoomSession'
+
+describe('RoomSession Object', () => {
+  it('should control which properties the user can access before connecting the room.', async () => {
+    const roomSession = new RoomSession({
+      token: '<some-token>',
+    })
+
+    expect(() => roomSession.active).not.toThrow()
+    expect(() => roomSession.memberId).not.toThrow()
+    expect(() => roomSession.join()).not.toThrow()
+    UNSAFE_PROP_ACCESS.map((prop) => {
+      // @ts-expect-error
+      expect(() => roomSession[prop]).toThrow()
+    })
+
+    // @ts-expect-error
+    roomSession.state = 'active'
+
+    expect(() => roomSession.active).not.toThrow()
+    expect(() => roomSession.memberId).not.toThrow()
+    expect(() => roomSession.join()).not.toThrow()
+    UNSAFE_PROP_ACCESS.map((prop) => {
+      // @ts-expect-error
+      expect(() => roomSession[prop]).not.toThrow()
+    })
+  })
+})