@wazo/sdk 0.43.6 → 1.0.0-alpha.0

package/src/simple/Phone.ts

@@ -12,6 +12,7 @@ import Emitter from '../utils/Emitter';
 import Wazo from './index';
 import SFUNotAvailableError from '../domain/SFUNotAvailableError';
 import { WazoSession, WebRtcConfig } from '../domain/types';
+import { getSipSessionId } from '../utils/sdp';
 
 const logger = IssueReporter.loggerFor('simple-phone');
 const sipLogger = IssueReporter.loggerFor('sip.js');
@@ -332,7 +333,7 @@ export class Phone extends Emitter {
     if (!sipSession || !this.phone) {
       return null;
     }
-    return this.phone.getSipSessionId(sipSession);
+    return getSipSessionId(sipSession);
   }
 
   sendMessage(body: string, sipSession?: WazoSession, contentType = 'text/plain'): void {

package/src/simple/__tests__/Auth.test.ts

@@ -1,5 +1,3 @@
-import BadResponse from '../../domain/BadResponse';
-import ServerError from '../../domain/ServerError';
 import getApiClient, { setRefreshToken } from '../../service/getApiClient';
 import { Auth as AuthClass } from '../Auth';
 
@@ -126,8 +124,13 @@ describe('simple/Auth', () => {
   describe('initiateIdpAuthentication', () => {
     const validResponse = { location: 'idp.com/auth', saml_session_id: 'a1b2C3d4' };
 
-    it('should return a `location` and `saml_session_id` if the response is valid', async () => {
-      const initiateIdpAuthentication = jest.fn(() => validResponse);
+    it('should return a `location` and `saml_session_id` if the response is ok', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: true,
+          status: 303,
+          json: () => Promise.resolve(validResponse),
+        }));
 
       (getApiClient as any).mockImplementation(() => ({
         auth: {
@@ -138,9 +141,12 @@ describe('simple/Auth', () => {
       const response = await Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz');
       expect(response).toBe(validResponse);
     });
-
     it('should return a `NoSamlRouteError` if the response is a 404', async () => {
-      const initiateIdpAuthentication = jest.fn(() => { throw BadResponse.fromText('an error message', 404); });
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: false,
+          status: 404,
+        }));
 
       (getApiClient as any).mockImplementation(() => ({
         auth: {
@@ -149,12 +155,84 @@ describe('simple/Auth', () => {
       }));
 
       await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow(
-        'No route found for SAML SSO',
+        'No route found for saml sso',
       );
     });
 
-    it('should return a `SamlConfigError` if the response is a 500', async () => {
-      const initiateIdpAuthentication = jest.fn(() => { throw ServerError.fromText('an error message', 500); });
+    it('should return an error `message` if the response is NOT ok', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: false,
+          json: () => Promise.resolve({ message: 'an error message', reason: 'an error reason' }),
+        }));
+
+      (getApiClient as any).mockImplementation(() => ({
+        auth: {
+          initiateIdpAuthentication,
+        },
+      }));
+
+      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow(
+        'an error message',
+      );
+    });
+
+    it('should return an error `reason` if there is no `message` and the response is NOT ok', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: false,
+          json: () => Promise.resolve({ reason: 'an error reason' }),
+        }));
+
+      (getApiClient as any).mockImplementation(() => ({
+        auth: {
+          initiateIdpAuthentication,
+        },
+      }));
+
+      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow(
+        'an error reason',
+      );
+    });
+
+    it('should return an error with a null message if there is no `message` and `reason`', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: false,
+          json: () => Promise.resolve({}),
+        }));
+
+      (getApiClient as any).mockImplementation(() => ({
+        auth: {
+          initiateIdpAuthentication,
+        },
+      }));
+
+      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('');
+    });
+
+    it('should return a NoSAMLRouteError if the response is a 404', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: false,
+          status: 404,
+        }));
+
+      (getApiClient as any).mockImplementation(() => ({
+        auth: {
+          initiateIdpAuthentication,
+        },
+      }));
+
+      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('No route found for saml sso');
+    });
+
+    it('should return a SamlConfigError if the response is a 500', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: false,
+          status: 500,
+        }));
 
       (getApiClient as any).mockImplementation(() => ({
         auth: {

package/src/simple/index.ts

@@ -17,7 +17,7 @@ import { CanceledCallError } from '../web-rtc-client';
 import BadResponse from '../domain/BadResponse';
 import ServerError from '../domain/ServerError';
 import SFUNotAvailableError from '../domain/SFUNotAvailableError';
-import Call from '../domain/Call';
+import ApiCall from '../domain/Call';
 import CallLog from '../domain/CallLog';
 import Recording from '../domain/Recording';
 import ChatMessage from '../domain/ChatMessage';
@@ -41,6 +41,9 @@ import Features from '../domain/Features';
 import Meeting from '../domain/Meeting';
 import Checker from '../checker/Checker';
 
+import Softphone from '../voice/softphone';
+import Call from '../voice/call';
+
 const Wazo = {
   Auth,
   Phone,
@@ -60,11 +63,15 @@ const Wazo = {
   loggerFor: IssueReporter.loggerFor.bind(IssueReporter),
   Features,
   Checker,
+  Voice: {
+    Softphone,
+    Call,
+  },
   // Domain
   domain: {
     BadResponse,
     ServerError,
-    Call,
+    Call: ApiCall,
     CallLog,
     CTIPhone,
     Recording,

package/src/simple/room/Room.ts

@@ -10,6 +10,7 @@ import RemoteParticipant from './RemoteParticipant';
 import IssueReporter from '../../service/IssueReporter';
 import LocalParticipant from './LocalParticipant';
 import { PeerConnection, WazoSession } from '../../domain/types';
+import { getSipSessionId } from '../../utils/sdp';
 
 export const SIGNAL_TYPE_PARTICIPANT_UPDATE = 'signal/PARTICIPANT_UPDATE';
 export const SIGNAL_TYPE_PARTICIPANT_REQUEST = 'signal/PARTICIPANT_REQUEST';
@@ -497,7 +498,7 @@ class Room extends Emitter {
       this.audioStream = stream;
 
       if (!this.roomAudioElement) {
-        const sessionId = Wazo.Phone.phone?.getSipSessionId(Wazo.Phone.phone?.currentSipSession as WazoSession);
+        const sessionId = getSipSessionId(Wazo.Phone.phone?.currentSipSession as WazoSession);
         this.roomAudioElement = await Wazo.Phone.phone?.createAudioElementFor(sessionId as string) as HTMLAudioElement;
         this.roomAudioElement.srcObject = stream;
       } else {

package/src/simple/room/SipRoom.ts

@@ -4,6 +4,7 @@ import IssueReporter from '../../service/IssueReporter';
 import Wazo from '../index';
 import Room from './Room';
 import { WazoSession } from '../../domain/types';
+import { getSipSessionId } from '../../utils/sdp';
 
 const logger = IssueReporter.loggerFor('sdk-sip-room');
 
@@ -156,7 +157,7 @@ class SipRoom extends Room {
   }
 
   _getCurrentSipCallIs() {
-    return Wazo.Phone.getSipSessionId(Wazo.Phone.phone?.currentSipSession as WazoSession);
+    return getSipSessionId(Wazo.Phone.phone?.currentSipSession as WazoSession);
   }
 
 }

package/src/state-machine/call-state-machine.ts

@@ -0,0 +1,131 @@
+import { setup, type ActorRefFrom } from 'xstate';
+
+import softphone from '../voice/softphone';
+import { States as SoftphoneStates } from './softphone-state-machine';
+
+export const States = {
+  IDLE: 'idle',
+  RINGING: 'ringing',
+  IN_PROGRESS: 'progress',
+  ESTABLISHED: 'established',
+  TERMINATED: 'terminated',
+} as const;
+
+export const EstablishedStates = {
+  ONGOING: 'ongoing',
+  HELD: 'held',
+  MUTED: 'muted',
+} as const;
+
+export type StateTypes = typeof States[keyof typeof States];
+
+export type EstablishedStateTypes = typeof EstablishedStates[keyof typeof EstablishedStates];
+
+export const Actions = {
+  INCOMING_CALL: 'incomingCall',
+  MAKE_CALL: 'makeCall',
+  ACCEPT: 'accept',
+  REMOTLY_ACCEPTED: 'remotlyAccepted',
+  REJECT: 'reject',
+  HANGUP: 'hangup',
+} as const;
+
+export const EstablishedActions = {
+  HOLD: 'hold',
+  RESUME: 'resume',
+  MUTE: 'mute',
+  UN_MUTE: 'unMute',
+} as const;
+
+export type ActionTypes = typeof Actions[keyof typeof Actions];
+
+export type EstablishedActionTypes = typeof EstablishedActions[keyof typeof EstablishedActions];
+
+const callMachine = setup({
+  guards: {
+    isRegistered: () => softphone.getState() === SoftphoneStates.REGISTERED,
+  },
+}).createMachine({
+  id: 'call',
+  initial: States.IDLE,
+  context: {},
+  states: {
+    [States.IDLE]: {
+      on: {
+        [Actions.INCOMING_CALL]: {
+          // guard: 'isRegistered',
+          target: States.RINGING,
+        },
+        [Actions.MAKE_CALL]: {
+          guard: 'isRegistered',
+          target: States.IN_PROGRESS,
+        },
+      },
+    },
+    [States.IN_PROGRESS]: {
+      on: {
+        [Actions.HANGUP]: {
+          guard: 'isRegistered',
+          target: States.TERMINATED,
+        },
+        [Actions.REMOTLY_ACCEPTED]: {
+          guard: 'isRegistered',
+          target: States.ESTABLISHED,
+        },
+      },
+    },
+    [States.RINGING]: {
+      on: {
+        [Actions.ACCEPT]: {
+          guard: 'isRegistered',
+          target: States.ESTABLISHED,
+        },
+        [Actions.REJECT]: {
+          guard: 'isRegistered',
+          target: States.TERMINATED,
+        },
+      },
+    },
+    [States.ESTABLISHED]: {
+      initial: EstablishedStates.ONGOING,
+      on: {
+        [Actions.HANGUP]: {
+          guard: 'isRegistered',
+          target: States.TERMINATED,
+        },
+        [EstablishedActions.HOLD]: {
+          guard: 'isRegistered',
+          target: `.${EstablishedStates.HELD}`,
+        },
+        [EstablishedActions.MUTE]: {
+          guard: 'isRegistered',
+          target: `.${EstablishedStates.MUTED}`,
+        },
+      },
+      states: {
+        [EstablishedStates.ONGOING]: { },
+        [EstablishedStates.HELD]: {
+          on: {
+            [EstablishedActions.RESUME]: {
+              guard: 'isRegistered',
+              target: EstablishedStates.ONGOING,
+            },
+          },
+        },
+        [EstablishedStates.MUTED]: {
+          on: {
+            [EstablishedActions.UN_MUTE]: {
+              guard: 'isRegistered',
+              target: EstablishedStates.ONGOING,
+            },
+          },
+        },
+      },
+    },
+    [States.TERMINATED]: { },
+  },
+});
+
+export type CallActorRef = ActorRefFrom<typeof callMachine>;
+
+export default callMachine;

package/src/state-machine/softphone-state-machine.ts

@@ -0,0 +1,49 @@
+import { type ActorRefFrom, setup } from 'xstate';
+
+export const States = {
+  UNREGISTERED: 'unregistered',
+  REGISTERING: 'registering',
+  REGISTERED: 'registered',
+} as const;
+
+export type StateTypes = typeof States[keyof typeof States];
+
+export const Actions = {
+  REGISTER: 'register',
+  REGISTER_DONE: 'registerDone',
+  UNREGISTER: 'unregister',
+  UNREGISTERED: 'unregistered',
+  TRANSPORT_CLOSED: 'transportClosed',
+} as const;
+
+export type ActionTypes = typeof Actions[keyof typeof Actions];
+
+const softphoneMachine = setup({}).createMachine({
+  id: 'softphone',
+  initial: States.UNREGISTERED,
+  context: {},
+  states: {
+    [States.UNREGISTERED]: {
+      on: {
+        [Actions.REGISTER]: States.REGISTERING,
+      },
+    },
+    [States.REGISTERING]: {
+      on: {
+        [Actions.REGISTER_DONE]: States.REGISTERED,
+        [Actions.TRANSPORT_CLOSED]: States.UNREGISTERED,
+        [Actions.UNREGISTERED]: States.UNREGISTERED,
+      },
+    },
+    [States.REGISTERED]: {
+      on: {
+        [Actions.UNREGISTER]: States.UNREGISTERED,
+        [Actions.TRANSPORT_CLOSED]: States.UNREGISTERED,
+      },
+    },
+  },
+});
+
+export type SoftphoneActorRef = ActorRefFrom<typeof softphoneMachine>;
+
+export default softphoneMachine;

package/src/state-machine/utils.ts

@@ -0,0 +1,53 @@
+import { type SnapshotFrom } from 'xstate';
+import { type SoftphoneActorRef, type ActionTypes as SoftphoneActions, type StateTypes as SoftphoneStates } from './softphone-state-machine';
+import { type CallActorRef, type ActionTypes as CallActions, type EstablishedActionTypes as EstablishedCallActions, type StateTypes as CallStates, type EstablishedStateTypes } from './call-state-machine';
+
+import InvalidStateTransition from '../domain/InvalidStateTransition';
+import InvalidState from '../domain/InvalidState';
+import IssueReporter from '../service/IssueReporter';
+
+const logger = IssueReporter.loggerFor('state-machine');
+
+export const getState = (actor: SoftphoneActorRef | CallActorRef): SoftphoneStates | CallStates | EstablishedStateTypes => {
+  return actor.getSnapshot().value as SoftphoneStates | CallStates | EstablishedStateTypes;
+};
+
+export const can = (actor: SoftphoneActorRef | CallActorRef, action: SoftphoneActions | CallActions | EstablishedCallActions): boolean => {
+  return actor.getSnapshot().can({ type: action });
+};
+
+export const hasState = (actor: SoftphoneActorRef | CallActorRef, state: SoftphoneStates | CallStates): boolean => {
+  return getState(actor) === state;
+};
+
+export const waitUntilState = (actor: SoftphoneActorRef | CallActorRef, state: SoftphoneStates | CallStates, timeout = 5000): Promise<unknown> => {
+  return Promise.race([
+    new Promise(resolve => {
+      (actor as SoftphoneActorRef).subscribe((snapshot: SnapshotFrom<SoftphoneActorRef | CallActorRef>) => {
+        if (snapshot.value === state) {
+          resolve(null);
+        }
+      });
+    }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`Waited for state ${state} timeout.`)), timeout)),
+  ]);
+};
+
+export const assertCan = (actor: SoftphoneActorRef | CallActorRef, action: SoftphoneActions | CallActions | EstablishedCallActions): void => {
+  if (!can(actor, action)) {
+    const currentState = actor.getSnapshot().value;
+    const message = `Invalid state transition from ${currentState} with action ${action}`;
+    logger.warn(message);
+
+    throw new InvalidStateTransition(message, action, currentState as string);
+  }
+};
+
+export const assertState = (actor: SoftphoneActorRef | CallActorRef, state: SoftphoneStates | CallStates): void => {
+  if (!hasState(actor, state)) {
+    const message = `Invalid state ${state}`;
+    logger.warn(message);
+
+    throw new InvalidState(message, state);
+  }
+};

package/src/utils/__tests__/api-requester.test.ts

@@ -158,23 +158,3 @@ describe('With a refresh token', () => {
     });
   });
 });
-
-describe('base64Encode', () => {
-  it('should encode a string using base64', () => {
-    const input = 'Hello World!';
-    const expectedOutput = 'SGVsbG8gV29ybGQh';
-    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
-  });
-
-  it('should handle special characters', () => {
-    const input = 'éà$@€';
-    const expectedOutput = 'w6nDoCRA4oKs';
-    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
-  });
-
-  it('should handle empty string', () => {
-    const input = '';
-    const expectedOutput = '';
-    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
-  });
-});

package/src/utils/api-requester.ts

@@ -64,15 +64,7 @@ export default class ApiRequester {
   }
 
   static base64Encode(str: string): string {
-    if (typeof btoa !== 'undefined') {
-      try {
-        return btoa(str);
-      } catch (error) {
-        // fall back to Base64.encode if btoa fails
-      }
-    }
-
-    return Base64.encode(str);
+    return typeof btoa !== 'undefined' ? btoa(str) : Base64.encode(str);
   }
 
   // @see https://github.com/facebook/flow/issues/183#issuecomment-358607052

package/src/utils/sdp.ts

@@ -1,4 +1,11 @@
 import sdpParser from 'sdp-transform';
+import { UserAgent } from 'sip.js/lib/api/user-agent';
+import { Inviter } from 'sip.js/lib/api';
+import { URI } from 'sip.js/lib/grammar/uri';
+
+import type { SipCall } from '../domain/types';
+
+export const SIP_ID_LENGTH = 36;
 
 export type Candidate = {
   foundation: string;
@@ -138,3 +145,32 @@ export const addIcesInAllBundles = (sdp: string) => {
   }));
   return sdpParser.write(parsedSdp);
 };
+
+export const getSipSessionId = (sipSession: SipCall | null | undefined): string => {
+  if (!sipSession) {
+    return '';
+  }
+
+  const message = sipSession.message as Partial<{ callId?: string }>;
+  if (message?.callId) {
+    return message.callId.substring(0, SIP_ID_LENGTH);
+  }
+
+  // For Inviter
+  // @ts-ignore: private
+  if (sipSession instanceof Inviter && sipSession.outgoingRequestMessage) {
+    // @ts-ignore: private
+    return sipSession.outgoingRequestMessage.callId.substring(0, SIP_ID_LENGTH);
+  }
+
+  // For Invitation
+  return (sipSession.id || '').substring(0, SIP_ID_LENGTH);
+};
+
+// We need to replace 0.0.0.0 to 127.0.0.1 in the sdp to avoid MOH during a createOffer.
+export const replaceLocalIpModifier = (description: Record<string, any>) => Promise.resolve({ // description is immutable... so we have to clone it or the `type` attribute won't be returned.
+  ...JSON.parse(JSON.stringify(description)),
+  sdp: description.sdp.replace('c=IN IP4 0.0.0.0', 'c=IN IP4 127.0.0.1'),
+});
+
+export const makeURI = (target: string, host: string): URI | undefined => UserAgent.makeURI(`sip:${target}@${host}`);

package/src/utils/sip-logger.ts

@@ -0,0 +1,40 @@
+import IssueReporter from '../service/IssueReporter';
+import { WebRtcConfig } from '../domain/types';
+
+const sipLogger = IssueReporter.loggerFor('sip.js');
+const protocolLogger = IssueReporter.loggerFor('sip');
+const protocolDebugMessages = ['Received WebSocket text message:', 'Sending WebSocket message:'];
+
+const logConnector = (level: any, className: string, label: any, content: string): void => {
+  const protocolIndex = content && content.indexOf ? protocolDebugMessages.findIndex(prefix => content.indexOf(prefix) !== -1) : -1;
+
+  if (className === 'sip.Transport' && protocolIndex !== -1) {
+    const direction = protocolIndex === 0 ? 'receiving' : 'sending';
+    const message = content.replace(`${protocolDebugMessages[protocolIndex]}\n\n`, '').replace('\r\n', '\n');
+    protocolLogger.trace(message, {
+      className,
+      direction,
+    });
+  } else {
+    sipLogger.trace(content, {
+      className,
+    });
+  }
+};
+
+const configureLogger = (rawOptions: Partial<WebRtcConfig> = {}): Partial<WebRtcConfig> => {
+  const options = rawOptions;
+
+  if (options.uaConfigOverrides) {
+    options.uaConfigOverrides.traceSip = true;
+  }
+  options.log = options.log || {};
+  options.log.builtinEnabled = false;
+  options.log.logLevel = 'debug';
+
+  options.log.connector = logConnector;
+
+  return options;
+};
+
+export default configureLogger;