@wazo/sdk 0.38.22 → 0.39.0-beta.1

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

@@ -1,28 +1,25 @@
-/* @flow */
-import authMethods from './api/auth';
-import applicationMethods from './api/application';
-import confdMethods from './api/confd';
-import ctidNgMethods from './api/ctid-ng';
-import dirdMethods from './api/dird';
-import callLogdMethods from './api/call-logd';
-import chatdMethods from './api/chatd';
-import calldMethods from './api/calld';
-import agentdMethods from './api/agentd';
-import webhookdMethods from './api/webhookd';
-import amidMethods from './api/amid';
-
+import authMethods, { AuthD } from './api/auth';
+import applicationMethods, { ApplicationD } from './api/application';
+import confdMethods, { ConfD } from './api/confd';
+import ctidNgMethods, { CtidNg } from './api/ctid-ng';
+import dirdMethods, { DirD } from './api/dird';
+import callLogdMethods, { CallLogD } from './api/call-logd';
+import chatdMethods, { ChatD } from './api/chatd';
+import calldMethods, { CallD } from './api/calld';
+import agentdMethods, { AgentD } from './api/agentd';
+import webhookdMethods, { WebhookD } from './api/webhookd';
+import amidMethods, { AmiD } from './api/amid';
 import ApiRequester from './utils/api-requester';
 import IssueReporter from './service/IssueReporter';
 
 type ConstructorParams = {
-  server: string,
-  agent?: ?Object,
-  clientId?: string,
-  refreshToken?: ?string,
-  isMobile?: ?boolean,
-  fetchOptions?: Object,
+  server: string;
+  agent?: Record<string, any> | null | undefined;
+  clientId?: string;
+  refreshToken?: string | null | undefined;
+  isMobile?: boolean | null | undefined;
+  fetchOptions?: Record<string, any>;
 };
-
 const AUTH_VERSION = '0.1';
 const APPLICATION_VERSION = '1.0';
 const CONFD_VERSION = '1.1';
@@ -34,36 +31,65 @@ const CALLD_VERSION = '1.0';
 const AGENTD_VERSION = '1.0';
 const WEBHOOKD_VERSION = '1.0';
 const AMID_VERSION = '1.0';
-
 const logger = IssueReporter ? IssueReporter.loggerFor('api') : console;
-
 export default class ApiClient {
   client: ApiRequester;
-  auth: Object;
-  application: Object;
-  confd: Object;
-  ctidNg: Object;
-  dird: Object;
-  callLogd: Object;
-  chatd: Object;
-  calld: Object;
-  agentd: Object;
-  webhookd: Object;
-  amid: Object;
-
-  refreshToken: ?string;
-  onRefreshToken: ?Function;
-  onRefreshTokenError: ?Function;
-  refreshExpiration: ?number;
-  refreshBackend: ?string;
-  refreshTenantId: ?string;
-  refreshDomainName: ?string;
+
+  auth: AuthD;
+
+  application: ApplicationD;
+
+  confd: ConfD;
+
+  ctidNg: CtidNg;
+
+  dird: DirD;
+
+  callLogd: CallLogD;
+
+  chatd: ChatD;
+
+  calld: CallD;
+
+  agentd: AgentD;
+
+  webhookd: WebhookD;
+
+  amid: AmiD;
+
+  refreshToken: string | null | undefined;
+
+  onRefreshToken: ((...args: Array<any>) => any) | null | undefined;
+
+  onRefreshTokenError: ((...args: Array<any>) => any) | null | undefined;
+
+  refreshExpiration: number | null | undefined;
+
+  refreshBackend: string | null | undefined;
+
+  refreshTenantId: string | null | undefined;
+
+  refreshDomainName: string | null | undefined;
+
   isMobile: boolean;
-  fetchOptions: Object;
+
+  fetchOptions: Record<string, any>;
 
   // @see https://github.com/facebook/flow/issues/183#issuecomment-358607052
-  constructor({ server, agent = null, refreshToken, clientId, isMobile = false, fetchOptions }: ConstructorParams) {
-    this.updateParameters({ server, agent, clientId, fetchOptions });
+  constructor({
+    server,
+    agent = null,
+    refreshToken,
+    clientId,
+    isMobile = false,
+    fetchOptions,
+  }: ConstructorParams) {
+    this.updateParameters({
+      server,
+      agent,
+      clientId,
+      fetchOptions,
+    });
     this.refreshToken = refreshToken;
     this.isMobile = isMobile || false;
   }
@@ -82,10 +108,20 @@ export default class ApiClient {
     this.amid = amidMethods(this.client, `amid/${AMID_VERSION}`);
   }
 
-  updateParameters({ server, agent, clientId, fetchOptions }: Object) {
+  updateParameters({
+    server,
+    agent,
+    clientId,
+    fetchOptions,
+  }: Record<string, any>) {
     const refreshTokenCallback = this.refreshTokenCallback.bind(this);
-    this.client = new ApiRequester({ server, agent, refreshTokenCallback, clientId, fetchOptions });
-
+    this.client = new ApiRequester({
+      server,
+      agent,
+      refreshTokenCallback,
+      clientId,
+      fetchOptions,
+    });
     this.initializeEndpoints();
   }
 
@@ -109,25 +145,22 @@ export default class ApiClient {
     }
 
     try {
-      const session = await this.auth.refreshToken(
-        this.refreshToken,
-        this.refreshBackend,
-        this.refreshExpiration,
-        this.isMobile,
-        this.refreshTenantId,
-        this.refreshDomainName,
-      );
+      const session = await this.auth.refreshToken(this.refreshToken, this.refreshBackend as string, this.refreshExpiration as number, this.isMobile, this.refreshTenantId as string, this.refreshDomainName as string);
+      if (!session) {
+        return null;
+      }
 
-      logger.info('token refreshed', { token: session.token });
+      logger.info('token refreshed', {
+        token: session.token,
+      });
 
       if (this.onRefreshToken) {
         this.onRefreshToken(session.token, session);
       }
 
       this.setToken(session.token);
-
       return session.token;
-    } catch (error) {
+    } catch (error: any) {
       logger.error('token refresh, error', error);
 
       if (this.onRefreshTokenError) {
@@ -144,19 +177,19 @@ export default class ApiClient {
     this.client.setTenant(tenant);
   }
 
-  setRefreshToken(refreshToken: ?string) {
+  setRefreshToken(refreshToken: string | null | undefined) {
     this.refreshToken = refreshToken;
   }
 
-  setClientId(clientId: ?string) {
+  setClientId(clientId: string | null | undefined) {
     this.client.clientId = clientId;
   }
 
-  setOnRefreshToken(onRefreshToken: Function) {
+  setOnRefreshToken(onRefreshToken: (...args: Array<any>) => any) {
     this.onRefreshToken = onRefreshToken;
   }
 
-  setOnRefreshTokenError(callback: Function) {
+  setOnRefreshTokenError(callback: (...args: Array<any>) => any) {
     this.onRefreshTokenError = callback;
   }
 
@@ -168,12 +201,12 @@ export default class ApiClient {
     this.refreshBackend = refreshBackend;
   }
 
-  setRefreshTenantId(tenantId: ?string) {
+  setRefreshTenantId(tenantId: string | null | undefined) {
     console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead');
     this.refreshTenantId = tenantId;
   }
 
-  setRefreshDomainName(domainName: ?string) {
+  setRefreshDomainName(domainName: string | null | undefined) {
     this.refreshDomainName = domainName;
   }
 
@@ -181,7 +214,7 @@ export default class ApiClient {
     this.isMobile = isMobile;
   }
 
-  setFetchOptions(fetchOptions: Object) {
+  setFetchOptions(fetchOptions: Record<string, any>) {
     this.fetchOptions = fetchOptions;
     this.client.setFetchOptions(fetchOptions);
   }
@@ -189,4 +222,5 @@ export default class ApiClient {
   disableErrorLogging() {
     this.client.disableErrorLogging();
   }
+
 }

package/src/checker/{Checker.js → Checker.ts}

@@ -1,46 +1,49 @@
-// @flow
-
 import type Session from '../domain/Session';
 import WazoApiClient from '../api-client';
 import IssueReporter from '../service/IssueReporter';
-
 import checks from './checks/index';
 
 const logger = IssueReporter.loggerFor('engine-check');
 
 class Checker {
   session: Session;
+
   server: string;
-  externalAppConfig: Object;
-  checks: Object[];
 
-  constructor(server: string, session: Session, externalAppConfig: Object = {}) {
+  externalAppConfig: Record<string, any>;
+
+  checks: Record<string, any>[];
+
+  constructor(server: string, session: Session, externalAppConfig: Record<string, any> = {}) {
     this.server = server;
     this.session = session;
     this.externalAppConfig = externalAppConfig;
     this.checks = [...checks];
   }
 
-  async check(onCheckBegin: Function = () => {}, onCheckResult: Function = () => {}) {
+  async check(onCheckBegin: (...args: Array<any>) => any = () => {}, onCheckResult: (...args: Array<any>) => any = () => {}) {
     await this._addEngineVersion();
-
     logger.info('Engine check starting');
 
     for (let i = 0; i < this.checks.length; i++) {
-      const { name, check } = this.checks[i];
-
+      const {
+        name,
+        check,
+      } = this.checks[i];
       logger.info(`Checking ${name} ...`);
-
       onCheckBegin(name);
+
       try {
         // eslint-disable-next-line no-await-in-loop
         const result = await check(this.server, this.session, this.externalAppConfig);
-        logger.info(`Checking ${name} success.`, { result });
-
+        logger.info(`Checking ${name} success.`, {
+          result,
+        });
         onCheckResult(name, result);
-      } catch (e) {
-        logger.info(`Checking ${name} failure`, { message: e.message });
-
+      } catch (e: any) {
+        logger.info(`Checking ${name} failure`, {
+          message: e.message,
+        });
         onCheckResult(name, e);
       }
     }
@@ -48,19 +51,23 @@ class Checker {
     logger.info('Engine check done.');
   }
 
-  addCheck(check: Object) {
+  addCheck(check: Record<string, any>) {
     this.checks.push(check);
   }
 
   async _addEngineVersion() {
     if (!this.session.engineVersion) {
-      const apiClient = new WazoApiClient({ server: this.server });
+      const apiClient = new WazoApiClient({
+        server: this.server,
+      });
       apiClient.setToken(this.session.token);
-
-      const { wazo_version: engineVersion } = await apiClient.confd.getInfos();
+      const {
+        wazo_version: engineVersion,
+      } = await apiClient.confd.getInfos();
       this.session.engineVersion = engineVersion;
     }
   }
+
 }
 
 export default Checker;

package/src/checker/checks/{aor.js → aor.ts}

@@ -2,24 +2,28 @@ import WazoApiClient from '../../api-client';
 
 export default {
   name: 'List of AOR',
-  check: async (server, session) => {
-    const apiClient = new WazoApiClient({ server });
+  check: async (server: string, session: any) => {
+    const apiClient = new WazoApiClient({
+      server,
+    });
     apiClient.setToken(session.token);
     apiClient.disableErrorLogging();
-
     const line = session.primaryWebRtcLine();
+
     if (!line) {
       return 'No WebRTC line for this user';
     }
-    const { username } = line;
+
+    const {
+      username,
+    } = line;
 
     try {
       const aors = await apiClient.amid.getAors(username);
       const nbAors = aors.length;
       const availableAors = aors.filter(aor => aor.status === 'Reachable');
-
       return `Number of AOR: ${nbAors} (${availableAors.length} Avail, ${nbAors - availableAors.length} Unavail)`;
-    } catch (e) {
+    } catch (e: any) {
       if (e.status === 401) {
         return 'Not available for this user';
       }

package/src/checker/checks/{api.js → api.ts}

@@ -3,40 +3,41 @@ import ServerError from '../../domain/ServerError';
 
 export default {
   name: 'API',
-  check: async (server, session) => {
-    const client = new WazoApiClient({ server });
+  check: async (server: string, session: any) => {
+    const client = new WazoApiClient({
+      server,
+    });
     client.setToken(session.token);
     client.disableErrorLogging();
 
-    const handleApiError = (apiName, error) => {
+    const handleApiError = (apiName: string, error: any) => {
       const statusText = error instanceof ServerError ? 'server error' : 'api error';
-
       throw new Error(`${apiName} fails with status (${error.status}, ${statusText}) : ${error.message}`);
     };
 
     // Check simple API call
     try {
-      await client.auth.getPushNotificationSenderId(session.uuid);
-      await client.auth.getProviders(session.uuid);
-    } catch (e) {
+      await client.auth.getPushNotificationSenderId(session.uuid as string);
+      await client.auth.getProviders(session.uuid as string);
+    } catch (e: any) {
       handleApiError('wazo-auth', e);
     }
 
     try {
       await client.callLogd.listCallLogs();
-    } catch (e) {
+    } catch (e: any) {
       handleApiError('wazo-callogd', e);
     }
 
     try {
       await client.calld.listCalls();
-    } catch (e) {
+    } catch (e: any) {
       handleApiError('wazo-calld', e);
     }
 
     try {
       await client.calld.listVoicemails();
-    } catch (e) {
+    } catch (e: any) {
       // API throws a 404 when no voicemail
       if (e.status !== 404) {
         handleApiError('wazo-calld', e);
@@ -44,17 +45,17 @@ export default {
     }
 
     try {
-      await client.chatd.getState(session.uuid);
-      await client.chatd.getContactStatusInfo(session.uuid);
+      await client.chatd.getState(session.uuid as string);
+      await client.chatd.getContactStatusInfo(session.uuid as string);
       await client.chatd.getUserRooms();
-    } catch (e) {
+    } catch (e: any) {
       handleApiError('wazo-chatd', e);
     }
 
     try {
       await client.confd.getInfos();
-      await client.confd.getUser(session.uuid);
-    } catch (e) {
+      await client.confd.getUser(session.uuid as string);
+    } catch (e: any) {
       handleApiError('wazo-confd', e);
     }
 
@@ -64,13 +65,13 @@ export default {
       await client.dird.fetchWazoSource(session.primaryContext());
       const conferenceSource = await client.dird.fetchConferenceSource(session.primaryContext());
       await client.dird.fetchConferenceContacts(conferenceSource.items[0]);
-    } catch (e) {
+    } catch (e: any) {
       handleApiError('wazo-dird', e);
     }
 
     try {
       await client.webhookd.getSubscriptions();
-    } catch (e) {
+    } catch (e: any) {
       handleApiError('wazo-webhookd', e);
     }
   },

package/src/checker/checks/{ice-ipv4.js → ice-ipv4.ts}

@@ -1,10 +1,10 @@
 /* global MediaStream, RTCPeerConnection */
-
 import { parseCandidate } from '../../utils/webrtc';
 import isMobile from '../../utils/isMobile';
 
-const checkIsIPV4 = ip => {
+const checkIsIPV4 = (ip: string) => {
   const blocks = ip.split('.');
+
   if (blocks.length !== 4) {
     return false;
   }
@@ -14,47 +14,46 @@ const checkIsIPV4 = ip => {
 
 export default {
   name: 'Non IP v4 ice',
-  check: (server, session, externalAppConfig) => new Promise((resolve, reject) => {
+  check: (server: string, session: any, externalAppConfig: Record<string, any>) => new Promise((resolve, reject) => {
     if (typeof MediaStream === 'undefined') {
       return resolve('Skipped on node');
     }
 
     const mobile = isMobile();
-    const offerOptions = { offerToReceiveAudio: 1 };
-    const ips = [];
-    const config = {
-      iceServers: [
-        { urls: 'stun:stun1.l.google.com:19302' },
-        { urls: 'stun:stun2.l.google.com:19302' },
-      ],
+    const offerOptions: any = {
+      offerToReceiveAudio: 1,
+    };
+    const ips: string[] = [];
+    const config: any = {
+      iceServers: [{
+        urls: 'stun:stun1.l.google.com:19302',
+      }, {
+        urls: 'stun:stun2.l.google.com:19302',
+      }],
     };
     let hasSrflxOrRelay = false;
 
     if (externalAppConfig && externalAppConfig.stun_servers) {
-      config.iceServers = {
-        ...externalAppConfig.stun_servers.split(',').map(url => ({ urls: url })),
-        ...config.iceServers,
+      config.iceServers = { ...externalAppConfig.stun_servers.split(',').map((url: string) => ({
+        urls: url,
+      })),
+      ...config.iceServers,
       };
     }
 
     if (externalAppConfig && externalAppConfig.turn_servers) {
-      // $FlowFixMe
-      config.iceServers = [
-        ...JSON.parse(externalAppConfig.turn_servers),
-        ...config.iceServers,
-      ];
-
+      config.iceServers = [...JSON.parse(externalAppConfig.turn_servers), ...config.iceServers];
       // Force to use TURN when defined in config
       config.iceTransportPolicy = 'relay';
     }
 
     const pc = new RTCPeerConnection(config);
-
     pc.createDataChannel('wazo-check-ipv4');
 
     pc.onicecandidate = e => {
       if (e.candidate) {
         const rawCandidate = e.candidate.candidate;
+
         if (rawCandidate.indexOf('srflx') !== -1 || rawCandidate.indexOf('relay') !== -1) {
           hasSrflxOrRelay = true;
           const candidate = parseCandidate(e.candidate.candidate);
@@ -64,20 +63,18 @@ export default {
         if (!hasSrflxOrRelay) {
           return reject(new Error('No `srflx` or `relay` found in candidate. Please consider using a TURN server.'));
         }
+
         if (ips.every(checkIsIPV4)) {
+          // @ts-ignore
           resolve();
         } else {
           const nonIPV4 = ips.find(ip => !checkIsIPV4(ip));
-
           reject(new Error(`Non IPv4 ice candidate found : ${nonIPV4}.`));
         }
-
       }
     };
 
-    pc.createOffer(offerOptions)
-      .then(offer => pc.setLocalDescription(offer))
-      .then(description => (mobile ? pc.createOffer(offerOptions) : description))
-      .then(sessionDescription => (mobile ? pc.setLocalDescription(sessionDescription) : sessionDescription));
+    // @ts-ignore
+    pc.createOffer(offerOptions).then(offer => pc.setLocalDescription(offer)).then(description => (mobile ? pc.createOffer(offerOptions) : description)).then(sessionDescription => (mobile ? pc.setLocalDescription(sessionDescription) : sessionDescription));
   }),
 };

package/src/checker/checks/{index.js → index.ts}

@@ -6,12 +6,4 @@ import webrtc from './webrtc';
 import SymmetricNat from './symmetric-nat';
 import iceIpv4 from './ice-ipv4';
 
-export default [
-  aor,
-  api,
-  wazoWebsocket,
-  webrtcTransport,
-  webrtc,
-  SymmetricNat,
-  iceIpv4,
-];
+export default [aor, api, wazoWebsocket, webrtcTransport, webrtc, SymmetricNat, iceIpv4];

package/src/checker/checks/{symmetric-nat.js → symmetric-nat.ts}

@@ -1,29 +1,28 @@
 /* global MediaStream, RTCPeerConnection */
 import { parseCandidate } from '../../utils/webrtc';
 
-const timeoutDuration = 8000;
+const timeoutDuration = 8000; // @see https://webrtchacks.com/symmetric-nat/
 
-// @see https://webrtchacks.com/symmetric-nat/
 export default {
   name: 'Symmetric NAT',
-  check: () => new Promise((resolve, reject) => {
+  check: (): Promise<string | void> => new Promise((resolve, reject) => {
     if (typeof MediaStream === 'undefined') {
       return resolve('Skipped on node');
     }
 
-    const candidates = {};
-    const rawCandidates = [];
+    const candidates: any = {};
+    const rawCandidates: any = [];
     let nbCandidates = 0;
-
     const pc = new RTCPeerConnection({
-      iceServers: [
-        { urls: 'stun:stun.wazo.io:443' },
-        { urls: 'stun:stun1.l.google.com:19302' },
-        { urls: 'stun:stun2.l.google.com:19302' },
-      ],
+      iceServers: [{
+        urls: 'stun:stun.wazo.io:443',
+      }, {
+        urls: 'stun:stun1.l.google.com:19302',
+      }, {
+        urls: 'stun:stun2.l.google.com:19302',
+      }],
     });
-
-    let timeout;
+    let timeout: any;
 
     const onEnded = () => {
       clearTimeout(timeout);
@@ -32,6 +31,7 @@ export default {
         reject(new Error(`Timed out (${timeoutDuration}ms), ${nbCandidates} candidates : ${rawCandidates.join(', ')}`));
         return;
       }
+
       const ports = candidates[Object.keys(candidates)[0]];
 
       if (ports.length === 1) {
@@ -42,7 +42,6 @@ export default {
     };
 
     timeout = setTimeout(onEnded, timeoutDuration);
-
     pc.createDataChannel('wazo-check-nat');
 
     pc.onicecandidate = e => {
@@ -53,7 +52,7 @@ export default {
       }
 
       if (e.candidate && e.candidate.candidate.indexOf('srflx') !== -1) {
-        const cand = parseCandidate(e.candidate.candidate);
+        const cand: any = parseCandidate(e.candidate.candidate);
         if (!candidates[cand.relatedPort]) candidates[cand.relatedPort] = [];
         candidates[cand.relatedPort].push(cand.port);
       } else if (!e.candidate) {

package/src/checker/checks/{wazo-websocket.js → wazo-websocket.ts}

@@ -2,10 +2,14 @@ import WebSocketClient, { SOCKET_EVENTS, HEARTBEAT_ENGINE_VERSION } from '../../
 
 export default {
   name: 'Wazo Websocket',
-  check: (server, session) => new Promise((resolve, reject) => {
-    const client = new WebSocketClient({ host: server, token: session.token, version: 2 });
+  check: (server: string, session: any) => new Promise<void>((resolve, reject) => {
+    const client = new WebSocketClient({
+      host: server,
+      token: session.token,
+      version: 2,
+    });
 
-    const handleError = (message) => {
+    const handleError = (message: any) => {
       client.close();
       reject(new Error(message));
     };
@@ -19,7 +23,6 @@ export default {
     client.on(SOCKET_EVENTS.ON_ERROR, error => {
       handleError(`Connection error : ${error}`);
     });
-
     client.on(SOCKET_EVENTS.ON_OPEN, () => {
       if (session.hasEngineVersionGte(HEARTBEAT_ENGINE_VERSION)) {
         client.setOnHeartbeatTimeout(() => {
@@ -33,7 +36,6 @@ export default {
         handleSuccess();
       }
     });
-
     client.connect();
   }),
 };