@wazo/sdk 0.38.22 → 0.39.0-beta.1

package/src/utils/__tests__/{sdp.test.js → sdp.test.ts}

@@ -1,16 +1,6 @@
 /* eslint-disable max-len */
 import sdpParser from 'sdp-transform';
-
-import {
-  getCandidates,
-  isSdpValid,
-  parseCandidate,
-  areCandidateValid,
-  fixSdp,
-  fixBundle,
-  toggleVideoDirection,
-  hasAnActiveVideo, addIcesInAllBundles,
-} from '../sdp';
+import { getCandidates, isSdpValid, parseCandidate, areCandidateValid, fixSdp, fixBundle, toggleVideoDirection, hasAnActiveVideo, addIcesInAllBundles } from '../sdp';
 
 const goodSdp = `
 c=IN IP4 203.0.113.1
@@ -18,7 +8,6 @@ m=audio 54400 RTP/SAVPF 0 96
 a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
 a=candidate:3996450952 1 udp 41819903 14.72.21.2 65092 typ relay raddr 0.0.0.0 rport 0 generation 0 network-id 3 network-cost 10
 `;
-
 const badMobileSdp = `
 o=- 31220837228924684 2 IN IP4 127.0.0.1
 s=-
@@ -43,15 +32,12 @@ a=fmtp:111 minptime=10;useinbandfec=1
 a=rtpmap:103 ISAC/16000
 a=ssrc:3716126308 label:3e68fa77-fca9-4b21-a00f-27c65d78928e
 `;
-
 const badSdp = `
 c=IN IP4 203.0.113.1
 m=audio 54400 RTP/SAVPF 0 96
 a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
 `;
-
 const candidate = 'candidate:3996450952 1 udp 41819903 14.72.2.1 57021 typ relay raddr 0.0.0.0 rport 0 generation 0 ufrag Ja/g network-id 3 network-cost 10';
-
 const videoReinvite = `
 INVITE sip:127.0.0.1:5039;transport=ws SIP/2.0
 
@@ -65,7 +51,6 @@ c=IN IP4 74.59.196.3
 m=video 52964 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 121 127 120 125 107 108 109 35 36 124 119 123 118 114 115 116
 c=IN IP4 74.59.196.3
 `;
-
 const invalidBundle = `
 INVITE sip:127.0.0.1:5039;transport=ws SIP/2.0
 
@@ -78,7 +63,6 @@ a=mid:0
 m=video 65050 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 121 127 120 125 107 108 109 35 36 124 119 123 118 114 115 116
 a=mid:1
 `;
-
 const inactiveVideo = `
 INVITE sip:127.0.0.1:5039;transport=ws SIP/2.0
 
@@ -92,41 +76,37 @@ m=video 65050 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 121 127 120 125 107 108
 a=inactive
 a=mid:video-1
 `;
-
 describe('SDP utils', () => {
   describe('Parsing candidates', () => {
     it('should return all candidates', () => {
       const candidates = getCandidates(goodSdp);
-
       expect(candidates.length).toBe(2);
       expect(candidates[0].type).toBe('host');
       expect(candidates[1].type).toBe('relay');
-
       expect(isSdpValid(goodSdp)).toBeTruthy();
-
       expect(getCandidates(badMobileSdp).length).toBe(0);
       expect(getCandidates(null).length).toBe(0);
       expect(getCandidates('').length).toBe(0);
       expect(getCandidates('nothing!').length).toBe(0);
     });
   });
-
   describe('Parsing candidate', () => {
     it('should parse a single candidate', () => {
       const parsed = parseCandidate(candidate);
-
+      // @ts-expect-error
       expect(parsed.type).toBe('relay');
+      // @ts-expect-error
       expect(parsed.ip).toBe('14.72.2.1');
     });
   });
-
   describe('Validating candidates', () => {
     it('should parse a single candidate', () => {
+      // @ts-expect-error
       expect(areCandidateValid([null])).toBeFalsy();
+      // @ts-expect-error
       expect(areCandidateValid([parseCandidate(candidate)])).toBeTruthy();
     });
   });
-
   describe('Validating sdp', () => {
     it('should tell if a sdp is valid', () => {
       expect(isSdpValid(goodSdp)).toBeTruthy();
@@ -134,47 +114,42 @@ describe('SDP utils', () => {
       expect(isSdpValid(badMobileSdp)).toBeFalsy();
     });
   });
-
   describe('Fixing sdp', () => {
     it('should fix a SDP without candidate or IN ip', () => {
       const candidates = [parseCandidate(candidate)];
-
+      // @ts-expect-error
       const fixedSdp = fixSdp(badMobileSdp, candidates);
       const parsed = sdpParser.parse(fixedSdp);
-
+      // @ts-expect-error
       expect(parsed.media[0].candidates.length).toBe(1);
       expect(parsed.media[0].port).toBe(57021);
+      // @ts-expect-error
       expect(parsed.origin.address).toBe('14.72.2.1');
       expect(fixedSdp.indexOf('IN 0.0.0.0')).toBe(-1);
     });
   });
-
   describe('Fixing group bundle', () => {
     it('should set a bundle for each m section', async () => {
       const invalid = fixBundle(invalidBundle);
       const parsed = sdpParser.parse(invalid);
-
+      // @ts-expect-error
       expect(parsed.groups[0].mids).toBe('0 1');
     });
   });
-
   describe('Deactivate video', () => {
     it('should set inactive to each video sections', async () => {
       const sdp = toggleVideoDirection(videoReinvite, 'inactive');
       const parsed = sdpParser.parse(sdp);
-
       expect(parsed.media[1].direction).toBe('inactive');
       expect(parsed.media[2].direction).toBe('inactive');
     });
   });
-
   describe('Checking if video is active ', () => {
     it('should return true if a section video is active', async () => {
       expect(hasAnActiveVideo(videoReinvite)).toBeTruthy();
       expect(hasAnActiveVideo(inactiveVideo)).toBeFalsy();
     });
   });
-
   describe('Adding candidate in all bundles ', () => {
     it('should add candidate everywhere', async () => {
       const audioWithoutCandidate = `
@@ -185,12 +160,14 @@ a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
 a=candidate:3996450952 1 udp 41819903 14.72.21.2 65092 typ relay raddr 0.0.0.0 rport 0 generation 0 network-id 3 network-cost 10
 `;
       const fixedAudioWithoutCandidate = sdpParser.parse(addIcesInAllBundles(audioWithoutCandidate));
-
+      // @ts-expect-error
       expect(fixedAudioWithoutCandidate.media[0].candidates[0].type).toBe('host');
+      // @ts-expect-error
       expect(fixedAudioWithoutCandidate.media[0].candidates[1].type).toBe('relay');
+      // @ts-expect-error
       expect(fixedAudioWithoutCandidate.media[1].candidates[0].type).toBe('host');
+      // @ts-expect-error
       expect(fixedAudioWithoutCandidate.media[1].candidates[1].type).toBe('relay');
-
       // It should not add candidate if already present
       const audioWithCandidate = `
 c=IN IP4 203.0.113.1
@@ -201,8 +178,9 @@ m=video 54400 RTP/SAVPF 0 96
 a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
 `;
       const fixedAudioWithCandidate = sdpParser.parse(addIcesInAllBundles(audioWithCandidate));
-
+      // @ts-expect-error
       expect(fixedAudioWithCandidate.media[0].candidates[0].type).toBe('srflx');
+      // @ts-expect-error
       expect(fixedAudioWithCandidate.media[1].candidates[0].type).toBe('host');
     });
   });

package/src/utils/__tests__/{string.test.js → string.test.ts}

@@ -3,18 +3,20 @@ import { camelToUnderscore } from '../string';
 describe('string utils', () => {
   describe('camelToUnderscore', () => {
     it('', () => {
+      // @ts-expect-error
       expect(() => camelToUnderscore(null)).toThrow('Input is not a string');
+      // @ts-expect-error
       expect(() => camelToUnderscore(undefined)).toThrow('Input is not a string');
+      // @ts-expect-error
       expect(() => camelToUnderscore({})).toThrow('Input is not a string');
+      // @ts-expect-error
       expect(() => camelToUnderscore([])).toThrow('Input is not a string');
     });
-
     it('should convert camel-cased string to underscore', () => {
       expect(camelToUnderscore('loremIpsum')).toEqual('lorem_ipsum');
       expect(camelToUnderscore('lorem-ipsum')).toEqual('lorem-ipsum');
       expect(camelToUnderscore('')).toEqual('');
     });
-
     it('should not prefix string with an underscore', () => {
       expect(camelToUnderscore('LoremIpsum')).toEqual('lorem_ipsum');
       expect(camelToUnderscore('L123')).toEqual('l123');

package/src/utils/{api-requester.js → api-requester.ts}

@@ -1,9 +1,10 @@
-/* @flow */
-/* global btoa, window, fetch */
+/* eslint-disable @typescript-eslint/default-param-last */
+/* global window */
+
 /* eslint-disable global-require */
+
 /* eslint-disable import/no-dynamic-require */
 import { Base64 } from 'js-base64';
-
 import BadResponse from '../domain/BadResponse';
 import ServerError from '../domain/ServerError';
 import isMobile from './isMobile';
@@ -11,20 +12,21 @@ import type { Token } from '../domain/types';
 import IssueReporter from '../service/IssueReporter';
 
 type ConstructorParams = {
-  server: string,
-  agent: ?Object,
-  clientId: ?string,
-  refreshTokenCallback: Function,
-  token?: string,
-  fetchOptions: ?Object,
+  server: string;
+  agent: Record<string, any> | null | undefined;
+  clientId: string | null | undefined;
+  refreshTokenCallback: (...args: Array<any>) => any;
+  token?: string | null;
+  fetchOptions: Record<string, any> | null | undefined;
 };
-
 const methods = ['head', 'get', 'post', 'put', 'delete'];
-
 const logger = IssueReporter ? IssueReporter.loggerFor('api') : console;
-
 // 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;
@@ -40,44 +42,50 @@ export const realFetch = () => {
   // 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 {
-    // $FlowFixMe
     return require(Math.random() >= 0 ? 'node-fetch/lib/index' : '');
-  } catch (e) {
+  } catch (e: any) {
     return fetch;
   }
 };
-
 export default class ApiRequester {
   server: string;
-  agent: ?Object;
-  clientId: ?string;
+
+  agent: Record<string, any> | null | undefined;
+
+  clientId: string | null | undefined;
+
   token: string;
-  tenant: ?string;
-  fetchOptions: Object;
-  refreshTokenCallback: Function;
-  refreshTokenPromise: ?Promise<any>;
+
+  tenant: string | null | undefined;
+
+  fetchOptions: Record<string, any>;
+
+  refreshTokenCallback: (...args: Array<any>) => any;
+
+  refreshTokenPromise: Promise<any> | null | undefined;
+
   shouldLogErrors: boolean;
 
-  head: Function;
-  get: Function;
-  post: Function;
-  put: Function;
-  delete: Function;
+  head: (...args: Array<any>) => any;
+
+  get: (...args: Array<any>) => any;
+
+  post: (...args: Array<any>) => any;
+
+  put: (...args: Array<any>) => any;
 
-  // eslint-disable-next-line
-  static successResponseParser(response: Object, isJson: boolean) {
+  delete: (...args: Array<any>) => any;
+
+  static successResponseParser(response: Record<string, any>): boolean {
     return response.status === 204 || response.status === 201 || response.status === 200;
   }
 
-  static defaultParser(response: Object) {
-    return response.json().then((data: Object) => data);
+  static defaultParser(response: Record<string, any>) {
+    return response.json().then((data: Record<string, any>) => data);
   }
 
-  static getQueryString(obj: Object): string {
-    return Object.keys(obj)
-      .filter(key => obj[key])
-      .map(key => `${key}=${encodeURIComponent(obj[key])}`)
-      .join('&');
+  static getQueryString(obj: Record<string, any>): string {
+    return Object.keys(obj).filter(key => obj[key]).map(key => `${key}=${encodeURIComponent(obj[key])}`).join('&');
   }
 
   static base64Encode(str: string): string {
@@ -85,31 +93,38 @@ export default class ApiRequester {
   }
 
   // @see https://github.com/facebook/flow/issues/183#issuecomment-358607052
-  constructor({ server, refreshTokenCallback, clientId, agent = null, token = null, fetchOptions }: ConstructorParams) {
+  constructor({
+    server,
+    refreshTokenCallback,
+    clientId,
+    agent = null,
+    token = null,
+    fetchOptions,
+  }: ConstructorParams) {
     this.server = server;
     this.agent = agent;
     this.clientId = clientId;
     this.refreshTokenCallback = refreshTokenCallback;
     this.refreshTokenPromise = null;
     this.fetchOptions = fetchOptions || {};
+
     if (token) {
       this.token = token;
     }
 
     this.shouldLogErrors = true;
-
     methods.forEach(method => {
-      // $FlowFixMe
-      ApiRequester.prototype[method] = function sugar(...args) {
+      // @ts-ignore
+      this[method] = function sugar(...args) {
         // Add method in arguments passed to `call`
         args.splice(1, 0, method);
-
+        // @ts-ignore
         return this.call.call(this, ...args);
       };
     });
   }
 
-  setTenant(tenant: ?string) {
+  setTenant(tenant: string | null | undefined) {
     this.tenant = tenant;
   }
 
@@ -117,7 +132,7 @@ export default class ApiRequester {
     this.token = token;
   }
 
-  setFetchOptions(options: Object) {
+  setFetchOptions(options: Record<string, any>) {
     this.fetchOptions = options;
   }
 
@@ -129,65 +144,60 @@ export default class ApiRequester {
     this.shouldLogErrors = true;
   }
 
-  async call(
-    path: string,
-    method: string = 'get',
-    body: ?Object = null,
-    headers: ?string | ?Object = null,
-    parse: Function = ApiRequester.defaultParser,
-    firstCall: boolean = true,
-  ): Promise<any> {
+  async call(path: string, method = 'get', body: Record<string, any> | null | undefined = null, headers: (string | null | undefined) | (Record<string, any> | null | undefined) = null, parse: (...args: Array<any>) => any = ApiRequester.defaultParser, firstCall = true): Promise<any> {
     const url = this.computeUrl(method, path, body);
     const newHeaders = this.getHeaders(headers);
-    let newBody = method === 'get' ? null : body;
+    let newBody: any = method === 'get' ? null : body;
+
     if (newBody && newHeaders['Content-Type'] === 'application/json') {
       newBody = JSON.stringify(newBody);
     }
+
     const isHead = method === 'head';
     const hasEmptyResponse = method === 'delete' || isHead;
     const newParse = hasEmptyResponse ? ApiRequester.successResponseParser : parse;
-
-    const fetchOptions = { ...this.fetchOptions || {} };
+    const fetchOptions = { ...(this.fetchOptions || {}),
+    };
     const extraHeaders = fetchOptions.headers || {};
     delete fetchOptions.headers;
-
     const options = {
       method,
       body: newBody,
-      headers: { ...this.getHeaders(headers), ...extraHeaders },
+      headers: { ...this.getHeaders(headers),
+        ...extraHeaders,
+      },
       agent: this.agent,
       ...fetchOptions,
     };
 
     if (this.refreshTokenPromise) {
-      logger.info('A token is already refreshing, waiting ...', { url });
+      logger.info('A token is already refreshing, waiting ...', {
+        url,
+      });
       await this.refreshTokenPromise;
     }
 
     const start = new Date();
-
-    return realFetch()(url, options).then(response => {
+    return realFetch()(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);
 
       // Throw an error only if status >= 400
       if ((isHead && response.status >= 500) || (!isHead && response.status >= 400)) {
         const promise = isJson ? response.json() : response.text();
         const exceptionClass = response.status >= 500 ? ServerError : BadResponse;
-
-        return promise.then(async (err: Object) => {
+        return promise.then(async (err: Record<string, any>) => {
           // Check if the token is still valid
           if (firstCall && this._checkTokenExpired(response, err)) {
-            logger.warn('token expired', { error: err.reason });
+            logger.warn('token expired', {
+              error: err.reason,
+            });
             // Replay the call after refreshing the token
             return this._replayWithNewToken(err, path, method, body, headers, parse);
           }
 
-          const error = typeof err === 'string'
-            ? exceptionClass.fromText(err, response.status)
-            : exceptionClass.fromResponse(err, response.status);
+          const error = typeof err === 'string' ? exceptionClass.fromText(err, response.status) : exceptionClass.fromResponse(err, response.status);
 
           if (this.shouldLogErrors) {
             logger.error('API error', error);
@@ -198,43 +208,52 @@ export default class ApiRequester {
       }
 
       return newParse(response, isJson);
-    }).catch(error => {
+    }).catch((error: any) => {
       if (this.shouldLogErrors) {
-        logger.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+        logger.error('Fetch failed', {
+          url,
+          options,
+          message: error.message,
+          stack: error.stack,
+        });
       }
 
       throw error;
     });
   }
 
-  _checkTokenExpired(response: Object, err: Object) {
+  _checkTokenExpired(response: Record<string, any>, err: Record<string, any>) {
     // Special case when authenticating form a token: we got a 404
     const isTokenNotFound = response.status === 404 && this._isTokenNotFound(err);
 
     return response.status === 401 || isTokenNotFound;
   }
 
-  _isTokenNotFound(err: Object) {
+  _isTokenNotFound(err: Record<string, any>) {
     return err && err.reason && err.reason[0] === 'No such token';
   }
 
   _replayWithNewToken(
-    err: Object,
+    err: Record<string, any>,
     path: string,
     method: string,
-    body: ?Object = null,
-    headers: ?string | ?Object = null,
-    parse: Function,
+    body: Record<string, any> | null | undefined = null,
+    headers: (string | null | undefined) | (Record<string, any> | null | undefined) = null,
+    parse: ((...args: Array<any>) => any),
   ) {
     const isTokenNotFound = this._isTokenNotFound(err);
-    let newPath = path;
-    logger.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
 
+    let newPath = path;
+    logger.info('refreshing token', {
+      inProgress: !!this.refreshTokenPromise,
+    });
     this.refreshTokenPromise = this.refreshTokenPromise || this.refreshTokenCallback();
-
-    return this.refreshTokenPromise.then(() => {
+    return this.refreshTokenPromise?.then(() => {
       this.refreshTokenPromise = null;
-      logger.info('token refreshed', { isTokenNotFound });
+      logger.info('token refreshed', {
+        isTokenNotFound,
+      });
+
       if (isTokenNotFound) {
         const pathParts = path.split('/');
         pathParts.pop();
@@ -243,32 +262,34 @@ export default class ApiRequester {
       }
 
       return this.call(newPath, method, body, headers, parse, false);
-    }).catch((e) => {
+    }).catch(e => {
       this.refreshTokenPromise = null;
       throw e;
     });
   }
 
-  getHeaders(header: ?Token | ?Object): Object {
+  getHeaders(header: (Token | null | undefined) | (Record<string, any> | null | undefined)): Record<string, any> {
     if (header instanceof Object) {
       return header;
     }
 
     return {
       'X-Auth-Token': this.token,
-      ...(this.tenant ? { 'Wazo-Tenant': this.tenant } : null),
+      ...(this.tenant ? {
+        'Wazo-Tenant': this.tenant,
+      } : null),
       Accept: 'application/json',
       'Content-Type': 'application/json',
     };
   }
 
-  computeUrl(method: string, path: string, body: ?Object): string {
+  computeUrl(method: string, path: string, body: Record<string, any> | null | undefined): string {
     const url = `${this.baseUrl}/${path}`;
-
     return method === 'get' && body && Object.keys(body).length ? `${url}?${ApiRequester.getQueryString(body)}` : url;
   }
 
   get baseUrl(): string {
     return `https://${this.server}/api`;
   }
+
 }

package/src/utils/{array.js → array.ts}

@@ -1,5 +1,4 @@
-// @flow
-export const lastIndexOf = (array: any[], method: Function): number => {
+export const lastIndexOf = (array: any[], method: (...args: Array<any>) => any): number => {
   const start = array.length - 1;
 
   for (let i = start; i >= 0; i--) {
@@ -7,5 +6,6 @@ export const lastIndexOf = (array: any[], method: Function): number => {
       return i;
     }
   }
+
   return -1;
 };

package/src/utils/{compare-version.js → compare-version.ts}

@@ -1,6 +1,5 @@
 // Can't use `semver` package as Wazo version aren't in semver format
-
-const compareVersions = (a, b) => {
+const compareVersions = (a: string, b: string) => {
   let i;
   let diff;
   const regExStrip0 = /(\.0+)+$/;
@@ -10,10 +9,12 @@ const compareVersions = (a, b) => {
 
   for (i = 0; i < l; i++) {
     diff = parseInt(segmentsA[i], 10) - parseInt(segmentsB[i], 10);
+
     if (diff) {
       return diff;
     }
   }
+
   return segmentsA.length - segmentsB.length;
 };
 

package/src/utils/{isMobile.js → isMobile.ts}

@@ -1,4 +1,4 @@
-/* @flow */
 /* global navigator */
 const isMobile = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+
 export default isMobile;

package/src/utils/{new-from.js → new-from.ts}

@@ -1,10 +1,7 @@
-// @flow
-
-export default (instance: any, ToClass: any) => {
-  const args = {};
+export default ((instance: any, ToClass: any) => {
+  const args: Record<string, any> = {};
   Object.getOwnPropertyNames(instance).forEach(prop => {
     args[prop] = instance[prop];
   });
-
   return new ToClass(args);
-};
+});

package/src/utils/{object.js → object.ts}

@@ -1,15 +1,12 @@
-// @flow
-
 import { camelToUnderscore } from './string';
 
-export const convertKeysFromCamelToUnderscore = (args: Object) => {
+export const convertKeysFromCamelToUnderscore = (args: Record<string, any>) => {
   if (!args || typeof args !== 'object' || Array.isArray(args)) {
     throw new Error('Input is not an object');
   }
 
-  return Object.keys(args).reduce((acc, key) => {
-    acc[camelToUnderscore(key)] = typeof args[key] === 'object' && !Array.isArray(args[key])
-      ? convertKeysFromCamelToUnderscore(args[key]) : args[key];
+  return Object.keys(args).reduce((acc: Record<string, any>, key) => {
+    acc[camelToUnderscore(key)] = typeof args[key] === 'object' && !Array.isArray(args[key]) ? convertKeysFromCamelToUnderscore(args[key]) : args[key];
     return acc;
   }, {});
 };

package/src/utils/{once.js → once.ts}

@@ -1,14 +1,14 @@
-// @flow
 /* eslint-disable */
 // Can't use arrow function here due to `apply`
-export default function(func: ?Function) {
+export default function (func: ((...args: Array<any>) => any) | null | undefined) {
   let ran = false;
-  let memo;
-  return function() {
+  let memo: any;
+  return function () {
     if (ran) return memo;
     ran = true;
+    // @ts-ignore
     memo = func && func.apply(this, arguments);
     func = null;
     return memo;
   };
-}
+}