@wazo/sdk 0.41.0 → 0.41.1

package/src/simple/Directory.ts

@@ -1,7 +1,7 @@
 import type Contact from '../domain/Contact';
 import getApiClient from '../service/getApiClient';
 
-class Directory {
+export class Directory {
   async findMultipleContactsByNumber(numbers: string[], fields?: Record<string, any>): Promise<Contact[]> {
     return getApiClient().dird.findMultipleContactsByNumber(numbers, fields);
   }
@@ -12,4 +12,5 @@ if (!global.wazoDirectoryInstance) {
   global.wazoDirectoryInstance = new Directory();
 }
 
+// @ts-ignore: Circular definition of import alias 'default'.
 export default global.wazoDirectoryInstance;

package/src/simple/Phone.ts

@@ -18,7 +18,7 @@ const sipLogger = IssueReporter.loggerFor('sip.js');
 const protocolLogger = IssueReporter.loggerFor('sip');
 const protocolDebugMessages = ['Received WebSocket text message:', 'Sending WebSocket message:'];
 
-class Phone extends Emitter {
+export class Phone extends Emitter {
   client: WazoWebRTCClient;
 
   phone: WebRTCPhone | null | undefined;
@@ -527,4 +527,5 @@ if (!global.wazoTelephonyInstance) {
   global.wazoTelephonyInstance = new Phone();
 }
 
+// @ts-ignore: Circular definition of import alias 'default'.
 export default global.wazoTelephonyInstance;

package/src/simple/Websocket.ts

@@ -3,6 +3,7 @@ import WazoWebSocketClient, * as WebSocketClient from '../websocket-client';
 import Emitter from '../utils/Emitter';
 import IssueReporter from '../service/IssueReporter';
 import { obfuscateToken } from '../utils/string';
+import { WebsocketType } from '../domain/types';
 
 const {
   SOCKET_EVENTS,
@@ -11,7 +12,7 @@ const {
 const ALL_EVENTS = [...Object.values(SOCKET_EVENTS), ...Object.values(OTHER_EVENTS)];
 const logger = IssueReporter.loggerFor('simple-ws-client');
 
-class Websocket extends Emitter {
+export class Websocket extends Emitter {
   ws: WazoWebSocketClient | null | undefined;
 
   eventLists: string[];
@@ -99,7 +100,8 @@ class Websocket extends Emitter {
 }
 
 if (!global.wazoWebsocketInstance) {
-  global.wazoWebsocketInstance = new Websocket();
+  global.wazoWebsocketInstance = new Websocket() as WebsocketType;
 }
 
+// @ts-ignore: Circular definition of import alias 'default'.
 export default global.wazoWebsocketInstance;

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

@@ -0,0 +1,123 @@
+import getApiClient, { setRefreshToken } from '../../service/getApiClient';
+import { Auth as AuthClass } from '../Auth';
+
+const Auth = new AuthClass();
+const TOKEN = 'some-token';
+const REFRESH_TOKEN = 'some-refresh-token';
+const USER_UUID = 'some-user-uuid';
+
+jest.mock('../../service/getApiClient');
+
+describe('simple/Auth', () => {
+  beforeEach(() => {
+    const authenticate = jest.fn();
+    (getApiClient as any).mockImplementation(() => ({
+      auth: {
+        authenticate,
+      },
+    }));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('validateToken', () => {
+    it('should return undefined if nullish', async () => {
+      // @ts-expect-error
+      const result = await Auth.validateToken(null);
+      expect(result).toEqual(undefined);
+    });
+
+    it('should set refresh token if provided', async () => {
+      await Auth.validateToken(TOKEN, REFRESH_TOKEN);
+      expect(setRefreshToken).toHaveBeenCalledWith(REFRESH_TOKEN);
+    });
+
+    it('should set user uuid header when using edge server', async () => {
+      Auth.usingEdgeServer = true;
+      const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
+      await Auth.validateToken(TOKEN, undefined, USER_UUID);
+      expect(setHttpUserUuidHeader).toHaveBeenCalledWith(USER_UUID);
+    });
+
+    it('should NOT set user uuid header when NOT using edge server', async () => {
+      Auth.usingEdgeServer = false;
+      const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
+      await Auth.validateToken(TOKEN, undefined, USER_UUID);
+      expect(setHttpUserUuidHeader).not.toHaveBeenCalled();
+    });
+  });
+  describe('checkHttpUserUuidHeader', () => {
+    it('should return undefined if UUID is null', async () => {
+      const result = await Auth.checkHttpUserUuidHeader(null);
+      expect(result).toEqual(undefined);
+    });
+
+    it('should set user UUID header on successful HEAD call', async () => {
+      const head = jest.fn(() => Promise.resolve({ headers: { get: () => null } }));
+      const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
+      Auth.onSetUsingEdgeServer = jest.fn();
+      (getApiClient as any).mockImplementation(() => ({
+        client: {
+          head,
+        },
+      }));
+      await Auth.checkHttpUserUuidHeader(USER_UUID);
+      expect(head).toHaveBeenCalled();
+      expect(setHttpUserUuidHeader).toHaveBeenCalledWith(USER_UUID);
+      expect(Auth.usingEdgeServer).toEqual(true);
+      expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(true);
+    });
+
+    it('should NOT set user UUID header on failed HEAD call', async () => {
+      const head = jest.fn(() => Promise.reject());
+      const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
+      Auth.onSetUsingEdgeServer = jest.fn();
+      (getApiClient as any).mockImplementation(() => ({
+        client: {
+          head,
+        },
+      }));
+      await Auth.checkHttpUserUuidHeader(USER_UUID);
+      expect(head).toHaveBeenCalled();
+      expect(setHttpUserUuidHeader).not.toHaveBeenCalled();
+      expect(Auth.usingEdgeServer).toEqual(false);
+      expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(false);
+    });
+
+    it('should set user UUID header on mobile when header is present', async () => {
+      Auth.mobile = true;
+      const head = jest.fn(() => Promise.resolve({ headers: { get: () => 'X-User-UUID: something' } }));
+      const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
+      Auth.onSetUsingEdgeServer = jest.fn();
+      (getApiClient as any).mockImplementation(() => ({
+        client: {
+          head,
+        },
+      }));
+      await Auth.checkHttpUserUuidHeader(USER_UUID);
+      expect(head).toHaveBeenCalled();
+      expect(setHttpUserUuidHeader).toHaveBeenCalledWith(USER_UUID);
+      expect(Auth.usingEdgeServer).toEqual(true);
+      expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(true);
+    });
+
+    it('should NOT set user UUID header on mobile when header is NOT present', async () => {
+      Auth.mobile = true;
+      const head = jest.fn(() => Promise.resolve({ headers: { get: () => 'something' } }));
+      const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
+      Auth.onSetUsingEdgeServer = jest.fn();
+      (getApiClient as any).mockImplementation(() => ({
+        client: {
+          head,
+        },
+      }));
+      await Auth.checkHttpUserUuidHeader(USER_UUID);
+      expect(head).toHaveBeenCalled();
+      expect(setHttpUserUuidHeader).not.toHaveBeenCalled();
+      expect(Auth.usingEdgeServer).toEqual(false);
+      expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(false);
+    });
+  });
+});

package/src/simple/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-named-as-default */
 /* global window */
 import Auth, { InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError } from './Auth';
 import Phone from './Phone';

package/src/simple/room/Participant.ts

@@ -1,10 +1,12 @@
 import Emitter from '../../utils/Emitter';
 import IssueReporter from '../../service/IssueReporter';
+// eslint-disable-next-line import/no-named-as-default
 import Phone from '../Phone';
 import Room, { SIGNAL_TYPE_PARTICIPANT_UPDATE } from './Room';
 import Contact from '../../domain/Contact';
 import getApiClient from '../../service/getApiClient';
 import Stream from './Stream';
+import type CallSession from '../../domain/CallSession';
 
 const logger = IssueReporter.loggerFor('room');
 
@@ -362,7 +364,7 @@ class Participant extends Emitter {
 
     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 as CallSession, false);
     }
 
     this.room?.sendSignal({

package/src/simple/room/Room.ts

@@ -25,7 +25,7 @@ type ConnectArgs = {
 };
 
 class Room extends Emitter {
-  callSession: CallSession | null | undefined;
+  callSession?: CallSession;
 
   name: string;
 
@@ -189,6 +189,7 @@ class Room extends Emitter {
 
     if (!room) {
       await Wazo.Phone.connect({
+        // @ts-ignore: Property 'audio' is missing
         media: constraints,
       });
       const withCamera = constraints && !!constraints.video;
@@ -260,7 +261,7 @@ class Room extends Emitter {
   async disconnect() {
     logger.info('disconnection to room called');
     await Wazo.Phone.hangup(this.callSession as CallSession);
-    this.callSession = null;
+    this.callSession = undefined;
     this.eventEmitter.emit(this.ON_DISCONNECTED, this);
     this.connected = false;
     this.unbind();
@@ -497,7 +498,7 @@ class Room extends Emitter {
 
       if (!this.roomAudioElement) {
         const sessionId = Wazo.Phone.phone?.getSipSessionId(Wazo.Phone.phone?.currentSipSession as WazoSession);
-        this.roomAudioElement = Wazo.Phone.phone?.createAudioElementFor(sessionId as string);
+        this.roomAudioElement = Wazo.Phone.phone?.createAudioElementFor(sessionId as string) as HTMLAudioElement;
         this.roomAudioElement.srcObject = stream;
       } else {
         this.roomAudioElement.srcObject = stream;

package/src/types/global.d.ts

@@ -1,6 +1,12 @@
 /* eslint-disable vars-on-top */
 /* eslint-disable no-var */
 
+import { WebsocketType } from '../domain/types';
+import { Auth } from '../simple/Auth';
+import { Configuration } from '../simple/Configuration';
+import { Directory } from '../simple/Directory';
+import { Phone } from '../simple/Phone';
+
 declare global {
   var Wazo;
   var wazoClients;
@@ -17,11 +23,11 @@ declare global {
   var wazoRequestApiTimeout;
   var wazoFetchOptions;
   var wazoCurrentServer;
-  var wazoAuthInstance;
-  var wazoConfigurationInstance;
-  var wazoDirectoryInstance;
-  var wazoTelephonyInstance;
-  var wazoWebsocketInstance;
+  var wazoAuthInstance: Auth;
+  var wazoConfigurationInstance: Configuration;
+  var wazoDirectoryInstance: Directory;
+  var wazoTelephonyInstance: Phone;
+  var wazoWebsocketInstance: WebsocketType;
 }
 
 export {};

package/src/web-rtc-client.ts

@@ -550,13 +550,14 @@ export default class WebRTCClient extends Emitter {
     });
   }
 
-  call(number: string, enableVideo?: boolean, audioOnly = false, conference = false): WazoSession | null {
+  call(number: string, enableVideo?: boolean, audioOnly = false, conference = false, options = {}): WazoSession | null {
     logger.info('sdk webrtc creating call', {
       clientId: this.clientId,
       number,
       enableVideo,
       audioOnly,
       conference,
+      options,
     });
     const inviterOptions: Record<string, any> = {
       sessionDescriptionHandlerOptionsReInvite: {
@@ -564,6 +565,7 @@ export default class WebRTCClient extends Emitter {
         audioOnly,
       },
       earlyMedia: true,
+      options,
     };
 
     if (audioOnly) {

package/src/websocket-client.ts

@@ -15,7 +15,7 @@ export const SOCKET_EVENTS = {
   ON_CLOSE: 'onclose',
   INITIALIZED: 'initialized',
   ON_AUTH_FAILED: 'on_auth_failed',
-};
+} as const;
 type Arguments = {
   host: string;
   token: string;