@wazo/sdk 0.38.21 → 0.39.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wazo/sdk",
-  "version": "0.38.21",
+  "version": "0.39.0-beta.1",
   "description": "Wazo's JavaScript Software Development Kit.",
   "main": "dist/wazo-sdk.js",
   "author": "Wazo (http://wazo.io)",
@@ -14,10 +14,9 @@
   "homepage": "https://github.com/wazo-platform/wazo-js-sdk",
   "files": [
     "dist/*.js",
-    "src/**/*.js",
-    "esm/**/*.js",
-    "lib/**/*.js",
-    "config.js"
+    "src/**/*",
+    "esm/**/*",
+    "lib/**/*"
   ],
   "repository": {
     "type": "git",
@@ -27,28 +26,35 @@
     "url": "https://github.com/wazo-platform/wazo-js-sdk/issues"
   },
   "scripts": {
-    "build": "./node_modules/.bin/rollup --config --extend",
-    "build:dev": "DEV=1 ./node_modules/.bin/rollup --config --extend",
+    "clean": "./node_modules/.bin/rimraf lib/* esm/* dist/*",
+    "build": "yarn clean && yarn build:esm && yarn build:cjs && yarn build:umd",
+    "build:umd": "./node_modules/.bin/rollup --config --extend --bundleConfigAsCjs",
+    "build:esm": "tsc -p ./tsconfig.esm.json",
+    "build:cjs": "tsc -p ./tsconfig.cjs.json",
     "test": "yarn jest && yarn lint && yarn typecheck && yarn checkbuild",
-    "watch": "./node_modules/.bin/webpack --mode=development --watch",
     "lint": "./node_modules/.bin/eslint src/",
     "jest": "./node_modules/.bin/jest src/",
     "checkbuild": "yarn build && node dist/wazo-sdk.js",
     "format": "./node_modules/.bin/prettier-eslint --write \"src/**/*.js\" \"__tests__/**/*.js\" --single-quote --trailing-comma es5",
-    "typecheck": "./node_modules/.bin/flow",
-    "fetch-typedefs": "./node_modules/.bin/flow-typed install",
-    "prepublishOnly": "./node_modules/.bin/rimraf lib/* esm/* && yarn build"
+    "typecheck": "./node_modules/.bin/tsc --noEmit",
+    "prepublishOnly": "yarn build"
   },
-  "jest": {
-    "transformIgnorePatterns": [
-      "node_modules/?!(sip.js/lib/api/session-state)"
-    ]
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./esm/types/index.d.ts",
+        "default": "./esm/index.mjs"
+      },
+      "require": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/index.js"
+      }
+    }
   },
   "dependencies": {
     "events": "^3.3.0",
     "fstream": "^1.0.12",
     "getstats": "manuquentin/getStats#fix_stats_mobile",
-    "globby": "^11.0.3",
     "google-libphonenumber": "^3.2.18",
     "js-base64": "^3.6.0",
     "json-to-graphql-query": "^2.0.0",
@@ -62,37 +68,37 @@
   },
   "devDependencies": {
     "@babel/core": "^7.13.10",
-    "@babel/plugin-transform-flow-strip-types": "^7.13.0",
     "@babel/preset-env": "^7.13.12",
+    "@babel/preset-typescript": "^7.18.6",
+    "@rollup/plugin-commonjs": "^24.0.0",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-terser": "^0.3.0",
+    "@rollup/plugin-typescript": "^10.0.1",
+    "@types/events": "^3.0.0",
+    "@types/google-libphonenumber": "^7.4.23",
+    "@types/jest": "^26.0.24",
+    "@types/jsrsasign": "^10.5.4",
+    "@types/node": "^18.11.17",
+    "@types/sdp-transform": "^2.4.5",
+    "@typescript-eslint/eslint-plugin": "^5.47.0",
+    "@typescript-eslint/parser": "^5.47.0",
     "babel-core": "^7.0.0-bridge.0",
     "babel-eslint": "10.1.0",
-    "babel-jest": "^26.6.3",
     "babel-loader": "^8.2.2",
-    "babel-preset-flow": "^6.23.0",
     "eslint": "^7.22.0",
     "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-airbnb-typescript": "^17.0.0",
     "eslint-config-prettier": "^8.1.0",
-    "eslint-plugin-flowtype": "^5.4.0",
     "eslint-plugin-import": "^2.22.1",
     "eslint-plugin-prettier": "^3.3.1",
-    "flow-bin": "^0.119.1",
-    "flow-typed": "^3.3.1",
     "jest": "^26.6.3",
     "jsonlint": "^1.6.3",
     "prettier-eslint-cli": "^5.0.1",
-    "remove-flow-types-loader": "^1.1.0",
     "rimraf": "^3.0.2",
-    "rollup": "^2.42.3",
-    "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-commonjs": "^10.1.0",
-    "rollup-plugin-flow": "^1.1.1",
-    "rollup-plugin-json": "^4.0.0",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-visualizer": "^4.2.2",
-    "webpack": "^5.27.2",
-    "webpack-bundle-analyzer": "^4.4.0",
-    "webpack-cli": "^4.5.0"
+    "rollup": "^3.9.1",
+    "ts-jest": "^26.5.4",
+    "typescript": "^4.9.4"
   },
   "engines": {
     "node": ">=0.8"

package/src/__tests__/{api-client.test.js → api-client.test.ts}

@@ -4,13 +4,20 @@ import ServerError from '../domain/ServerError';
 import BadResponse from '../domain/BadResponse';
 import Session from '../domain/Session';
 
-const mockedResponse = { data: { token: 1 } };
+const mockedResponse = {
+  data: {
+    token: 1,
+  },
+};
+
 const mockedNotFoundResponse = {
   message: 'No such user voicemail',
 };
+
 const mockedTextErrorPayload = {
   message: 'No such user voicemail',
 };
+
 const mockedJsonErrorPayload = {
   timestamp: 1537529588.789515,
   message: 'No such user voicemail',
@@ -19,66 +26,89 @@ const mockedJsonErrorPayload = {
     user_uuid: 'xxx-xxx-xxx-xxx-xxxx',
   },
 };
+
 const mockedTextError = {
   ok: false,
   text: () => Promise.resolve(mockedTextErrorPayload),
   status: 500,
-  headers: { get: () => 'text/plain' },
+  headers: {
+    get: () => 'text/plain',
+  },
 };
+
 const mockedJsonError = {
   ok: false,
   json: () => Promise.resolve(mockedJsonErrorPayload),
   status: 500,
-  headers: { get: () => 'application/json' },
+  headers: {
+    get: () => 'application/json',
+  },
 };
+
 const mockedJson = {
   ok: true,
   json: () => Promise.resolve(mockedResponse),
-  headers: { get: () => 'application/json' },
+  headers: {
+    get: () => 'application/json',
+  },
 };
 
 const mockedUnAuthorized = {
   text: () => Promise.resolve(mockedResponse),
   ok: false,
   status: 401,
-  headers: { get: () => 'text/plain' },
+  headers: {
+    get: () => 'text/plain',
+  },
 };
+
 const mockedNotFound = {
   json: () => Promise.resolve(mockedNotFoundResponse),
   ok: false,
   status: 404,
-  headers: { get: () => 'application/json' },
+  headers: {
+    get: () => 'application/json',
+  },
 };
+
 const server = 'localhost';
 const authVersion = '0.1';
 const username = 'wazo';
 const password = 'zowa';
-
 jest.mock('node-fetch/lib/index', () => {});
+const token = '1234';
+
+const client = new WazoApiClient({
+  server,
+});
 
-const token = 1234;
-const client = new WazoApiClient({ server });
 client.setToken(token);
 
 describe('With correct API results', () => {
   beforeEach(() => {
     jest.resetModules();
-
+    // @ts-expect-error
     global.fetch = jest.fn(() => Promise.resolve(mockedJson));
   });
 
   describe('logIn test', () => {
     it('should retrieve user token', async () => {
-      const data = { backend: 'wazo_user', expiration: 3600 };
+      const data = {
+        backend: 'wazo_user',
+        expiration: 3600,
+      };
       const headers = {
         Authorization: `Basic ${Base64.encode(`${username}:${password}`)}`,
         'Content-Type': 'application/json',
       };
-
-      const result = await client.auth.logIn({ username, password });
+      // @ts-expect-error
+      const result = await client.auth.logIn({
+        username,
+        password,
+      });
       expect(result).toBeInstanceOf(Session);
+      // @ts-expect-error
       expect(result.token).toBe(1);
-
       expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
         method: 'post',
         body: JSON.stringify(data),
@@ -91,8 +121,8 @@ describe('With correct API results', () => {
   describe('logOut test', () => {
     it('should delete the specified token', async () => {
       const oldToken = 123;
+      // @ts-expect-error
       await client.auth.logOut(oldToken);
-
       expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${oldToken}`, {
         method: 'delete',
         body: null,
@@ -106,17 +136,15 @@ describe('With correct API results', () => {
 describe('With unAuthorized API results', () => {
   beforeEach(() => {
     jest.resetModules();
-
+    // @ts-expect-error
     global.fetch = jest.fn(() => Promise.resolve(mockedUnAuthorized));
   });
 
   describe('checkLogin test', () => {
     it('should return false on 401 status', async () => {
-      const tokenToCheck = 123;
+      const tokenToCheck = '123';
       const result = await client.auth.checkToken(tokenToCheck);
-
       expect(result).toBeFalsy();
-
       expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${tokenToCheck}`, {
         method: 'head',
         body: null,
@@ -130,16 +158,17 @@ describe('With unAuthorized API results', () => {
 describe('With not found API results', () => {
   beforeEach(() => {
     jest.resetModules();
-
+    // @ts-expect-error
     global.fetch = jest.fn(() => Promise.resolve(mockedNotFound));
   });
 
   describe('fetchVoicemail test', () => {
     it('should throw a BadResponse instance on 404 status', async () => {
       let error = null;
+
       try {
         await client.calld.listVoicemails();
-      } catch (e) {
+      } catch (e: any) {
         error = e;
       }
 
@@ -147,11 +176,14 @@ describe('With not found API results', () => {
       expect(error).toBeInstanceOf(BadResponse);
       expect(error.message).toBe(mockedNotFoundResponse.message);
       expect(error.status).toBe(404);
-
       expect(global.fetch).toBeCalledWith(`https://${server}/api/calld/1.0/users/me/voicemails`, {
         method: 'get',
         body: null,
-        headers: { 'X-Auth-Token': token, 'Content-Type': 'application/json', Accept: 'application/json' },
+        headers: {
+          'X-Auth-Token': token,
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
         agent: null,
       });
     });
@@ -161,15 +193,20 @@ describe('With not found API results', () => {
 describe('With erroneous text API results', () => {
   beforeEach(() => {
     jest.resetModules();
-
+    // @ts-expect-error
     global.fetch = jest.fn(() => Promise.resolve(mockedTextError));
   });
 
   it('throw an exception when the response is >= 500', async () => {
     let error = null;
+
     try {
-      await client.auth.logIn({ username, password });
-    } catch (e) {
+      // @ts-expect-error
+      await client.auth.logIn({
+        username,
+        password,
+      });
+    } catch (e: any) {
       error = e;
     }
 
@@ -183,15 +220,20 @@ describe('With erroneous text API results', () => {
 describe('With erroneous json API results', () => {
   beforeEach(() => {
     jest.resetModules();
-
+    // @ts-expect-error
     global.fetch = jest.fn(() => Promise.resolve(mockedJsonError));
   });
 
   it('throw an exception when the response is >= 500', async () => {
     let error = null;
+
     try {
-      await client.auth.logIn({ username, password });
-    } catch (e) {
+      // @ts-expect-error
+      await client.auth.logIn({
+        username,
+        password,
+      });
+    } catch (e: any) {
       error = e;
     }
 

package/src/__tests__/{web-rtc-client.test.js → web-rtc-client.test.ts}

@@ -1,5 +1,8 @@
 import WebRTCClient from '../web-rtc-client';
 
+jest.mock('sip.js/lib/platform/web/transport');
+
+// @ts-expect-error
 const client = new WebRTCClient({});
 
 describe('WebRTC client', () => {
@@ -7,132 +10,189 @@ describe('WebRTC client', () => {
     const mutedSession = {
       sessionDescriptionHandler: {
         peerConnection: {
-          getSenders: () => [{ track: { kind: 'audio', enabled: false } }],
+          getSenders: () => [{
+            track: {
+              kind: 'audio',
+              enabled: false,
+            },
+          }],
         },
       },
     };
-
     const unMutedSession = {
       sessionDescriptionHandler: {
         peerConnection: {
-          getSenders: () => [{ track: { kind: 'audio', enabled: true } }],
+          getSenders: () => [{
+            track: {
+              kind: 'audio',
+              enabled: true,
+            },
+          }],
         },
       },
     };
-
     const oldKindMuted = {
       sessionDescriptionHandler: {
         peerConnection: {
-          getLocalStreams: () => [{ getAudioTracks: () => [{ enabled: false }] }],
+          getLocalStreams: () => [{
+            getAudioTracks: () => [{
+              enabled: false,
+            }],
+          }],
         },
       },
     };
-
     const oldKindUnmuted = {
       sessionDescriptionHandler: {
         peerConnection: {
-          getLocalStreams: () => [{ getAudioTracks: () => [{ enabled: true }] }],
+          getLocalStreams: () => [{
+            getAudioTracks: () => [{
+              enabled: true,
+            }],
+          }],
         },
       },
     };
-
+    // @ts-expect-error
     expect(client.isAudioMuted(mutedSession)).toBeTruthy();
+    // @ts-expect-error
     expect(client.isAudioMuted(oldKindMuted)).toBeTruthy();
-
+    // @ts-expect-error
     expect(client.isAudioMuted(unMutedSession)).toBeFalsy();
+    // @ts-expect-error
     expect(client.isAudioMuted(oldKindUnmuted)).toBeFalsy();
   });
 });
-
 describe('changeAudioInputDevice', () => {
   const defaultId = 'default';
   const deviceId = 'device1';
-  const constraints = { audio: { deviceId: { exact: defaultId } }, video: null };
-
+  const constraints = {
+    audio: {
+      deviceId: {
+        exact: defaultId,
+      },
+    },
+    video: null,
+  };
   const session = {
     sessionDescriptionHandler: {
       peerConnection: {
-        getSenders: () => [{ track: { kind: 'audio', enabled: true } }],
+        getSenders: () => [{
+          track: {
+            kind: 'audio',
+            enabled: true,
+          },
+        }],
       },
     },
   };
-
   const stream = {};
   const getAudioTracksMock = jest.fn(() => []);
   Object.defineProperty(stream, 'getAudioTracks', {
     value: getAudioTracksMock,
   });
-
   const getUserMediaMock = jest.fn(async () => {
     return new Promise(resolve => {
       resolve(stream);
     });
   });
-
-  const devices = [
-    { deviceId: 'default', kind: 'audioinput', label: 'Default - Fake Microphone', groupId: 'fak3Gr0up3' },
-    { deviceId: 'fak3d3v1c3', kind: 'audioinput', label: 'Fake Microphone', groupId: 'fak3Gr0up3' },
-  ];
+  const devices = [{
+    deviceId: 'default',
+    kind: 'audioinput',
+    label: 'Default - Fake Microphone',
+    groupId: 'fak3Gr0up3',
+  }, {
+    deviceId: 'fak3d3v1c3',
+    kind: 'audioinput',
+    label: 'Fake Microphone',
+    groupId: 'fak3Gr0up3',
+  }];
   const enumerateDevicesMock = jest.fn(async () => {
     return new Promise(resolve => {
       resolve(devices);
     });
   });
-
   Object.defineProperty(global.navigator, 'mediaDevices', {
     value: {
       getUserMedia: getUserMediaMock,
       enumerateDevices: enumerateDevicesMock,
     },
   });
-
   it('should change the audio input track if the provided id is different', async () => {
+    // @ts-expect-error
     client.setMediaConstraints(constraints);
     expect(client.getAudioDeviceId()).toBe(defaultId);
+    // @ts-expect-error
     const result = await client.changeAudioInputDevice(deviceId, session);
     expect(result).toBeTruthy();
   });
-
   it('should NOT change the audio input track if the provided id is the same', async () => {
+    // @ts-expect-error
     client.setMediaConstraints(constraints);
     expect(client.getAudioDeviceId()).toBe(defaultId);
+    // @ts-expect-error
     const result = await client.changeAudioInputDevice(defaultId, session);
     expect(result).toBeFalsy();
   });
-
   it('should change the audio input track if the provided id is the same and force param is TRUE', async () => {
+    // @ts-expect-error
     client.setMediaConstraints(constraints);
     expect(client.getAudioDeviceId()).toBe(defaultId);
+    // @ts-expect-error
     const result = await client.changeAudioInputDevice(defaultId, session, true);
     expect(result).toBeTruthy();
   });
-
   describe('setVideoInputDevice', () => {
     it('should retain its original video values', () => {
-      const video = { height: { min: 480, max: 720 }, width: { min: 640, max: 1280 } };
-
+      const video = {
+        height: {
+          min: 480,
+          max: 720,
+        },
+        width: {
+          min: 640,
+          max: 1280,
+        },
+      };
       client.video = video;
       client.setVideoInputDevice(deviceId);
-      expect(client.video).toEqual({ ...video, deviceId: { exact: deviceId } });
+      expect(client.video).toEqual({ ...video,
+        deviceId: {
+          exact: deviceId,
+        },
+      });
     });
-
     it('should set deviceId when video\'s original value is true', () => {
       client.video = true;
       client.setVideoInputDevice(deviceId);
-      expect(client.video).toEqual({ deviceId: { exact: deviceId } });
+      expect(client.video).toEqual({
+        deviceId: {
+          exact: deviceId,
+        },
+      });
     });
-
     it('should set deviceId when video\'s original value is not set', () => {
       client.video = undefined;
       client.setVideoInputDevice(deviceId);
-      expect(client.video).toEqual({ deviceId: { exact: deviceId } });
+      expect(client.video).toEqual({
+        deviceId: {
+          exact: deviceId,
+        },
+      });
     });
-
     it('should NOT set deviceId when its value does not change', () => {
-      client.video = { deviceId: { exact: deviceId } };
+      client.video = {
+        deviceId: {
+          exact: deviceId,
+        },
+      };
       const result = client.setVideoInputDevice(deviceId);
       expect(result).toEqual(null);
-      expect(client.video).toEqual({ deviceId: { exact: deviceId } });
+      expect(client.video).toEqual({
+        deviceId: {
+          exact: deviceId,
+        },
+      });
     });
   });
 });

package/src/api/agentd.ts

@@ -0,0 +1,37 @@
+import ApiRequester from '../utils/api-requester';
+import Agent from '../domain/Agent';
+
+export interface AgentD {
+  getAgent: (agentId: string) => Promise<Agent>;
+  login: (agentNumber: string, context: string, extension: string) => Promise<boolean>;
+  loginWithLineId: (lineId: number) => Promise<boolean>;
+  logout: (agentNumber: string) => Promise<boolean>;
+  pause: (agentNumber: string) => Promise<boolean>;
+  resume: (agentNumber: string) => Promise<boolean>;
+  getStatus: () => Promise<Agent>;
+  staticLogout: () => Promise<boolean>;
+  staticPause: () => Promise<boolean>;
+  staticResume: () => Promise<boolean>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): AgentD => ({
+  getAgent: (agentId: string): Promise<Agent> => client.get(`${baseUrl}/agents/by-id/${agentId}`, null).then(Agent.parse),
+  login: (agentNumber: string, context: string, extension: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/login`, {
+    context,
+    extension,
+  }, null, ApiRequester.successResponseParser),
+  loginWithLineId: (lineId: number) => client.post(`${baseUrl}/users/me/agents/login`, {
+    line_id: lineId,
+  }, null, ApiRequester.successResponseParser),
+  logout: (agentNumber: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/logoff`, null, null, ApiRequester.successResponseParser),
+  pause: (agentNumber: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/pause`, {
+    reason: 'songbird_reason',
+  }, null, ApiRequester.successResponseParser),
+  resume: (agentNumber: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/unpause`, null, null, ApiRequester.successResponseParser),
+  getStatus: (): Promise<Agent> => client.get(`${baseUrl}/users/me/agents`, null).then(Agent.parse),
+  staticLogout: () => client.post(`${baseUrl}/users/me/agents/logoff`, null, null, ApiRequester.successResponseParser),
+  staticPause: () => client.post(`${baseUrl}/users/me/agents/pause`, {
+    reason: 'songbird_reason',
+  }, null, ApiRequester.successResponseParser),
+  staticResume: () => client.post(`${baseUrl}/users/me/agents/unpause`, null, null, ApiRequester.successResponseParser),
+}));

package/src/api/amid.ts

@@ -0,0 +1,16 @@
+import ApiRequester from '../utils/api-requester';
+
+export interface AmiD {
+  action: (action: string, args: Record<string, any>) => Promise<string>;
+  getAors: (endpoint: string) => Promise<any[]>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): AmiD => ({
+  action: (action: string, args: Record<string, any> = {}): Promise<string> => client.post(`${baseUrl}/action/${action}`, args),
+  getAors: async (endpoint: string) => {
+    const rawEvents = await client.post(`${baseUrl}/action/PJSIPShowEndpoint`, {
+      Endpoint: endpoint,
+    });
+    return rawEvents.filter((event: Record<string, any>) => event.Event === 'ContactStatusDetail');
+  },
+}));