@wazo/sdk 0.43.14 → 0.44.0

package/src/utils/Emitter.ts

@@ -1,34 +0,0 @@
-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.ts

@@ -1,102 +0,0 @@
-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: NodeJS.Timeout | string | number | undefined;
-
-  _heartbeatNotReceivedTimeout: NodeJS.Timeout | string | number | undefined;
-
-  _heartbeatTries: number;
-
-  _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: (...args: Array<any>) => any) {
-    this._sendHeartbeatCallback = cb;
-  }
-
-  setOnHeartbeatTimeout(cb: (...args: Array<any>) => any) {
-    this._onTimeoutCallback = cb;
-  }
-
-  stop() {
-    this.hasHeartbeat = false;
-
-    if (this._heartbeatNotReceivedTimeout) {
-      clearTimeout(this._heartbeatNotReceivedTimeout);
-    }
-
-    if (this._heartbeatDelayTimeout) {
-      clearTimeout(this._heartbeatDelayTimeout);
-    }
-  }
-
-  start() {
-    this.stop();
-    this.hasHeartbeat = true;
-    this._heartbeatTries = 0;
-
-    this._sendHeartbeat();
-  }
-
-  onHeartbeat() {
-    this._clearTimeouts();
-
-    if (!this.hasHeartbeat) {
-      return;
-    }
-
-    this._sendHeartbeat();
-  }
-
-  _sendHeartbeat() {
-    if (this._heartbeatTries >= this.maxHeartbeats) {
-      return;
-    }
-
-    this._clearTimeouts();
-
-    this._heartbeatDelayTimeout = setTimeout(() => {
-      this._heartbeatTries++;
-
-      if (this._sendHeartbeatCallback) {
-        this._sendHeartbeatCallback();
-      }
-    }, this.heartbeatDelay);
-
-    if (this._onTimeoutCallback) {
-      this._heartbeatNotReceivedTimeout = setTimeout(this._onTimeoutCallback, this.heartbeatTimeout);
-    }
-  }
-
-  _clearTimeouts() {
-    if (this._heartbeatNotReceivedTimeout) {
-      clearTimeout(this._heartbeatNotReceivedTimeout);
-    }
-
-    if (this._heartbeatDelayTimeout) {
-      clearTimeout(this._heartbeatDelayTimeout);
-    }
-  }
-
-}
-
-export default Heartbeat;

package/src/utils/PhoneNumberUtil.ts

@@ -1,81 +0,0 @@
-import { AsYouType, parsePhoneNumber as libParsePhoneNumber, CountryCode } from 'libphonenumber-js';
-
-// eslint-disable-next-line
-const EXTRA_CHAR_REGEXP = /[^+*\d]/g;
-const DEFAULT_GUESSING_COUNTRIES: CountryCode[] = ['US', 'FR', 'GB', 'AU'];
-
-const shouldBeFormatted = (number: string | null | undefined) => {
-  if (!number || number.length <= 5) {
-    return false;
-  }
-
-  return !number.includes('#') && !number.includes('*') && !number.match(/[aA-zZ]/);
-};
-
-const isSameCountry = (country1: string, country2: string) => {
-  if ((country1 === 'US' && country2 === 'CA') || (country2 === 'US' && country1 === 'CA')) {
-    return true;
-  }
-
-  return country1 === country2;
-};
-
-const guessParsePhoneNumber = (number: string, defaultCountry?: CountryCode, guessingCountries: CountryCode[] = DEFAULT_GUESSING_COUNTRIES) => {
-  const mergedCountries = [...new Set([defaultCountry, ...guessingCountries])].filter(Boolean) as CountryCode[];
-
-  let parsedNumber;
-  for (let i = 0; i < mergedCountries.length; i++) {
-    const country = mergedCountries[i];
-
-    parsedNumber = libParsePhoneNumber(number, country);
-    if (parsedNumber.isValid()) {
-      break;
-    }
-  }
-
-  return parsedNumber;
-};
-
-const getDisplayableNumber = (rawNumber: string, country: CountryCode, asYouType = false, guessingCountries: CountryCode[] | undefined = DEFAULT_GUESSING_COUNTRIES): string => {
-  if (!rawNumber) {
-    return rawNumber;
-  }
-
-  const number = String(rawNumber);
-
-  if (!shouldBeFormatted(number)) {
-    return number;
-  }
-
-  let displayValue = '';
-
-  if (asYouType) {
-    displayValue = new AsYouType(country).input(number);
-  } else {
-    try {
-      const parsedNumber = guessParsePhoneNumber(number, country, guessingCountries);
-      if (parsedNumber?.isValid()) {
-        displayValue = isSameCountry(String(parsedNumber.country), country) ? parsedNumber.formatNational() : parsedNumber.formatInternational();
-      } else {
-        displayValue = rawNumber;
-      }
-    } catch (error) {
-      displayValue = rawNumber;
-    }
-  }
-
-  return displayValue;
-};
-
-const parsePhoneNumber = (phoneNumber: string): string => phoneNumber.replace(EXTRA_CHAR_REGEXP, '');
-
-const getCallableNumber = (number: string, country?: CountryCode): string => {
-  try {
-    const callableNumber = country ? getDisplayableNumber(number, country) : number;
-    return parsePhoneNumber(callableNumber);
-  } catch (_) {
-    return number;
-  }
-};
-
-export { parsePhoneNumber, getDisplayableNumber, guessParsePhoneNumber, getCallableNumber, type CountryCode };

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

@@ -1,66 +0,0 @@
-import Heartbeat from '../Heartbeat';
-
-describe('Heartbeat', () => {
-  describe('When onHearbeat is not called', () => {
-    it('should retry the call with a new token', async () => {
-      const spy = jest.fn();
-      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();
-      const sendHeartbeat = jest.fn();
-      const heartbeat = new Heartbeat(10, 50, 2);
-      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();
-      const heartbeat = new Heartbeat(5, 50, 8);
-      const sendHeartbeat = jest.fn(() => {
-        heartbeat.onHeartbeat();
-      });
-      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();
-      const heartbeat = new Heartbeat(5, 50, 8);
-      const sendHeartbeat = jest.fn(() => {
-        heartbeat.onHeartbeat();
-      });
-      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.ts

@@ -1,79 +0,0 @@
-import { getDisplayableNumber, getCallableNumber, guessParsePhoneNumber } from '../PhoneNumberUtil';
-
-describe('Formatting phone numbers', () => {
-  it('should not format all phone numbers', () => {
-    expect(getDisplayableNumber('*143450', 'FR')).toBe('*143450');
-    expect(getDisplayableNumber('*10', 'US')).toBe('*10');
-    expect(getDisplayableNumber('Wazo Fax', 'US')).toBe('Wazo Fax');
-    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');
-    expect(getDisplayableNumber('+33675456545', 'US')).toBe('+33 6 75 45 65 45');
-    expect(getDisplayableNumber('0675456545', 'US')).toBe('+33 6 75 45 65 45');
-    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');
-    expect(getDisplayableNumber('+3367545', 'US', true)).toBe('+33 6 75 45');
-    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 10 05803648');
-    expect(getDisplayableNumber('+14188004554', 'FR')).toBe('+1 418 800 4554');
-    expect(getDisplayableNumber('00201005803648', 'EG')).toBe('010 05803648');
-    expect(getDisplayableNumber('0634543450', 'FR')).toBe('06 34 54 34 50');
-    expect(getDisplayableNumber('4188034302', 'US')).toBe('(418) 803-4302');
-    expect(getDisplayableNumber('8775863230', 'CA')).toBe('(877) 586-3230');
-    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');
-    expect(getCallableNumber('06 75 45 12 34', 'FR')).toBe('0675451234');
-    expect(getCallableNumber('+1-202-555-0147', 'US')).toBe('2025550147');
-    expect(getCallableNumber('202-555-0113', 'US')).toBe('2025550113');
-    expect(getCallableNumber('8008', 'US')).toBe('8008');
-    expect(getCallableNumber('80.08', 'US')).toBe('8008');
-    expect(getCallableNumber('*10', 'US')).toBe('*10');
-    expect(getCallableNumber('9000', 'US')).toBe('9000');
-  });
-
-  it('works without a country', () => {
-    expect(getCallableNumber('06 75 45')).toBe('067545');
-    expect(getCallableNumber('067-545')).toBe('067545');
-    expect(getCallableNumber('8008')).toBe('8008');
-    expect(getCallableNumber('80.08')).toBe('8008');
-    expect(getCallableNumber('*10')).toBe('*10');
-    expect(getCallableNumber('9000')).toBe('9000');
-  });
-});
-
-describe('guessParsePhoneNumber', () => {
-  it('should guess with default countries', () => {
-    const parsedNumber = guessParsePhoneNumber('0675456545');
-    expect(parsedNumber?.country).toBe('FR');
-    expect(parsedNumber?.isValid()).toBe(true);
-  });
-
-  it('should guess with specified countries', () => {
-    const parsedNumber = guessParsePhoneNumber('752097514', undefined, ['JP']);
-    expect(parsedNumber?.country).toBe('JP');
-    expect(parsedNumber?.isValid()).toBe(true);
-  });
-
-  it('should used use defaultCountry has guesser', () => {
-    const parsedNumber = guessParsePhoneNumber('752097514', 'JP', []);
-    expect(parsedNumber?.country).toBe('JP');
-    expect(parsedNumber?.isValid()).toBe(true);
-  });
-});

package/src/utils/__tests__/api-requester.test.ts

@@ -1,180 +0,0 @@
-import ApiRequester from '../api-requester';
-
-const server = 'localhost';
-const path = 'auth';
-const method = 'get';
-const body = {
-  a: 1,
-};
-const url = `https://${server}/api/${path}?a=1`;
-const token = 'abc';
-const newToken = 'newToken';
-const headers = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json',
-  'X-Auth-Token': token,
-};
-
-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');
-  });
-});
-
-describe('Computing fetch URL', () => {
-  it('should add query string to URL in get method with body', () => {
-    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');
-  });
-});
-
-describe('Retrieving headers', () => {
-  it('should send a tenant if exists', () => {
-    const tenant = 'abc234';
-    const requester = new ApiRequester({
-      server,
-      agent: null,
-      clientId: null,
-      refreshTokenCallback: () => null,
-      fetchOptions: null,
-    });
-    requester.setTenant(tenant);
-    expect(requester.getHeaders(null)['Wazo-Tenant']).toBe(tenant);
-  });
-
-  it('should not send a tenant if not present', () => {
-    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 () => {
-    Object.defineProperty(global, 'fetch', {
-      value: jest.fn(() => Promise.resolve({
-        json: () => Promise.resolve({}),
-        headers: {
-          get: () => '',
-        },
-      }) as any),
-    });
-
-    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,
-      signal: expect.any(Object),
-      headers: {},
-      agent: null,
-    });
-  });
-});
-
-describe('With a refresh token', () => {
-  it('should retry the call with a new token', async () => {
-    let calls = 0;
-    Object.defineProperty(global, 'fetch', {
-      value: jest.fn(() => {
-        calls++;
-        return Promise.resolve({
-          headers: {
-            get: () => 'application/json',
-          },
-          status: calls === 1 ? 401 : 200,
-          json: () => Promise.resolve({}),
-        } as any);
-      }),
-    });
-
-    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(null));
-    };
-
-    const updatedHeaders = {
-      Accept: 'application/json',
-      '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,
-      signal: expect.any(Object),
-      headers,
-      agent: null,
-    });
-    expect(global.fetch).toHaveBeenNthCalledWith(2, url, {
-      method: 'get',
-      body: null,
-      signal: expect.any(Object),
-      headers: updatedHeaders,
-      agent: null,
-    });
-  });
-});
-
-describe('base64Encode', () => {
-  it('should encode a string using base64', () => {
-    const input = 'Hello World!';
-    const expectedOutput = 'SGVsbG8gV29ybGQh';
-    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
-  });
-
-  it('should handle special characters', () => {
-    const input = 'éà$@€';
-    const expectedOutput = 'w6nDoCRA4oKs';
-    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
-  });
-
-  it('should handle empty string', () => {
-    const input = '';
-    const expectedOutput = '';
-    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
-  });
-});

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

@@ -1,19 +0,0 @@
-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,
-  }];
-  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);
-    expect(lastIndexOf(array, elem => elem.a === 4)).toBe(-1);
-  });
-});

package/src/utils/__tests__/compare-version.test.ts

@@ -1,11 +0,0 @@
-import compareVersions from '../compare-version';
-
-describe('Comparing versions', () => {
-  it('should compare non semver versions', () => {
-    expect(compareVersions('1.0', '1.0')).toBe(0);
-    expect(compareVersions('0.10', '0.9')).toBeGreaterThan(0);
-    expect(compareVersions('0.10', '0.11')).toBeLessThan(0);
-    expect(compareVersions('0.10', '0.1')).toBeGreaterThan(0);
-    expect(compareVersions('19.10', '19.1')).toBeGreaterThan(0);
-  });
-});

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

@@ -1,77 +0,0 @@
-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'],
-        },
-      });
-    });
-  });
-});