@wazo/sdk 0.38.22 → 0.39.0-beta.10

package/src/checker/checks/{wazo-websocket.js → wazo-websocket.ts}

@@ -2,10 +2,14 @@ import WebSocketClient, { SOCKET_EVENTS, HEARTBEAT_ENGINE_VERSION } from '../../
 
 export default {
   name: 'Wazo Websocket',
-  check: (server, session) => new Promise((resolve, reject) => {
-    const client = new WebSocketClient({ host: server, token: session.token, version: 2 });
+  check: (server: string, session: any) => new Promise<void>((resolve, reject) => {
+    const client = new WebSocketClient({
+      host: server,
+      token: session.token,
+      version: 2,
+    });
 
-    const handleError = (message) => {
+    const handleError = (message: any) => {
       client.close();
       reject(new Error(message));
     };
@@ -19,7 +23,6 @@ export default {
     client.on(SOCKET_EVENTS.ON_ERROR, error => {
       handleError(`Connection error : ${error}`);
     });
-
     client.on(SOCKET_EVENTS.ON_OPEN, () => {
       if (session.hasEngineVersionGte(HEARTBEAT_ENGINE_VERSION)) {
         client.setOnHeartbeatTimeout(() => {
@@ -33,7 +36,6 @@ export default {
         handleSuccess();
       }
     });
-
     client.connect();
   }),
 };

package/src/checker/checks/{webrtc-transport.js → webrtc-transport.ts}

@@ -1,8 +1,9 @@
+import { Invitation, Inviter } from 'sip.js';
 import WebRTCClient from '../../web-rtc-client';
 
 export default {
   name: 'WebRTC Transport (WS) ~30s',
-  check: (server, session) => new Promise((resolve, reject) => {
+  check: (server: string, session: Inviter | Invitation): Promise<void> => new Promise((resolve, reject) => {
     const client = new WebRTCClient({
       host: server,
       media: {
@@ -10,7 +11,7 @@ export default {
       },
     }, session);
 
-    const handleError = (message) => {
+    const handleError = (message: any) => {
       client.close();
       reject(new Error(message));
     };

package/src/checker/checks/{webrtc.js → webrtc.ts}

@@ -3,7 +3,7 @@ import WebRTCClient from '../../web-rtc-client';
 
 export default {
   name: 'WebRTC',
-  check: (server, session) => new Promise((resolve, reject) => {
+  check: (server: string, session: any) => new Promise<void | string>((resolve, reject) => {
     if (typeof MediaStream === 'undefined') {
       return resolve('Skipped on node');
     }
@@ -15,7 +15,7 @@ export default {
       },
     }, session);
 
-    const handleError = (message) => {
+    const handleError = (message: any) => {
       client.close();
       reject(new Error(message));
     };
@@ -29,16 +29,15 @@ export default {
     client.on(client.TRANSPORT_ERROR, error => {
       handleError(`Transport error : ${error}`);
     });
-
     client.on(client.REGISTERED, () => {
       const sipSession = client.call('*10');
+
       if (!sipSession || !client.getSipSessionId(sipSession)) {
         return handleError('Unable to make call through WebRTC');
       }
 
       setTimeout(() => {
         client.hangup(sipSession);
-
         handleSuccess();
       }, 1000);
     });

package/src/domain/{AdHocAPIConference.js → AdHocAPIConference.ts}

@@ -1,45 +1,40 @@
-// @flow
-
 import CallSession from './CallSession';
 import type WebRTCPhone from './Phone/WebRTCPhone';
 import getApiClient from '../service/getApiClient';
 
 export type ConferenceParticipant = {
-  admin: boolean,
-  call_id: string,
-  caller_id_name: string,
-  caller_id_number: string,
-  id: string,
-  join_time: number,
-  language: string,
-  muted: boolean,
-  user_uuid: string,
+  admin: boolean;
+  call_id: string;
+  caller_id_name: string;
+  caller_id_number: string;
+  id: string;
+  join_time: number;
+  language: string;
+  muted: boolean;
+  user_uuid: string;
 };
-
 export type ConferenceParticipants = {
-  items: Array<ConferenceParticipant>,
-  total: number,
+  items: Array<ConferenceParticipant>;
+  total: number;
 };
-
 export type ConferenceArguments = {
-  phone: WebRTCPhone,
-  host: CallSession,
-  finished?: boolean,
-  participants: {[string]: CallSession};
-  started?: boolean,
-  answerTime?: ?number,
-  conferenceId?: ?string,
-  muted?: boolean,
-  paused?: boolean,
-};
+  phone: WebRTCPhone;
+  host: CallSession;
+  finished?: boolean;
+  participants: Record<string, CallSession>;
+  started?: boolean;
+  answerTime?: number | null | undefined;
+  conferenceId?: string | null | undefined;
+  muted?: boolean;
+  paused?: boolean;
+}; // API adhoc conference
 
-// API adhoc conference
 export default class AdHocAPIConference {
   phone: WebRTCPhone;
 
   host: CallSession;
 
-  participants: {[string]: CallSession};
+  participants: Record<string, CallSession>;
 
   started: boolean;
 
@@ -47,7 +42,7 @@ export default class AdHocAPIConference {
 
   conferenceId: string;
 
-  answerTime: ?number;
+  answerTime: number | null | undefined;
 
   muted: boolean;
 
@@ -81,14 +76,11 @@ export default class AdHocAPIConference {
 
   async start() {
     this.started = true;
-    // $FlowFixMe
+    // @ts-ignore
     this.answerTime = Object.values(this.participants).length ? Object.values(this.participants)[0].answerTime : null;
-
     const participantIds = Object.keys(this.participants);
     const conference = await getApiClient().calld.createAdHocConference(this.host.callId, participantIds);
-
     this.conferenceId = conference.conference_id;
-
     return this;
   }
 
@@ -98,20 +90,20 @@ export default class AdHocAPIConference {
 
   async addParticipant(newParticipant: CallSession): Promise<AdHocAPIConference> {
     const participantCallId = newParticipant.getTalkingToIds()[0];
-    const participants = { ...this.participants, [participantCallId]: newParticipant };
-
+    const participants = { ...this.participants,
+      [participantCallId]: newParticipant,
+    };
     await getApiClient().calld.addAdHocConferenceParticipant(this.conferenceId, participantCallId);
-
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
       participants,
     });
   }
 
   participantHasLeft(leaver: CallSession): AdHocAPIConference {
     delete this.participants[leaver.getId()];
-
-    return new AdHocAPIConference({ ...this, participants: this.participants });
+    return new AdHocAPIConference({ ...this,
+      participants: this.participants,
+    });
   }
 
   hasParticipants() {
@@ -121,32 +113,28 @@ export default class AdHocAPIConference {
   mute(): AdHocAPIConference {
     this.muted = true;
     this.phone.mute(this.host);
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
     });
   }
 
   unmute(): AdHocAPIConference {
     this.muted = false;
     this.phone.unmute(this.host);
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
     });
   }
 
   hold(): AdHocAPIConference {
     this.paused = true;
     this.phone.hold(this.host);
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
     });
   }
 
   resume(): AdHocAPIConference {
     this.paused = false;
     this.phone.resume(this.host);
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
     });
   }
 
@@ -160,9 +148,7 @@ export default class AdHocAPIConference {
 
   async hangup(): Promise<AdHocAPIConference> {
     await getApiClient().calld.deleteAdHocConference(this.conferenceId);
-
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
       finished: true,
       participant: [],
     });
@@ -171,12 +157,10 @@ export default class AdHocAPIConference {
   async removeParticipant(participantToRemove: CallSession) {
     const callId = participantToRemove.getTalkingToIds()[0];
     delete this.participants[callId];
-
     await getApiClient().calld.removeAdHocConferenceParticipant(this.conferenceId, callId);
-
-    return new AdHocAPIConference({
-      ...this,
+    return new AdHocAPIConference({ ...this,
       participants: this.participants,
     });
   }
+
 }

package/src/domain/{Agent.js → Agent.ts}

@@ -1,6 +1,4 @@
-// @flow
-
-type AgentResponse = {
+export type AgentResponse = {
   context: string;
   extension: string;
   id: number;
@@ -8,7 +6,7 @@ type AgentResponse = {
   number: string;
   paused: boolean;
   paused_reason: string;
-}
+};
 
 type AgentArguments = {
   context: string;
@@ -18,16 +16,21 @@ type AgentArguments = {
   number: string;
   paused: boolean;
   pausedReason: string;
-}
+};
 
 class Agent {
-
   context: string;
+
   extension: string;
+
   id: number;
+
   logged: boolean;
+
   number: string;
+
   paused: boolean;
+
   pausedReason: string;
 
   static parse(plain: AgentResponse): Agent {
@@ -50,7 +53,7 @@ class Agent {
     number,
     paused,
     pausedReason,
-  }: $Shape<AgentArguments>) {
+  }: AgentArguments) {
     this.context = context;
     this.extension = extension;
     this.id = id;
@@ -59,6 +62,7 @@ class Agent {
     this.paused = paused;
     this.pausedReason = pausedReason;
   }
+
 }
 
 export default Agent;

package/src/domain/BadResponse.ts

@@ -0,0 +1,29 @@
+export default class BadResponse extends Error {
+  static fromResponse(error: Record<string, any>, status: number) {
+    return new BadResponse(error.message || JSON.stringify(error), status, error.timestamp, error.error_id, error.details, error);
+  }
+
+  static fromText(response: string, status: number) {
+    return new BadResponse(response, status);
+  }
+
+  status: number;
+
+  timestamp: number | null | undefined;
+
+  errorId: string | null | undefined;
+
+  details: Record<string, any> | null | undefined;
+
+  error: Record<string, any> | Error | null | undefined;
+
+  constructor(message: string, status: number, timestamp: number | null | undefined = null, errorId: string | null | undefined = null, details: Record<string, any> | null | undefined = null, error: Record<string, any> | Error | null | undefined = null) {
+    super(message);
+    this.timestamp = timestamp;
+    this.status = status;
+    this.errorId = errorId;
+    this.details = details;
+    this.error = error;
+  }
+
+}

package/src/domain/{Call.js → Call.ts}

@@ -1,72 +1,83 @@
-// @flow
-
 import moment from 'moment';
 import newFrom from '../utils/new-from';
 
 const RECORD_STATE_ACTIVE = 'active';
-
-type CallResponse = {
-  call_id: string,
-  sip_call_id: string,
-  caller_id_name: string,
-  caller_id_number: string,
-  peer_caller_id_name: string,
-  peer_caller_id_number: string,
-  dialed_extension: string,
-  status: string,
-  is_caller: boolean,
-  is_video?: boolean,
-  line_id: ?number,
-  creation_time: string,
-  on_hold: boolean,
-  muted: boolean,
-  talking_to: Object,
-  record_state: boolean,
+export type CallResponse = {
+  call_id: string;
+  sip_call_id: string;
+  caller_id_name: string;
+  caller_id_number: string;
+  peer_caller_id_name: string;
+  peer_caller_id_number: string;
+  dialed_extension: string;
+  status: string;
+  is_caller: boolean;
+  is_video?: boolean;
+  line_id: number | null | undefined;
+  creation_time: string;
+  on_hold: boolean;
+  muted: boolean;
+  talking_to: Record<string, any>;
+  record_state: string;
 };
-
 type CallArguments = {
-  id: string,
-  sipCallId: string,
-  isCaller: boolean,
-  isVideo?: boolean,
-  callerName: string,
-  callerNumber: string,
-  calleeName: string,
-  calleeNumber: string,
-  dialedExtension: string,
-  lineId: ?number;
-  onHold: boolean,
-  muted: boolean,
-  status: string,
-  startingTime: Date,
-  talkingToIds: string[],
-  recording: boolean,
+  id: string;
+  sipCallId: string;
+  isCaller: boolean;
+  isVideo?: boolean;
+  callerName: string;
+  callerNumber: string;
+  calleeName: string;
+  calleeNumber: string;
+  dialedExtension: string;
+  lineId: number | null | undefined;
+  onHold: boolean;
+  muted: boolean;
+  status: string;
+  startingTime: Date;
+  talkingToIds: string[];
+  recording: boolean;
 };
-
 export default class Call {
   type: string;
 
   id: string;
+
   sipCallId: string;
+
   callerName: string;
+
   callerNumber: string;
+
   calleeName: string;
+
   calleeNumber: string;
+
   dialedExtension: string;
-  lineId: ?number;
+
+  lineId: number | null | undefined;
+
   isCaller: boolean;
+
   isVideo: boolean;
+
   onHold: boolean;
+
   muted: boolean;
+
   status: string;
+
   startingTime: Date;
+
   talkingToIds: string[];
+
   recording: boolean;
 
   static parseMany(plain: Array<CallResponse>): Array<Call> {
     if (!plain) {
       return [];
     }
+
     return plain.map((plainCall: CallResponse) => Call.parse(plainCall));
   }
 
@@ -112,7 +123,7 @@ export default class Call {
     startingTime,
     talkingToIds,
     recording,
-  }: CallArguments = {}) {
+  }: CallArguments) {
     this.id = id;
     this.sipCallId = sipCallId;
     this.callerName = callerName;
@@ -129,25 +140,29 @@ export default class Call {
     this.talkingToIds = talkingToIds || [];
     this.recording = recording;
     this.isVideo = !!isVideo;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'Call';
   }
 
   getElapsedTimeInSeconds(): number {
     const now = Date.now();
-    return (now - this.startingTime) / 1000;
+    return (now - +this.startingTime) / 1000;
   }
 
-  separateCalleeName(): { firstName: string, lastName: string } {
+  separateCalleeName(): {
+    firstName: string;
+    lastName: string;
+  } {
     const names = this.calleeName.split(' ');
     const firstName = names[0];
     const lastName = names.slice(1).join(' ');
-
-    return { firstName, lastName };
+    return {
+      firstName,
+      lastName,
+    };
   }
 
-  is(other: ?Call): boolean {
+  is(other: Call | null | undefined): boolean {
     return !!other && this.id === other.id;
   }
 
@@ -198,4 +213,5 @@ export default class Call {
   isRecording(): boolean {
     return this.recording;
   }
+
 }