@wazo/sdk 0.41.0 → 0.41.2

package/src/domain/types.ts

@@ -3,6 +3,13 @@ import { SessionDescriptionHandlerFactoryOptions } from 'sip.js/lib/platform/web
 import type { IncomingResponse as SipIncomingResponse } from 'sip.js/lib/core/messages/incoming-response';
 import { Transport } from 'sip.js/lib/api';
 import WazoSessionDescriptionHandler from '../lib/WazoSessionDescriptionHandler';
+import { Websocket } from '../simple/Websocket';
+import * as WebSocketClient from '../websocket-client';
+
+const {
+  SOCKET_EVENTS,
+  ...OTHER_EVENTS
+} = WebSocketClient;
 
 type GenericObject = Record<string, any>;
 
@@ -312,3 +319,5 @@ export type SearchableQueryParams = QueryParams & {
 export type UuidSearchableQueryParams = SearchableQueryParams & {
   uuid?: string;
 };
+
+export type WebsocketType = Websocket & typeof SOCKET_EVENTS & typeof OTHER_EVENTS;

package/src/index.ts

@@ -48,6 +48,7 @@ export { default as WebRTCClient } from './web-rtc-client';
 export { default as WazoApiClient } from './api-client';
 export { default as Agent, AgentResponse, AgentArguments } from './domain/Agent';
 export { default as ExternalApp } from './domain/ExternalApp';
+export { default as SessionDescriptionHandler } from './lib/WazoSessionDescriptionHandler';
 export * from './types/WebSocketMessage';
 export * from './utils/PhoneNumberUtil';
 export * from './domain/types';

package/src/service/__tests__/IssueReporter.test.ts

@@ -24,7 +24,11 @@ describe('IssueReporter', () => {
   });
   beforeEach(() => {
     jest.resetAllMocks();
-    jest.spyOn(global, 'fetch');
+    Object.defineProperty(global, 'fetch', {
+      value: jest.fn(() => ({
+        catch: () => {},
+      })),
+    });
   });
   afterAll(() => {
     console.log = oldLog;

package/src/simple/Auth.ts

@@ -24,9 +24,10 @@ export class InvalidSubscription extends Error {}
 export class InvalidAuthorization extends Error {}
 export class NoTenantIdError extends Error {}
 export class NoDomainNameError extends Error {}
+
 const logger = IssueReporter.loggerFor('simple-auth');
 
-class Auth {
+export class Auth {
   clientId: string;
 
   expiration: number;
@@ -39,11 +40,11 @@ class Auth {
 
   session: Session | null;
 
-  onRefreshTokenCallback: ((...args: Array<any>) => any) | null;
+  onRefreshTokenCallback?: (token: string, session: Session) => void;
 
-  onRefreshTokenCallbackError: ((...args: Array<any>) => any) | null;
+  onRefreshTokenCallbackError?: (error: any) => void;
 
-  onHostFromHeadersCallback: ((...args: Array<any>) => any) | null;
+  onHostFromHeadersCallback?: (stackHostFromHeaders: string) => void;
 
   authenticated: boolean;
 
@@ -55,6 +56,8 @@ class Auth {
 
   usingEdgeServer: boolean | undefined;
 
+  onSetUsingEdgeServer?: (usingEdgeServer: boolean) => void;
+
   constructor() {
     this.expiration = DETAULT_EXPIRATION;
     this.authenticated = false;
@@ -162,11 +165,16 @@ class Auth {
     return this._onAuthenticated(rawSession as Session);
   }
 
-  async validateToken(token: string, refreshToken: string): Promise<Session | undefined | null> {
+  async validateToken(token: string, refreshToken?: string, headerUserUuid?: string): Promise<Session | undefined | null> {
     if (!token) {
       return;
     }
 
+    if (this.usingEdgeServer && typeof headerUserUuid === 'string') {
+      logger.info('using edge server, setting user UUID header', { headerUserUuid });
+      this.setHttpUserUuidHeader(headerUserUuid);
+    }
+
     if (refreshToken) {
       setRefreshToken(refreshToken);
     }
@@ -212,10 +220,15 @@ class Auth {
     setFetchOptions({});
   }
 
-  setOnHostFromHeaders(callback: (...args: Array<any>) => any) {
+  setOnHostFromHeaders(callback: (hostFromHeaders: string) => void) {
     this.onHostFromHeadersCallback = callback;
   }
 
+  setOnSetUsingEdgeServer(callback: (usingEdgeServer: boolean) => void) {
+    logger.info('setting onSetUsingEdgeServer callback', { callback: typeof callback === 'function' });
+    this.onSetUsingEdgeServer = callback;
+  }
+
   setOnRefreshToken(callback: (...args: Array<any>) => any) {
     this.onRefreshTokenCallback = callback;
   }
@@ -366,6 +379,11 @@ class Auth {
       this.usingEdgeServer = false;
       logger.info('Setting usingEdgeServer to FALSE', { justification: e });
     }
+
+    if (typeof this.onSetUsingEdgeServer === 'function') {
+      logger.info('calling onSetUsingEdgeServer', { usingEdgeServer: this.usingEdgeServer });
+      this.onSetUsingEdgeServer(this.usingEdgeServer);
+    }
   }
 
   async _onAuthenticated(rawSession: Session): Promise<Session | null> {
@@ -437,4 +455,5 @@ if (!global.wazoAuthInstance) {
   global.wazoAuthInstance = new Auth();
 }
 
+// @ts-ignore: Circular definition of import alias 'default'.
 export default global.wazoAuthInstance;

package/src/simple/Configuration.ts

@@ -1,11 +1,11 @@
-import Auth from './Auth';
+import Wazo from '.';
 import getApiClient from '../service/getApiClient';
 import Profile from '../domain/Profile';
 
-class Configuration {
+export class Configuration {
   async getCurrentUser(): Promise<Profile> {
-    const session = Auth.getSession();
-    return getApiClient().confd.getUser(session ? session.uuid : '');
+    const session = Wazo.Auth.getSession();
+    return getApiClient().confd.getUser(`${session ? session.uuid : ''}`);
   }
 
 }
@@ -14,4 +14,5 @@ if (!global.wazoConfigurationInstance) {
   global.wazoConfigurationInstance = new Configuration();
 }
 
+// @ts-ignore: Circular definition of import alias 'default'.
 export default global.wazoConfigurationInstance;

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/utils/__tests__/api-requester.test.ts

@@ -79,12 +79,14 @@ describe('Retrieving headers', () => {
 });
 describe('Calling fetch', () => {
   it('should call fetch without body but query string in get method', async () => {
-    global.fetch = jest.fn(() => Promise.resolve({
-      json: () => Promise.resolve({}),
-      headers: {
-        get: () => '',
-      },
-    })) as any;
+    Object.defineProperty(global, 'fetch', {
+      value: jest.fn(() => Promise.resolve({
+        json: () => Promise.resolve({}),
+        headers: {
+          get: () => '',
+        },
+      }) as any),
+    });
 
     await new ApiRequester({
       server,
@@ -107,17 +109,19 @@ describe('Calling fetch', () => {
 describe('With a refresh token', () => {
   it('should retry the call with a new token', async () => {
     let calls = 0;
+    Object.defineProperty(global, 'fetch', {
+      value: jest.fn(() => {
+        calls++;
+        return Promise.resolve({
+          headers: {
+            get: () => 'application/json',
+          },
+          status: calls === 1 ? 401 : 200,
+          json: () => Promise.resolve({}),
+        } as any);
+      }),
+    });
 
-    global.fetch = jest.fn(() => {
-      calls++;
-      return Promise.resolve({
-        headers: {
-          get: () => 'application/json',
-        },
-        status: calls === 1 ? 401 : 200,
-        json: () => Promise.resolve({}),
-      });
-    }) as any;
     const requester = new ApiRequester({
       server,
       agent: null,

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;
@@ -277,7 +277,7 @@ class WebSocketClient extends Emitter {
       return;
     }
 
-    this.socket.close();
+    this.socket.close(1000);
     this.initialized = false;
 
     if (force) {