@wazo/sdk 0.38.21 → 0.39.0-beta.1

package/src/service/{IssueReporter.js → IssueReporter.ts}

@@ -1,8 +1,7 @@
 /* global window */
+
 /* eslint-disable prefer-destructuring, no-param-reassign, no-underscore-dangle */
-// @flow
 import moment from 'moment';
-
 import { realFetch } from '../utils/api-requester';
 import isMobile from '../utils/isMobile';
 
@@ -15,10 +14,9 @@ const ERROR = 'error';
 const CONSOLE_METHODS = [INFO, LOG, WARN, ERROR];
 const LOG_LEVELS = [TRACE, DEBUG, INFO, LOG, WARN, ERROR];
 const CATEGORY_PREFIX = 'logger-category=';
-
 const MAX_REMOTE_RETRY = 100;
 
-const addLevelsTo = (instance: Object, withMethods = false) => {
+const addLevelsTo = (instance: Record<string, any>, withMethods = false) => {
   instance.TRACE = TRACE;
   instance.DEBUG = DEBUG;
   instance.INFO = INFO;
@@ -27,23 +25,28 @@ const addLevelsTo = (instance: Object, withMethods = false) => {
   instance.ERROR = ERROR;
 
   if (withMethods) {
-    instance.trace = (...args) => instance.apply(null, [TRACE, ...args]);
-    instance.debug = (...args) => instance.apply(null, [DEBUG, ...args]);
-    instance.info = (...args) => instance.apply(null, [INFO, ...args]);
-    instance.log = (...args) => instance.apply(null, [LOG, ...args]);
-    instance.warn = (...args) => instance.apply(null, [WARN, ...args]);
-    instance.error = (...args) => instance.apply(null, [ERROR, ...args]);
+    instance.trace = (...args: any) => instance.apply(null, [TRACE, ...args]);
+
+    instance.debug = (...args: any) => instance.apply(null, [DEBUG, ...args]);
+
+    instance.info = (...args: any) => instance.apply(null, [INFO, ...args]);
+
+    instance.log = (...args: any) => instance.apply(null, [LOG, ...args]);
+
+    instance.warn = (...args: any) => instance.apply(null, [WARN, ...args]);
+
+    instance.error = (...args: any) => instance.apply(null, [ERROR, ...args]);
   }
 
   return instance;
 };
 
-const safeStringify = (object: Object) => {
+const safeStringify = (object: Record<string, any>) => {
   const result = '{"message": "Not parsable JSON"}';
+
   try {
     return JSON.stringify(object);
-  } catch (e) {
-    // Nothing to do
+  } catch (e: any) { // Nothing to do
   }
 
   return result;
@@ -51,24 +54,33 @@ const safeStringify = (object: Object) => {
 
 class IssueReporter {
   TRACE: string;
+
   INFO: string;
+
   LOG: string;
+
   WARN: string;
+
   ERROR: string;
 
-  oldConsoleMethods: Object;
+  oldConsoleMethods: Record<string, any> | null;
+
   enabled: boolean;
-  remoteClientConfiguration: ?Object;
 
-  buffer: Object[];
-  bufferTimeout: ?TimeoutID;
-  _boundProcessBuffer: Function;
-  _boundParseLoggerBody: Function;
-  _callback: ?Function;
+  remoteClientConfiguration: Record<string, any> | null | undefined;
+
+  buffer: Record<string, any>[];
+
+  bufferTimeout: any | null | undefined;
+
+  _boundProcessBuffer: (...args: Array<any>) => any;
+
+  _boundParseLoggerBody: (...args: Array<any>) => any;
+
+  _callback: ((...args: Array<any>) => any) | null | undefined;
 
   constructor() {
     addLevelsTo(this);
-
     this.oldConsoleMethods = null;
     this.enabled = false;
     this.remoteClientConfiguration = null;
@@ -83,11 +95,17 @@ class IssueReporter {
     this._catchConsole();
   }
 
-  setCallback(cb: Function) {
+  setCallback(cb: (...args: Array<any>) => any) {
     this._callback = cb;
   }
 
-  configureRemoteClient(configuration: Object = { tag: 'wazo-sdk', host: null, port: null, level: null, extra: {} }) {
+  configureRemoteClient(configuration: Record<string, any> = {
+    tag: 'wazo-sdk',
+    host: null,
+    port: null,
+    level: null,
+    extra: {},
+  }) {
     this.remoteClientConfiguration = configuration;
   }
 
@@ -123,7 +141,8 @@ class IssueReporter {
     // Handle category label
     let category = null;
     let skipSendToRemote = false;
-    let extra = {};
+    let extra: any = {};
+
     if (args[0].indexOf(CATEGORY_PREFIX) === 0) {
       category = args[0].split('=')[1];
       // eslint-disable-next-line no-param-reassign
@@ -132,17 +151,20 @@ class IssueReporter {
 
     // Handle extra data as object for the last argument
     const lastArg = args[args.length - 1];
+
     if (lastArg && ((typeof lastArg === 'object' && Object.keys(lastArg).length) || lastArg instanceof Error)) {
       if (lastArg instanceof Error) {
         extra = {
           errorMessage: lastArg.message,
           errorStack: lastArg.stack,
           errorType: lastArg.constructor.name,
+          // @ts-ignore
           skipSendToRemote: lastArg.skipSendToRemote,
         };
       } else {
         extra = lastArg;
       }
+
       // eslint-disable-next-line no-param-reassign
       args.splice(1, 1);
     }
@@ -167,9 +189,8 @@ class IssueReporter {
 
     // Log the message in the console anyway (but don't console.error on mobile)
     const consoleLevel = isMobile() && level === 'error' ? WARN : level;
-
     // eslint-disable-next-line
-    const oldMethod = this.oldConsoleMethods[consoleLevel] || this.oldConsoleMethods.log;
+    const oldMethod = this.oldConsoleMethods?.[consoleLevel] || this.oldConsoleMethods?.log;
     oldMethod.apply(oldMethod, [date, consoleMessage]);
 
     if (this._callback) {
@@ -177,18 +198,27 @@ class IssueReporter {
     }
 
     if (!skipSendToRemote) {
-      this._sendToRemoteLogger(level, { date, message, category, ...extra });
+      this._sendToRemoteLogger(level, {
+        date,
+        message,
+        category,
+        ...extra,
+      });
     }
   }
 
-  logRequest(url: string, options: Object, response: Object, start: Date) {
+  logRequest(url: string, options: Record<string, any>, response: Record<string, any>, start: Date) {
     if (!this.enabled) {
       return;
     }
-    const { status } = response;
-    const duration = new Date() - start;
 
+    const {
+      status,
+    } = response;
+
+    const duration = +(new Date()) - +start;
     let level = TRACE;
+
     if (status >= 400 && status < 500) {
       level = WARN;
     } else if (status >= 500) {
@@ -222,27 +252,36 @@ class IssueReporter {
   _catchConsole() {
     this.oldConsoleMethods = {};
     CONSOLE_METHODS.forEach((methodName: string) => {
-      // eslint-disable-next-line
-      this.oldConsoleMethods[methodName] = console[methodName];
-      window.console[methodName] = (...args) => {
+      if (this.oldConsoleMethods) {
+        // @ts-ignore
+        // eslint-disable-next-line
+        this.oldConsoleMethods[methodName] = console[methodName];
+      }
+      const parent:any = typeof window !== 'undefined' ? window : global;
+      parent.console[methodName] = (...args: any) => {
         // Store message
         try {
           this.log(methodName, args.join(' '));
-          // Use old console method to log it normally
-          this.oldConsoleMethods[methodName].apply(null, args);
-        } catch (e) {
-          // Avoid circular structure issues
+          if (this.oldConsoleMethods) {
+            // Use old console method to log it normally
+            this.oldConsoleMethods[methodName].apply(null, args);
+          }
+        } catch (e: any) { // Avoid circular structure issues
         }
       };
     });
   }
 
-  _sendToRemoteLogger(level: string, payload: Object = {}) {
+  _sendToRemoteLogger(level: string, payload: Record<string, any> = {}) {
     if (!this.remoteClientConfiguration) {
       return;
     }
 
-    const { level: minLevel, bufferSize } = this.remoteClientConfiguration;
+    const {
+      level: minLevel,
+      bufferSize,
+    } = this.remoteClientConfiguration;
+
     if (!minLevel || this._isLevelAbove(minLevel, level)) {
       return;
     }
@@ -256,10 +295,14 @@ class IssueReporter {
     this._sendDebugToGrafana(payload);
   }
 
-  _parseLoggerBody(payload: Object) {
-    const { level } = payload;
-    const { maxMessageSize, extra } = this.remoteClientConfiguration || {};
-
+  _parseLoggerBody(payload: Record<string, any>) {
+    const {
+      level,
+    } = payload;
+    const {
+      maxMessageSize,
+      extra,
+    } = this.remoteClientConfiguration || {};
     delete payload.level;
 
     if (maxMessageSize && typeof payload.message === 'string' && payload.message.length > maxMessageSize) {
@@ -273,7 +316,7 @@ class IssueReporter {
     });
   }
 
-  _addToBuffer(payload: Object) {
+  _addToBuffer(payload: Record<string, any>) {
     // Reset buffer timer
     if (this.bufferTimeout) {
       clearTimeout(this.bufferTimeout);
@@ -282,8 +325,10 @@ class IssueReporter {
 
     this.buffer.push(payload);
 
-    // $FlowFixMe
-    const { bufferSize, bufferTimeout } = this.remoteClientConfiguration;
+    const {
+      bufferSize,
+      bufferTimeout,
+    }: any = this.remoteClientConfiguration;
 
     if (this.buffer.length > bufferSize) {
       return this._processBuffer();
@@ -298,22 +343,27 @@ class IssueReporter {
     this._sendDebugToGrafana(this.buffer);
 
     this.buffer = [];
+
     if (this.bufferTimeout) {
       clearTimeout(this.bufferTimeout);
       this.bufferTimeout = null;
     }
   }
 
-  _sendDebugToGrafana(payload: Object | Object[], retry: number = 0) {
+  _sendDebugToGrafana(payload: string | Record<string, any> | Record<string, any>[], retry = 0) {
     if (!this.remoteClientConfiguration || retry >= MAX_REMOTE_RETRY) {
       return;
     }
 
-    const { tag, host, port } = this.remoteClientConfiguration;
-    const isArray = Array.isArray(payload);
+    const {
+      tag,
+      host,
+      port,
+    } = this.remoteClientConfiguration;
+
     const isSecure = +port === 443;
     const url = `http${isSecure ? 's' : ''}://${host}${isSecure ? '' : `:${port}`}/${tag}`;
-    const body = isArray ? `[${payload.map(this._boundParseLoggerBody).join(',')}]` : this._parseLoggerBody(payload);
+    const body = Array.isArray(payload) ? `[${payload.map(this._boundParseLoggerBody).join(',')}]` : this._parseLoggerBody(payload as Record<string, any>);
 
     realFetch()(url, {
       method: 'POST',
@@ -321,15 +371,13 @@ class IssueReporter {
         Accept: 'application/json',
         'Content-Type': 'application/json',
       },
-      // $FlowFixMe
       body,
     }).catch((e: Error) => {
-      // $FlowFixMe
+      // @ts-ignore
       e.skipSendToRemote = true;
       this.log('error', this._makeCategory('grafana'), 'Sending log to grafana, error', e);
-
       setTimeout(() => {
-        if (isArray) {
+        if (Array.isArray(payload)) {
           payload = payload.map(message => this._writeRetryCount(message, retry + 1));
         } else if (payload && typeof payload === 'object') {
           payload = this._writeRetryCount(payload, retry + 1);
@@ -340,9 +388,8 @@ class IssueReporter {
     });
   }
 
-  _writeRetryCount(message: string | Object, count: number): string | Object {
+  _writeRetryCount(message: string | Record<string, any>, count: number): string | Record<string, any> {
     if (message && typeof message === 'object') {
-      // $FlowFixMe
       message._retry = count;
     }
 
@@ -352,6 +399,7 @@ class IssueReporter {
   _isLevelAbove(level1: string, level2: string) {
     const index1 = LOG_LEVELS.indexOf(level1);
     const index2 = LOG_LEVELS.indexOf(level2);
+
     if (index1 === -1 || index2 === -1) {
       return false;
     }
@@ -362,6 +410,7 @@ class IssueReporter {
   _makeCategory(category: string) {
     return `${CATEGORY_PREFIX}${category}`;
   }
+
 }
 
 export default new IssueReporter();

package/src/service/__tests__/{IssueReporter.test.js → IssueReporter.test.ts}

@@ -1,13 +1,14 @@
 /* eslint-disable no-underscore-dangle */
+
 /* eslint-disable no-useless-escape */
+
 /* eslint-disable no-console */
 import IssueReporter from '../IssueReporter';
 import { realFetch } from '../../utils/api-requester';
 
 jest.mock('../../utils/api-requester');
-
-let oldLog;
-let oldError;
+let oldLog: any;
+let oldError: any;
 
 class MyError extends Error {}
 
@@ -17,24 +18,22 @@ describe('IssueReporter', () => {
     oldError = console.error;
 
     console.log = () => {};
+
     console.error = () => {};
 
     IssueReporter.enable();
   });
-
   beforeEach(() => {
     jest.resetAllMocks();
-
+    // @ts-expect-error
     realFetch.mockImplementation(() => () => ({
       catch: () => {},
     }));
   });
-
   afterAll(() => {
     console.log = oldLog;
     console.error = oldError;
   });
-
   it('should compute level order', () => {
     expect(IssueReporter._isLevelAbove('info', 'trace')).toBeTruthy();
     expect(IssueReporter._isLevelAbove('trace', 'warn')).toBeFalsy();
@@ -44,33 +43,41 @@ describe('IssueReporter', () => {
     expect(IssueReporter._isLevelAbove('trace', 'something')).toBeFalsy();
     expect(IssueReporter._isLevelAbove('something', 'trace')).toBeFalsy();
   });
-
   it('should send if verbosity is higher than required', () => {
     // Same level
-    IssueReporter.configureRemoteClient({ level: 'trace' });
+    IssueReporter.configureRemoteClient({
+      level: 'trace',
+    });
+
     IssueReporter._sendToRemoteLogger('info');
+
     expect(realFetch).toHaveBeenCalled();
   });
-
   it('should send if verbosity is equal than required', () => {
     // Same level
-    IssueReporter.configureRemoteClient({ level: 'trace' });
+    IssueReporter.configureRemoteClient({
+      level: 'trace',
+    });
+
     IssueReporter._sendToRemoteLogger('trace');
+
     expect(realFetch).toHaveBeenCalled();
   });
-
   it('should not send if verbosity is lower than required', () => {
     // Lower level
-    IssueReporter.configureRemoteClient({ level: 'info' });
+    IssueReporter.configureRemoteClient({
+      level: 'info',
+    });
+
     IssueReporter._sendToRemoteLogger('trace');
+
     expect(realFetch).not.toHaveBeenCalled();
   });
-
   it('should log extra data', () => {
     jest.spyOn(IssueReporter, '_sendToRemoteLogger').mockImplementation(() => {});
-
-    IssueReporter.log('log', 'logger-category=http', 'my message', { status: 200 });
-
+    IssueReporter.log('log', 'logger-category=http', 'my message', {
+      status: 200,
+    });
     expect(IssueReporter._sendToRemoteLogger).toHaveBeenCalledWith('log', {
       date: expect.anything(),
       message: 'my message',
@@ -78,12 +85,9 @@ describe('IssueReporter', () => {
       status: 200,
     });
   });
-
   it('should log an error', () => {
     jest.spyOn(IssueReporter, '_sendToRemoteLogger').mockImplementation(() => {});
-
     IssueReporter.log('error', 'logger-category=http', 'my message', new MyError('nope'));
-
     expect(IssueReporter._sendToRemoteLogger).toHaveBeenCalledWith('error', {
       date: expect.anything(),
       message: 'my message',
@@ -93,17 +97,17 @@ describe('IssueReporter', () => {
       errorType: 'MyError',
     });
   });
-
   it('remove slashes', () => {
     expect(IssueReporter.removeSlashes('\\')).toBe('');
     expect(IssueReporter.removeSlashes('\\"')).toBe("'");
     expect(IssueReporter.removeSlashes('\"')).toBe("'");
     expect(IssueReporter.removeSlashes('\\\"')).toBe("'");
   });
-
   it('Add retry count', () => {
     expect(IssueReporter._writeRetryCount('', 1)).toBe('');
     expect(IssueReporter._writeRetryCount('{}', 1)).toBe('{}');
-    expect(IssueReporter._writeRetryCount({}, 1)).toEqual({ _retry: 1 });
+    expect(IssueReporter._writeRetryCount({}, 1)).toEqual({
+      _retry: 1,
+    });
   });
 });

package/src/service/getApiClient.ts

@@ -0,0 +1,94 @@
+/* eslint-disable dot-notation */
+import WazoApiClient from '../api-client';
+
+// Can't use node cache mechanism here because when requiring lib/CallApi.js
+// this file will be merge with CallApi.js and the cache will be lost.
+// So we have to store values in global scope.
+global.wazoClients = global.wazoClients || {};
+global.wazoClientId = global.wazoClientId || {};
+global.wazoClientToken = global.wazoClientToken || {};
+global.wazoRefreshToken = global.wazoRefreshToken || {};
+global.wazoRefreshTenantId = global.wazoRefreshTenantId || {};
+global.wazoRefreshDomainName = global.wazoRefreshDomainName || {};
+global.wazoOnRefreshToken = global.wazoOnRefreshToken || {};
+global.wazoOnRefreshTokenError = global.wazoOnRefreshTokenError || {};
+global.wazoRefreshExpiration = global.wazoRefreshExpiration || {};
+global.wazoRefreshBackend = global.wazoRefreshBackend || {};
+global.wazoIsMobile = global.wazoIsMobile || {};
+global.wazoFetchOptions = global.wazoFetchOptions || {};
+export const setApiClientId = (clientId: string, forServer: string | null | undefined = null) => {
+  global.wazoClientId[String(forServer)] = clientId;
+};
+export const setCurrentServer = (newServer: string) => {
+  global.wazoCurrentServer = newServer;
+};
+export const setApiToken = (newToken: string | null | undefined, forServer: string | null | undefined = null) => {
+  global.wazoClientToken[String(forServer)] = newToken;
+};
+export const setRefreshToken = (newRefreshToken: string | null | undefined, forServer: string | null | undefined = null) => {
+  global.wazoRefreshToken[String(forServer)] = newRefreshToken;
+};
+export const setRefreshTenantId = (refreshTenantId: string | null | undefined, forServer: string | null | undefined = null) => {
+  console.warn('Use of `setRefreshTenantId` is deprecated, please use `setRefreshDomainName` instead');
+  global.wazoRefreshTenantId[String(forServer)] = refreshTenantId;
+};
+export const setRefreshDomainName = (refreshDomainName: string | null | undefined, forServer: string | null | undefined = null) => {
+  global.wazoRefreshDomainName[String(forServer)] = refreshDomainName;
+};
+export const setOnRefreshToken = (onRefreshToken: (...args: Array<any>) => any, forServer: string | null | undefined = null) => {
+  global.wazoOnRefreshToken[String(forServer)] = onRefreshToken;
+};
+export const setOnRefreshTokenError = (callback: (...args: Array<any>) => any, forServer: string | null | undefined = null) => {
+  global.wazoOnRefreshTokenError[String(forServer)] = callback;
+};
+export const setRefreshExpiration = (refreshExpiration: number, forServer: string | null | undefined = null) => {
+  global.wazoRefreshExpiration[String(forServer)] = refreshExpiration;
+};
+export const setRefreshBackend = (refreshBackend: number, forServer: string | null | undefined = null) => {
+  global.wazoRefreshBackend[String(forServer)] = refreshBackend;
+};
+export const setIsMobile = (isMobile: boolean, forServer: string | null | undefined = null) => {
+  global.wazoIsMobile[String(forServer)] = isMobile;
+};
+export const setFetchOptions = (fetchOptions: Record<string, any>, forServer: string | null | undefined = null) => {
+  global.wazoFetchOptions[String(forServer)] = fetchOptions;
+};
+
+const fillClient = (apiClient: WazoApiClient) => {
+  const {
+    server,
+    token,
+    clientId,
+  } = apiClient.client;
+  const tenantId = global.wazoRefreshTenantId[server] || global.wazoRefreshTenantId.null || apiClient.refreshTenantId;
+  //  try with null server when dealing with non-related server info
+  apiClient.setToken(global.wazoClientToken[server] || global.wazoClientToken.null || token);
+  apiClient.setClientId(global.wazoClientId[server] || global.wazoClientId.null || clientId);
+  apiClient.setRefreshToken(global.wazoRefreshToken[server] || global.wazoRefreshToken.null || apiClient.refreshToken);
+
+  if (tenantId) {
+    apiClient.setRefreshTenantId(tenantId);
+  }
+
+  apiClient.setRefreshDomainName(global.wazoRefreshDomainName[server] || global.wazoRefreshDomainName.null || apiClient.refreshDomainName);
+  apiClient.setFetchOptions(global.wazoFetchOptions[server] || global.wazoFetchOptions.null || apiClient.fetchOptions);
+  apiClient.setOnRefreshToken(global.wazoOnRefreshToken[server] || global.wazoOnRefreshToken.null || apiClient.onRefreshToken);
+  apiClient.setOnRefreshTokenError(global.wazoOnRefreshTokenError[server] || global.wazoOnRefreshTokenError.null || apiClient.onRefreshTokenError);
+  apiClient.setRefreshExpiration(global.wazoRefreshExpiration[server] || global.wazoRefreshExpiration.null || apiClient.refreshExpiration);
+  apiClient.setRefreshBackend(global.wazoRefreshBackend[server] || global.wazoRefreshBackend.null || apiClient.refreshBackend);
+  apiClient.setIsMobile(global.wazoIsMobile[server] || global.wazoIsMobile.null || apiClient.isMobile);
+  return apiClient;
+};
+
+export default ((forServer: string | null | undefined = null): WazoApiClient => {
+  const server: string = forServer || global.wazoCurrentServer || '';
+
+  if (server in global.wazoClients) {
+    return fillClient(global.wazoClients[server]);
+  }
+
+  global.wazoClients[server] = new WazoApiClient({
+    server,
+  });
+  return fillClient(global.wazoClients[server]);
+});