@wazo/sdk 0.38.22 → 0.39.0-beta.1

package/src/utils/Emitter.ts

@@ -0,0 +1,34 @@
+import EventEmitter from 'events';
+
+export interface IEmitter {
+  eventEmitter: EventEmitter;
+  on: (event: string, callback: (...args: Array<any>) => any) => void;
+  once: (event: string, callback: (...args: Array<any>) => any) => void;
+  off: (event: string, callback: (...args: Array<any>) => any) => void;
+  unbind: () => void;
+}
+
+export default class Emitter implements IEmitter {
+  eventEmitter: EventEmitter;
+
+  constructor() {
+    this.eventEmitter = new EventEmitter();
+  }
+
+  on(event: string, callback: (...args: Array<any>) => any) {
+    this.eventEmitter.on(event, callback);
+  }
+
+  once(event: string, callback: (...args: Array<any>) => any) {
+    this.eventEmitter.once(event, callback);
+  }
+
+  off(event: string, callback: (...args: Array<any>) => any) {
+    this.eventEmitter.removeListener(event, callback);
+  }
+
+  unbind() {
+    this.eventEmitter.removeAllListeners();
+  }
+
+}

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

@@ -1,36 +1,39 @@
-// @flow
-
 const DEFAULT_HEARTBEAT_DELAY = 2000;
 const DEFAULT_HEARTBEAT_TIMEOUT = 5000;
 const DEFAULT_MAX_HEARTBEATS = 3;
 
 class Heartbeat {
   heartbeatDelay: number;
+
   heartbeatTimeout: number;
+
   maxHeartbeats: number;
 
   hasHeartbeat: boolean;
-  _heartbeatDelayTimeout: ?TimeoutID;
-  _heartbeatNotReceivedTimeout: ?TimeoutID;
+
+  _heartbeatDelayTimeout: ReturnType<typeof setTimeout> | undefined;
+
+  _heartbeatNotReceivedTimeout: ReturnType<typeof setTimeout> | undefined;
+
   _heartbeatTries: number;
-  _sendHeartbeatCallback: ?Function;
-  _onTimeoutCallback: ?Function;
 
-  constructor(heartbeatDelay: number = DEFAULT_HEARTBEAT_DELAY, heartbeatTimeout: number = DEFAULT_HEARTBEAT_TIMEOUT,
-    maxHeartbeats: number = DEFAULT_MAX_HEARTBEATS) {
+  _sendHeartbeatCallback: ((...args: Array<any>) => any) | null | undefined;
+
+  _onTimeoutCallback: ((...args: Array<any>) => any) | null | undefined;
+
+  constructor(heartbeatDelay: number = DEFAULT_HEARTBEAT_DELAY, heartbeatTimeout: number = DEFAULT_HEARTBEAT_TIMEOUT, maxHeartbeats: number = DEFAULT_MAX_HEARTBEATS) {
     this.heartbeatDelay = heartbeatDelay;
     this.heartbeatTimeout = heartbeatTimeout;
     this.maxHeartbeats = maxHeartbeats;
-
     this.hasHeartbeat = false;
     this._heartbeatTries = 0;
   }
 
-  setSendHeartbeat(cb: Function) {
+  setSendHeartbeat(cb: (...args: Array<any>) => any) {
     this._sendHeartbeatCallback = cb;
   }
 
-  setOnHeartbeatTimeout(cb: Function) {
+  setOnHeartbeatTimeout(cb: (...args: Array<any>) => any) {
     this._onTimeoutCallback = cb;
   }
 
@@ -40,6 +43,7 @@ class Heartbeat {
     if (this._heartbeatNotReceivedTimeout) {
       clearTimeout(this._heartbeatNotReceivedTimeout);
     }
+
     if (this._heartbeatDelayTimeout) {
       clearTimeout(this._heartbeatDelayTimeout);
     }
@@ -49,6 +53,7 @@ class Heartbeat {
     this.stop();
     this.hasHeartbeat = true;
     this._heartbeatTries = 0;
+
     this._sendHeartbeat();
   }
 
@@ -91,6 +96,7 @@ class Heartbeat {
       clearTimeout(this._heartbeatDelayTimeout);
     }
   }
+
 }
 
 export default Heartbeat;

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

@@ -1,13 +1,14 @@
-// @flow
 import LibPhoneNumber from 'google-libphonenumber';
 
 const PhoneNumberUtil = LibPhoneNumber.PhoneNumberUtil.getInstance();
-const { PhoneNumberFormat, AsYouTypeFormatter } = LibPhoneNumber;
-
+const {
+  PhoneNumberFormat,
+  AsYouTypeFormatter,
+} = LibPhoneNumber;
 // eslint-disable-next-line
 const EXTRA_CHAR_REGEXP = /[^+*\d]/g;
 
-const shouldBeFormatted = (number: ?string) => {
+const shouldBeFormatted = (number: string | null | undefined) => {
   if (!number || number.length <= 5) {
     return false;
   }
@@ -15,7 +16,7 @@ const shouldBeFormatted = (number: ?string) => {
   return !number.includes('#') && !number.includes('*') && !number.match(/[aA-zZ]/);
 };
 
-const isSameCountry = (country1, country2) => {
+const isSameCountry = (country1: string, country2: string) => {
   if ((country1 === 'US' && country2 === 'CA') || (country2 === 'US' && country1 === 'CA')) {
     return true;
   }
@@ -23,12 +24,13 @@ const isSameCountry = (country1, country2) => {
   return country1 === country2;
 };
 
-const getDisplayableNumber = (rawNumber: string, country: string, asYouType: boolean = false): string => {
+const getDisplayableNumber = (rawNumber: string, country: string, asYouType = false): string => {
   if (!rawNumber) {
     return rawNumber;
   }
 
   const number = String(rawNumber);
+
   if (!shouldBeFormatted(number)) {
     return number;
   }
@@ -44,9 +46,7 @@ const getDisplayableNumber = (rawNumber: string, country: string, asYouType: boo
     try {
       const parsedNumber = PhoneNumberUtil.parseAndKeepRawInput(number, country);
       const numberCountry = PhoneNumberUtil.getRegionCodeForNumber(parsedNumber);
-      const format = isSameCountry(numberCountry, country) ? PhoneNumberFormat.NATIONAL
-        : PhoneNumberFormat.INTERNATIONAL;
-
+      const format = isSameCountry(String(numberCountry), country) ? PhoneNumberFormat.NATIONAL : PhoneNumberFormat.INTERNATIONAL;
       displayValue = PhoneNumberUtil.format(parsedNumber, format);
     } catch (_) {
       // Avoid to crash when phone number like `0080510` can't be parsed
@@ -59,22 +59,16 @@ const getDisplayableNumber = (rawNumber: string, country: string, asYouType: boo
 
 const parsePhoneNumber = (phoneNumber: string): string => phoneNumber.replace(EXTRA_CHAR_REGEXP, '');
 
-const getCallableNumber = (number: string, country: ?string): ?string => {
+const getCallableNumber = (number: string, country: string | null | undefined): string | null | undefined => {
   try {
     if (country) {
       return getDisplayableNumber(number, country).replace(EXTRA_CHAR_REGEXP, '');
     }
+
     return parsePhoneNumber(number);
   } catch (_) {
     return number;
   }
 };
 
-export {
-  PhoneNumberUtil,
-  PhoneNumberFormat,
-  parsePhoneNumber,
-  AsYouTypeFormatter,
-  getDisplayableNumber,
-  getCallableNumber,
-};
+export { PhoneNumberUtil, PhoneNumberFormat, parsePhoneNumber, AsYouTypeFormatter, getDisplayableNumber, getCallableNumber };

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

@@ -7,13 +7,10 @@ describe('Heartbeat', () => {
       const heartbeat = new Heartbeat(10, 50, 2);
       heartbeat.setOnHeartbeatTimeout(spy);
       heartbeat.start();
-
       await new Promise(resolve => setTimeout(resolve, 70));
-
       expect(spy).toHaveBeenCalled();
     });
   });
-
   describe('When onHearbeat is called', () => {
     it('should not call onTimeout', async () => {
       const timeout = jest.fn();
@@ -22,18 +19,14 @@ describe('Heartbeat', () => {
       heartbeat.setSendHeartbeat(sendHeartbeat);
       heartbeat.setOnHeartbeatTimeout(timeout);
       heartbeat.start();
-
       setTimeout(() => {
         heartbeat.onHeartbeat();
       }, 30);
-
       await new Promise(resolve => setTimeout(resolve, 70));
-
       expect(sendHeartbeat).toHaveBeenCalled();
       expect(timeout).not.toHaveBeenCalled();
     });
   });
-
   describe('When onHearbeat is called every times', () => {
     it('should not timeout', async () => {
       const timeout = jest.fn();
@@ -44,14 +37,11 @@ describe('Heartbeat', () => {
       heartbeat.setSendHeartbeat(sendHeartbeat);
       heartbeat.setOnHeartbeatTimeout(timeout);
       heartbeat.start();
-
       await new Promise(resolve => setTimeout(resolve, 100));
-
       expect(sendHeartbeat).toHaveBeenNthCalledWith(8);
       expect(timeout).not.toHaveBeenCalled();
     });
   });
-
   describe('When calling it twice', () => {
     it('should work like the first time', async () => {
       const timeout = jest.fn();
@@ -61,20 +51,15 @@ describe('Heartbeat', () => {
       });
       heartbeat.setSendHeartbeat(sendHeartbeat);
       heartbeat.setOnHeartbeatTimeout(timeout);
-
       // First call
       heartbeat.start();
-
       await new Promise(resolve => setTimeout(resolve, 100));
-
       expect(sendHeartbeat).toHaveBeenNthCalledWith(8);
       expect(timeout).not.toHaveBeenCalled();
-
       // Second call
       heartbeat.setSendHeartbeat(() => {});
       heartbeat.start();
       await new Promise(resolve => setTimeout(resolve, 100));
-
       expect(timeout).toHaveBeenCalled();
     });
   });

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

@@ -8,7 +8,6 @@ describe('Formatting phone numbers', () => {
     expect(getDisplayableNumber('#23445433', 'DE')).toBe('#23445433');
     expect(getDisplayableNumber('0080510', 'FR')).toBe('0080510');
   });
-
   it('should format real phone numbers', () => {
     expect(getDisplayableNumber('+33675456545', 'FR')).toBe('06 75 45 65 45');
     expect(getDisplayableNumber('0675456545', 'FR')).toBe('06 75 45 65 45');
@@ -16,7 +15,6 @@ describe('Formatting phone numbers', () => {
     expect(getDisplayableNumber('0675456545', 'US')).toBe('+1 0675456545');
     expect(getDisplayableNumber('4188884356', 'US')).toBe('(418) 888-4356');
   });
-
   it('should format real phone numbers when typing', () => {
     expect(getDisplayableNumber('+3367545', 'FR', true)).toBe('+33 6 75 45');
     expect(getDisplayableNumber('067545', 'FR', true)).toBe('06 75 45');
@@ -24,7 +22,6 @@ describe('Formatting phone numbers', () => {
     expect(getDisplayableNumber('067545', 'US', true)).toBe('067545');
     expect(getDisplayableNumber('418808', 'US', true)).toBe('418-808');
   });
-
   it('should use the international number if the country number is different from the given country', () => {
     expect(getDisplayableNumber('00201005803648', 'FR')).toBe('+20 100 580 3648');
     expect(getDisplayableNumber('+14188004554', 'FR')).toBe('+1 418-800-4554');
@@ -35,7 +32,6 @@ describe('Formatting phone numbers', () => {
     expect(getDisplayableNumber('8775863230', 'US')).toBe('(877) 586-3230');
   });
 });
-
 describe('getCallableNumber', () => {
   it('works with a country', () => {
     expect(getCallableNumber('+33 6 75 45 12 34', 'FR')).toBe('0675451234');
@@ -48,11 +44,17 @@ describe('getCallableNumber', () => {
     expect(getCallableNumber('9000', 'US')).toBe('9000');
   });
   it('works without a country', () => {
+    // @ts-expect-error
     expect(getCallableNumber('06 75 45')).toBe('067545');
+    // @ts-expect-error
     expect(getCallableNumber('067-545')).toBe('067545');
+    // @ts-expect-error
     expect(getCallableNumber('8008')).toBe('8008');
+    // @ts-expect-error
     expect(getCallableNumber('80.08')).toBe('8008');
+    // @ts-expect-error
     expect(getCallableNumber('*10')).toBe('*10');
+    // @ts-expect-error
     expect(getCallableNumber('9000')).toBe('9000');
   });
 });

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

@@ -3,7 +3,9 @@ import ApiRequester from '../api-requester';
 const server = 'localhost';
 const path = 'auth';
 const method = 'get';
-const body = { a: 1 };
+const body = {
+  a: 1,
+};
 const url = `https://${server}/api/${path}?a=1`;
 const token = 'abc';
 const newToken = 'newToken';
@@ -15,18 +17,36 @@ const headers = {
 
 describe('Generating query string', () => {
   it('should generate a simple query string from an object', () => {
-    expect(ApiRequester.getQueryString({ a: 1, b: 'someString' })).toBe('a=1&b=someString');
-    expect(ApiRequester.getQueryString({ bool: true, b: 'booléen' })).toBe('bool=true&b=bool%C3%A9en');
-    expect(ApiRequester.getQueryString({ nope: undefined, b: 'yep' })).toBe('b=yep');
+    expect(ApiRequester.getQueryString({
+      a: 1,
+      b: 'someString',
+    })).toBe('a=1&b=someString');
+    expect(ApiRequester.getQueryString({
+      bool: true,
+      b: 'booléen',
+    })).toBe('bool=true&b=bool%C3%A9en');
+    expect(ApiRequester.getQueryString({
+      nope: undefined,
+      b: 'yep',
+    })).toBe('b=yep');
   });
 });
 
 describe('Computing fetch URL', () => {
   it('should add query string to URL in get method with body', () => {
-    const client = new ApiRequester({ server: 'localhost' });
-
-    expect(client.computeUrl('get', 'auth', { a: 1 })).toBe('https://localhost/api/auth?a=1');
-    expect(client.computeUrl('post', 'auth', { a: 1 })).toBe('https://localhost/api/auth');
+    const client = new ApiRequester({
+      server: 'localhost',
+      agent: null,
+      clientId: null,
+      refreshTokenCallback: () => null,
+      fetchOptions: null,
+    });
+    expect(client.computeUrl('get', 'auth', {
+      a: 1,
+    })).toBe('https://localhost/api/auth?a=1');
+    expect(client.computeUrl('post', 'auth', {
+      a: 1,
+    })).toBe('https://localhost/api/auth');
     expect(client.computeUrl('get', 'auth', null)).toBe('https://localhost/api/auth');
     expect(client.computeUrl('get', 'auth', {})).toBe('https://localhost/api/auth');
   });
@@ -35,23 +55,33 @@ describe('Computing fetch URL', () => {
 describe('Retrieving headers', () => {
   it('should send a tenant if exists', () => {
     const tenant = 'abc234';
-
-    const requester = new ApiRequester({ server });
+    const requester = new ApiRequester({
+      server,
+      agent: null,
+      clientId: null,
+      refreshTokenCallback: () => null,
+      fetchOptions: null,
+    });
     requester.setTenant(tenant);
-
-    expect(requester.getHeaders()['Wazo-Tenant']).toBe(tenant);
+    expect(requester.getHeaders(null)['Wazo-Tenant']).toBe(tenant);
   });
 
   it('should not send a tenant if not present', () => {
-    const requester = new ApiRequester({ server });
-
-    expect(requester.getHeaders()).not.toHaveProperty('Wazo-Tenant');
+    const requester = new ApiRequester({
+      server,
+      agent: null,
+      clientId: null,
+      refreshTokenCallback: () => null,
+      fetchOptions: null,
+    });
+    expect(requester.getHeaders(null)).not.toHaveProperty('Wazo-Tenant');
   });
 });
-
 describe('Calling fetch', () => {
   it('should call fetch without body but query string in get method', async () => {
     jest.mock('node-fetch/lib/index', () => {});
+
+    // @ts-ignore
     global.fetch = jest.fn(() => Promise.resolve({
       json: () => Promise.resolve({}),
       headers: {
@@ -59,8 +89,20 @@ describe('Calling fetch', () => {
       },
     }));
 
-    await new ApiRequester({ server }).call(path, method, body, {});
-    expect(global.fetch).toBeCalledWith(url, { method: 'get', body: null, headers: {}, agent: null });
+    await new ApiRequester({
+      server,
+      agent: null,
+      clientId: null,
+      refreshTokenCallback: () => null,
+      fetchOptions: null,
+    }).call(path, method, body, {});
+
+    expect(global.fetch).toBeCalledWith(url, {
+      method: 'get',
+      body: null,
+      headers: {},
+      agent: null,
+    });
   });
 });
 
@@ -68,6 +110,7 @@ describe('With a refresh token', () => {
   it('should retry the call with a new token', async () => {
     jest.mock('node-fetch/lib/index', () => {});
     let calls = 0;
+    // @ts-ignore
     global.fetch = jest.fn(() => {
       calls++;
       return Promise.resolve({
@@ -78,13 +121,18 @@ describe('With a refresh token', () => {
         json: () => Promise.resolve({}),
       });
     });
-
-    const requester = new ApiRequester({ server });
+    const requester = new ApiRequester({
+      server,
+      agent: null,
+      clientId: null,
+      refreshTokenCallback: () => null,
+      fetchOptions: null,
+    });
     requester.token = token;
 
     requester.refreshTokenCallback = () => {
       requester.token = newToken;
-      return new Promise(resolve => resolve());
+      return new Promise(resolve => resolve(null));
     };
 
     const updatedHeaders = {
@@ -92,10 +140,13 @@ describe('With a refresh token', () => {
       'Content-Type': 'application/json',
       'X-Auth-Token': newToken,
     };
-
     await requester.call(path, method, body, null);
-
-    expect(global.fetch).toHaveBeenNthCalledWith(1, url, { method: 'get', body: null, headers, agent: null });
+    expect(global.fetch).toHaveBeenNthCalledWith(1, url, {
+      method: 'get',
+      body: null,
+      headers,
+      agent: null,
+    });
     expect(global.fetch).toHaveBeenNthCalledWith(2, url, {
       method: 'get',
       body: null,

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

@@ -1,8 +1,16 @@
 import { lastIndexOf } from '../array';
 
 describe('Finding last index of an array of object', () => {
-  const array = [{ a: 1, b: 3 }, { a: 1, b: 2 }, { a: 1, b: 3 }];
-
+  const array = [{
+    a: 1,
+    b: 3,
+  }, {
+    a: 1,
+    b: 2,
+  }, {
+    a: 1,
+    b: 3,
+  }];
   it('should compare non semver versions', () => {
     expect(lastIndexOf(array, elem => elem.a === 1 && elem.b === 3)).toBe(2);
     expect(lastIndexOf(array, elem => elem.a === 1)).toBe(2);

package/src/utils/__tests__/object.test.ts

@@ -0,0 +1,77 @@
+import { convertKeysFromCamelToUnderscore } from '../object';
+
+describe('object utils', () => {
+  describe('convertKeysFromCamelToUnderscore', () => {
+    it('should throw an error when input is not an object', () => {
+      const msg = 'Input is not an object';
+      // @ts-expect-error
+      expect(() => convertKeysFromCamelToUnderscore(true)).toThrow(msg);
+      // @ts-expect-error
+      expect(() => convertKeysFromCamelToUnderscore(null)).toThrow(msg);
+      // @ts-expect-error
+      expect(() => convertKeysFromCamelToUnderscore(undefined)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore([])).toThrow(msg);
+      // @ts-expect-error
+      expect(() => convertKeysFromCamelToUnderscore('some-string')).toThrow(msg);
+    });
+    it('should convert camel-cased keys to underscore', () => {
+      let value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({
+        LoremIpsum: value,
+      })).toEqual({
+        lorem_ipsum: value,
+      });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({
+        loremIpsum: value,
+      })).toEqual({
+        lorem_ipsum: value,
+      });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({
+        'lorem-ipsum': value,
+      })).toEqual({
+        'lorem-ipsum': value,
+      });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({
+        L123: value,
+      })).toEqual({
+        l123: value,
+      });
+    });
+    it('should handle multi-leveled object', () => {
+      const value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({
+        LoremIpsum: {
+          DoloreSit: {
+            Amet: value,
+          },
+          regular: 'reg',
+        },
+      })).toEqual({
+        lorem_ipsum: {
+          dolore_sit: {
+            amet: value,
+          },
+          regular: 'reg',
+        },
+      });
+      expect(convertKeysFromCamelToUnderscore({
+        LoremIpsum: {
+          DoloreSit: {
+            Amet: [value],
+          },
+          regular: ['something'],
+        },
+      })).toEqual({
+        lorem_ipsum: {
+          dolore_sit: {
+            amet: [value],
+          },
+          regular: ['something'],
+        },
+      });
+    });
+  });
+});