@wazo/sdk 0.38.21 → 0.39.0-beta.1

package/src/simple/Websocket.ts

@@ -0,0 +1,119 @@
+import type Session from '../domain/Session';
+import WazoWebSocketClient, * as WebSocketClient from '../websocket-client';
+import Emitter, { IEmitter } from '../utils/Emitter';
+import IssueReporter from '../service/IssueReporter';
+
+const {
+  SOCKET_EVENTS,
+  ...OTHER_EVENTS
+} = WebSocketClient;
+const ALL_EVENTS = [...Object.values(SOCKET_EVENTS), ...Object.values(OTHER_EVENTS)];
+const logger = IssueReporter.loggerFor('simple-ws-client');
+
+export interface IWebsocket extends IEmitter {
+  ws: WazoWebSocketClient | null | undefined;
+  eventLists: string[];
+
+  CONFERENCE_USER_PARTICIPANT_JOINED: string;
+  CONFERENCE_USER_PARTICIPANT_LEFT: string;
+  MEETING_USER_PARTICIPANT_JOINED: string;
+  MEETING_USER_PARTICIPANT_LEFT: string;
+  CALL_CREATED: string;
+
+  open: (host: string, session: Session) => void;
+  updateToken: (token: string) => void;
+  isOpen: () => boolean;
+  close: (force?: boolean) => void;
+}
+
+class Websocket extends Emitter implements IWebsocket {
+  ws: WazoWebSocketClient | null | undefined;
+
+  eventLists: string[];
+
+  CONFERENCE_USER_PARTICIPANT_JOINED: string;
+
+  CONFERENCE_USER_PARTICIPANT_LEFT: string;
+
+  MEETING_USER_PARTICIPANT_JOINED: string;
+
+  MEETING_USER_PARTICIPANT_LEFT: string;
+
+  CALL_CREATED: string;
+
+  constructor() {
+    super();
+    // Sugar syntax for `Wazo.WebSocket.EVENT_NAME`
+    Object.keys(OTHER_EVENTS).forEach(key => {
+      // @ts-ignore
+      this[key] = OTHER_EVENTS[key];
+    });
+    Object.keys(SOCKET_EVENTS).forEach(key => {
+      // @ts-ignore
+      this[key] = SOCKET_EVENTS[key];
+    });
+    this.eventLists = WazoWebSocketClient.eventLists;
+    this.ws = null;
+  }
+
+  open(host: string, session: Session) {
+    logger.info('open simple WebSocket', {
+      host,
+      token: session.token,
+    });
+    this.ws = new WazoWebSocketClient({
+      host,
+      token: session.token,
+      events: ['*'],
+      version: 2,
+    }, {
+      rejectUnauthorized: false,
+      binaryType: 'arraybuffer',
+    });
+    this.ws.connect();
+    // Re-emit all events
+    ALL_EVENTS.forEach((event: any) => {
+      if (!this.ws) {
+        return;
+      }
+
+      this.ws.on(event, (payload: Record<string, any>) => {
+        this.eventEmitter.emit(event, payload);
+      });
+    });
+  }
+
+  updateToken(token: string) {
+    logger.info('update token via simple Websocket', {
+      token,
+      ws: !!this.ws,
+    });
+
+    if (!this.ws) {
+      return;
+    }
+
+    this.ws.updateToken(token);
+  }
+
+  isOpen(): boolean {
+    return this.ws?.isConnected() || false;
+  }
+
+  close(force = false) {
+    logger.info('Closing Wazo websocket', { force, ws: !!this.ws });
+
+    if (this.ws) {
+      this.ws.close(force);
+    }
+
+    this.unbind();
+  }
+
+}
+
+if (!global.wazoWebsocketInstance) {
+  global.wazoWebsocketInstance = new Websocket();
+}
+
+export default global.wazoWebsocketInstance;

package/src/simple/{index.js → index.ts}

@@ -1,7 +1,7 @@
 /* global window */
-import Auth, { InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError } from './Auth';
-import Phone from './Phone';
-import Websocket from './Websocket';
+import Auth, { IAuth, InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError } from './Auth';
+import Phone, { IPhone } from './Phone';
+import Websocket, { IWebsocket } from './Websocket';
 import Room from './room/Room';
 import SipRoom from './room/SipRoom';
 import RemoteParticipant from './room/RemoteParticipant';
@@ -12,7 +12,6 @@ import Configuration from './Configuration';
 import getApiClient from '../service/getApiClient';
 import { createLocalVideoStream, createLocalAudioStream } from './utils';
 import { CanceledCallError } from '../web-rtc-client';
-
 import BadResponse from '../domain/BadResponse';
 import ServerError from '../domain/ServerError';
 import SFUNotAvailableError from '../domain/SFUNotAvailableError';
@@ -39,12 +38,11 @@ import IssueReporter from '../service/IssueReporter';
 import Features from '../domain/Features';
 import Meeting from '../domain/Meeting';
 import Checker from '../checker/Checker';
-import Softphone from './Softphone';
 
 const Wazo = {
-  Auth,
-  Phone,
-  Websocket,
+  Auth: Auth as IAuth,
+  Phone: Phone as IPhone,
+  Websocket: Websocket as IWebsocket,
   Room,
   SipRoom,
   RemoteParticipant,
@@ -59,8 +57,6 @@ const Wazo = {
   loggerFor: IssueReporter.loggerFor.bind(IssueReporter),
   Features,
   Checker,
-  Softphone,
-
   // Domain
   domain: {
     BadResponse,
@@ -88,17 +84,49 @@ const Wazo = {
   },
 
   // Api
-  get api() { return getApiClient(); },
-  get agentd() { return getApiClient().agentd; },
-  get amid() { return getApiClient().amid; },
-  get application() { return getApiClient().application; },
-  get auth() { return getApiClient().auth; },
-  get callLogs() { return getApiClient().callLogs; },
-  get calld() { return getApiClient().calld; },
-  get chatd() { return getApiClient().chatd; },
-  get confd() { return getApiClient().confd; },
-  get dird() { return getApiClient().dird; },
-  get webhookd() { return getApiClient().webhookd; },
+  get api() {
+    return getApiClient();
+  },
+
+  get agentd() {
+    return getApiClient().agentd;
+  },
+
+  get amid() {
+    return getApiClient().amid;
+  },
+
+  get application() {
+    return getApiClient().application;
+  },
+
+  get auth() {
+    return getApiClient().auth;
+  },
+
+  get callLogd() {
+    return getApiClient().callLogd;
+  },
+
+  get calld() {
+    return getApiClient().calld;
+  },
+
+  get chatd() {
+    return getApiClient().chatd;
+  },
+
+  get confd() {
+    return getApiClient().confd;
+  },
+
+  get dird() {
+    return getApiClient().dird;
+  },
+
+  get webhookd() {
+    return getApiClient().webhookd;
+  },
 
   // Error
   InvalidSubscription,
@@ -110,8 +138,10 @@ const Wazo = {
 };
 
 if (window) {
+  // @ts-ignore
   window.Wazo = Wazo;
 }
+
 if (global) {
   global.Wazo = Wazo;
 }

package/src/simple/room/{LocalParticipant.js → LocalParticipant.ts}

@@ -1,7 +1,5 @@
-// @flow
 import Participant from './Participant';
 
-class LocalParticipant extends Participant {
-}
+class LocalParticipant extends Participant {}
 
 export default LocalParticipant;

package/src/simple/room/{Participant.js → Participant.ts}

@@ -1,7 +1,5 @@
-// @flow
 import Emitter from '../../utils/Emitter';
 import IssueReporter from '../../service/IssueReporter';
-
 import Phone from '../Phone';
 import Room, { SIGNAL_TYPE_PARTICIPANT_UPDATE } from './Room';
 import Contact from '../../domain/Contact';
@@ -9,37 +7,72 @@ import getApiClient from '../../service/getApiClient';
 
 const logger = IssueReporter.loggerFor('room');
 
+export type RawParticipant = {
+  user_uuid?: string,
+  caller_id_name: string,
+  caller_id_number?: string
+  call_id: string,
+};
+
 class Participant extends Emitter {
-  room: Room;
-  uuid: string;
+  room: Room | null | undefined;
+
+  uuid?: string;
+
   name: string;
-  number: string;
+
+  number?: string;
+
   callId: string;
+
   isTalking: boolean;
+
   streams: any[];
+
   videoStreams: any[];
+
   audioMuted: boolean;
+
   videoMuted: boolean;
+
   screensharing: boolean;
+
   isOnHold: boolean;
+
   banned: boolean;
-  extra: Object;
+
+  extra: Record<string, any>;
 
   ON_UPDATED: string;
+
   ON_START_TALKING: string;
+
   ON_STOP_TALKING: string;
+
   ON_DISCONNECT: string;
+
   ON_STREAM_SUBSCRIBED: string;
+
   ON_STREAM_UNSUBSCRIBED: string;
+
   ON_AUDIO_MUTED: string;
+
   ON_AUDIO_UNMUTED: string;
+
   ON_VIDEO_MUTED: string;
+
   ON_VIDEO_UNMUTED: string;
+
   ON_SCREENSHARING: string;
+
   ON_STOP_SCREENSHARING: string;
+
   ON_EXTRA_CHANGE: string;
+
   ON_HOLD: string;
+
   ON_RESUME: string;
+
   ON_BAN: string;
 
   /**
@@ -47,11 +80,9 @@ class Participant extends Emitter {
    * @param rawParticipant string Participant sent via the Wazo WS
    * @param extra Object extra status of the participant
    */
-  constructor(room: Room, rawParticipant: Object = {}, extra: Object = {}) {
+  constructor(room: Room | null, rawParticipant: RawParticipant, extra: Record<string, any> = {}) {
     super();
-
     this.room = room;
-
     this.uuid = rawParticipant.user_uuid;
     this.name = (rawParticipant.caller_id_name || '').replace("\\'", "'");
     this.number = rawParticipant.caller_id_number;
@@ -65,7 +96,6 @@ class Participant extends Emitter {
     this.isOnHold = false;
     this.extra = extra;
     this.banned = false;
-
     this.ON_UPDATED = 'participant/ON_UPDATED';
     this.ON_START_TALKING = 'participant/ON_START_TALKING';
     this.ON_STOP_TALKING = 'participant/ON_STOP_TALKING';
@@ -89,43 +119,59 @@ class Participant extends Emitter {
     this.eventEmitter.emit.apply(this.eventEmitter, [this.ON_UPDATED, ...args]);
   }
 
-  triggerUpdate(eventType: string, broadcast: boolean = true) {
-    const status: Object = { callId: this.callId };
+  triggerUpdate(eventType: string, broadcast = true) {
+    const status: Record<string, any> = {
+      callId: this.callId,
+    };
 
     switch (eventType) {
       case this.ON_START_TALKING:
-      case this.ON_STOP_TALKING: {
+      case this.ON_STOP_TALKING:
+      {
         status.isTalking = this.isTalking;
         break;
       }
+
       case this.ON_AUDIO_MUTED:
-      case this.ON_AUDIO_UNMUTED: {
+      case this.ON_AUDIO_UNMUTED:
+      {
         status.audioMuted = this.audioMuted;
         break;
       }
+
       case this.ON_VIDEO_MUTED:
-      case this.ON_VIDEO_UNMUTED: {
+      case this.ON_VIDEO_UNMUTED:
+      {
         status.videoMuted = this.videoMuted;
         break;
       }
+
       case this.ON_SCREENSHARING:
-      case this.ON_STOP_SCREENSHARING: {
+      case this.ON_STOP_SCREENSHARING:
+      {
         status.screensharing = this.screensharing;
         break;
       }
+
       case this.ON_HOLD:
-      case this.ON_RESUME: {
+      case this.ON_RESUME:
+      {
         status.isOnHold = this.isOnHold;
         break;
       }
-      case this.ON_EXTRA_CHANGE: {
+
+      case this.ON_EXTRA_CHANGE:
+      {
         status.extra = this.extra;
         break;
       }
-      case this.ON_BAN: {
+
+      case this.ON_BAN:
+      {
         status.banned = true;
         break;
       }
+
       default:
         break;
     }
@@ -139,7 +185,11 @@ class Participant extends Emitter {
   }
 
   onTalking(isTalking: boolean) {
-    logger.info('on participant talking', { name: this.name, isTalking, callId: this.callId });
+    logger.info('on participant talking', {
+      name: this.name,
+      isTalking,
+      callId: this.callId,
+    });
     this.isTalking = isTalking;
     // you may notice we're not broadcasting: since all participants are getting this info
     // directly from asterisk, there's no need to do so
@@ -158,79 +208,79 @@ class Participant extends Emitter {
     return this.triggerEvent(this.ON_STREAM_UNSUBSCRIBED, stream);
   }
 
-  onAudioMuted(broadcast: boolean = true) {
+  onAudioMuted(broadcast = true) {
     if (this.audioMuted) {
       return;
     }
-    this.audioMuted = true;
 
+    this.audioMuted = true;
     this.triggerUpdate(this.ON_AUDIO_MUTED, broadcast);
   }
 
-  onAudioUnMuted(broadcast: boolean = true) {
+  onAudioUnMuted(broadcast = true) {
     if (!this.audioMuted) {
       return;
     }
-    this.audioMuted = false;
 
+    this.audioMuted = false;
     this.triggerUpdate(this.ON_AUDIO_UNMUTED, broadcast);
   }
 
-  onVideoMuted(broadcast: boolean = true) {
+  onVideoMuted(broadcast = true) {
     if (this.videoMuted) {
       return;
     }
-    this.videoMuted = true;
 
+    this.videoMuted = true;
     this.triggerUpdate(this.ON_VIDEO_MUTED, broadcast);
   }
 
-  onVideoUnMuted(broadcast: boolean = true) {
+  onVideoUnMuted(broadcast = true) {
     if (!this.videoMuted) {
       return;
     }
-    this.videoMuted = false;
 
+    this.videoMuted = false;
     this.triggerUpdate(this.ON_VIDEO_UNMUTED, broadcast);
   }
 
-  onScreensharing(broadcast: boolean = true) {
+  onScreensharing(broadcast = true) {
     if (this.screensharing) {
       return;
     }
-    this.screensharing = true;
 
+    this.screensharing = true;
     this.triggerUpdate(this.ON_SCREENSHARING, broadcast);
   }
 
-  onStopScreensharing(broadcast: boolean = true) {
+  onStopScreensharing(broadcast = true) {
     if (!this.screensharing) {
       return;
     }
-    this.screensharing = false;
 
+    this.screensharing = false;
     this.triggerUpdate(this.ON_STOP_SCREENSHARING, broadcast);
   }
 
-  onHold(broadcast: boolean = true) {
+  onHold(broadcast = true) {
     if (this.isOnHold) {
       return;
     }
-    this.isOnHold = true;
 
+    this.isOnHold = true;
     this.triggerUpdate(this.ON_HOLD, broadcast);
   }
 
-  onResume(broadcast: boolean = true) {
+  onResume(broadcast = true) {
     if (!this.isOnHold) {
       return;
     }
-    this.isOnHold = false;
 
+    this.isOnHold = false;
     this.triggerUpdate(this.ON_RESUME, broadcast);
   }
 
-  onBan(broadcast: boolean = true) {
+  onBan(broadcast = true) {
     this.banned = true;
     this.triggerUpdate(this.ON_BAN, broadcast);
   }
@@ -246,8 +296,11 @@ class Participant extends Emitter {
     };
   }
 
-  updateStatus(status: Object, broadcast: boolean = true) {
-    logger.info('updating participant status', { name: this.name, status });
+  updateStatus(status: Record<string, any>, broadcast = true) {
+    logger.info('updating participant status', {
+      name: this.name,
+      status,
+    });
 
     if (typeof status.audioMuted !== 'undefined' && status.audioMuted !== this.audioMuted) {
       if (status.audioMuted) {
@@ -287,7 +340,9 @@ class Participant extends Emitter {
 
     // Poor man's object comparison
     if (typeof status.extra !== 'undefined' && JSON.stringify(this.extra) !== JSON.stringify(status.extra)) {
-      this.extra = { ...this.extra, ...status.extra };
+      this.extra = { ...this.extra,
+        ...status.extra,
+      };
 
       if (this.extra.contact && !(this.extra.contact instanceof Contact)) {
         this.extra.contact = new Contact(this.extra.contact);
@@ -297,16 +352,19 @@ class Participant extends Emitter {
     }
   }
 
-  broadcastStatus(inboundStatus: Object = null, sendReinvite: ?boolean) {
+  broadcastStatus(inboundStatus: Record<string, any> | null = null, sendReinvite: boolean | null | undefined = null) {
     const status = inboundStatus || this.getStatus();
-    logger.info('broadcasting participant status', { callId: this.callId, status });
+    logger.info('broadcasting participant status', {
+      callId: this.callId,
+      status,
+    });
 
     if (sendReinvite && !this.streams.length && Phone.phone) {
       // eslint-disable-next-line no-underscore-dangle
-      Phone.phone._sendReinviteMessage(this.room.callSession, false);
+      Phone.phone._sendReinviteMessage(this.room?.callSession, false);
     }
 
-    this.room.sendSignal({
+    this.room?.sendSignal({
       type: SIGNAL_TYPE_PARTICIPANT_UPDATE,
       origin: this.callId,
       status,
@@ -318,8 +376,11 @@ class Participant extends Emitter {
     this.videoStreams = streams;
   }
 
-  async ban(apiRequestDelay: ?number = null) {
-    const { meetingUuid } = this.room;
+  async ban(apiRequestDelay: number | null | undefined = null) {
+    const {
+      meetingUuid,
+    } = this.room || {};
+
     if (!meetingUuid) {
       throw new Error('Attempting to ban a participant without a `meetingUuid`');
     }
@@ -339,6 +400,7 @@ class Participant extends Emitter {
   async delay(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms));
   }
+
 }
 
 export default Participant;

package/src/simple/room/{RemoteParticipant.js → RemoteParticipant.ts}

@@ -1,14 +1,15 @@
-// @flow
 import Room from './Room';
-import Participant from './Participant';
+import Participant, { RawParticipant } from './Participant';
 
 class RemoteParticipant extends Participant {
-  constructor(room: Room, rawParticipant: Object = {}, extra: Object = {}) {
+  constructor(room: Room, rawParticipant: RawParticipant, extra: Record<string, any> = {}) {
     super(room, rawParticipant, extra);
+
     if (this.name === '<unknown>') {
-      this.name = this.number;
+      this.name = String(this.number);
     }
   }
+
 }
 
 export default RemoteParticipant;