@wazo/sdk 0.40.9 → 0.41.1

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,8 +79,6 @@ describe('Retrieving headers', () => {
 });
 describe('Calling fetch', () => {
   it('should call fetch without body but query string in get method', async () => {
-    jest.mock('node-fetch/src/index', () => {});
-
     global.fetch = jest.fn(() => Promise.resolve({
       json: () => Promise.resolve({}),
       headers: {
@@ -108,7 +106,6 @@ describe('Calling fetch', () => {
 
 describe('With a refresh token', () => {
   it('should retry the call with a new token', async () => {
-    jest.mock('node-fetch/src/index', () => {});
     let calls = 0;
 
     global.fetch = jest.fn(() => {

package/src/utils/api-requester.ts

@@ -1,12 +1,7 @@
-/* global window */
-/* eslint-disable global-require */
-/* eslint-disable import/no-dynamic-require */
 import { Base64 } from 'js-base64';
-import { AbortController as NodeAbortController } from 'node-abort-controller';
 
 import BadResponse from '../domain/BadResponse';
 import ServerError from '../domain/ServerError';
-import isMobile from './isMobile';
 import type { Token } from '../domain/types';
 import IssueReporter from '../service/IssueReporter';
 
@@ -23,32 +18,6 @@ const methods = ['head', 'get', 'post', 'put', 'delete', 'options'];
 const logger = IssueReporter ? IssueReporter.loggerFor('api') : console;
 const REQUEST_TIMEOUT_MS = 300 * 1000; // 300s like the Chrome engine default value.
 
-// Use a function here to be able to mock it in tests
-export const realFetch = () => {
-  if (typeof fetch !== 'undefined') {
-    return fetch;
-  }
-
-  if (typeof document !== 'undefined' && window.fetch) {
-    // Browser
-    return window.fetch;
-  }
-
-  if (isMobile()) {
-    // React native
-    return fetch;
-  }
-
-  // nodejs
-  // this package is disabled for react-native in package.json because it requires nodejs modules
-  // Used to trick the optimizer to avoid requiring `node-fetch/lib/index` directly
-  // It causes to require it on browsers when delivered by a nodejs engine (cf: vitejs).
-  try {
-    return require(Math.random() >= 0 ? 'node-fetch/lib/index' : '');
-  } catch (e: any) {
-    return fetch;
-  }
-};
 export default class ApiRequester {
   server: string;
 
@@ -169,7 +138,7 @@ export default class ApiRequester {
     const hasEmptyResponse = method === 'delete' || isHead;
     const newParse = hasEmptyResponse && parse === ApiRequester.defaultParser ? ApiRequester.successResponseParser : parse;
     const fetchOptions = { ...(this.fetchOptions || {}) };
-    const controller = typeof AbortController !== 'undefined' ? new AbortController() : new NodeAbortController();
+    const controller = new AbortController();
     const extraHeaders = fetchOptions.headers || {};
     delete fetchOptions.headers;
     const options = {
@@ -192,7 +161,7 @@ export default class ApiRequester {
     }
 
     const start = new Date();
-    const requestPromise = realFetch()(url, options).then((response: any) => {
+    const requestPromise = fetch(url, options).then((response: any) => {
       const contentType = response.headers.get('content-type') || '';
       const isJson = contentType.indexOf('application/json') !== -1;
       IssueReporter.logRequest(url, options, response, start);

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;