@wazo/sdk 0.43.15 → 0.44.1

package/src/base-api-client.ts

@@ -1,184 +0,0 @@
-import authMethods, { AuthD } from './api/auth';
-import ApiRequester from './utils/api-requester';
-import IssueReporter from './service/IssueReporter';
-import { obfuscateToken } from './utils/string';
-import { AUTH_VERSION } from './constants';
-
-export type ConstructorParams = {
-  server: string;
-  agent?: Record<string, any> | null | undefined;
-  clientId?: string;
-  refreshToken?: string | null | undefined;
-  isMobile?: boolean | null | undefined;
-  fetchOptions?: Record<string, any>;
-};
-
-const logger = IssueReporter ? IssueReporter.loggerFor('api') : console;
-
-export default class BaseApiClient {
-  client: ApiRequester;
-
-  auth: AuthD;
-
-  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: Record<string, any>;
-
-  constructor({
-    server,
-    agent = null,
-    refreshToken,
-    clientId,
-    isMobile = false,
-    fetchOptions,
-  }: ConstructorParams) {
-    this.updateParameters({
-      server,
-      agent,
-      clientId,
-      fetchOptions,
-    });
-    this.refreshToken = refreshToken;
-    this.isMobile = isMobile || false;
-  }
-
-  initializeEndpoints(): void {
-    this.auth = authMethods(this.client, `auth/${AUTH_VERSION}`);
-  }
-
-  updateParameters({
-    server,
-    agent,
-    clientId,
-    fetchOptions,
-  }: Record<string, any>) {
-    const refreshTokenCallback = this.refreshTokenCallback.bind(this);
-    this.client = new ApiRequester({
-      server,
-      agent,
-      refreshTokenCallback,
-      clientId,
-      fetchOptions,
-    });
-    this.initializeEndpoints();
-  }
-
-  async forceRefreshToken(): Promise<string | null> {
-    logger.info('forcing refresh token, calling callback');
-    return this.refreshTokenCallback();
-  }
-
-  async refreshTokenCallback(): Promise<string | null> {
-    logger.info('refresh token callback called', {
-      refreshToken: obfuscateToken(this.refreshToken),
-      refreshBackend: this.refreshBackend,
-      refreshTenantId: this.refreshTenantId,
-      refreshDomainName: this.refreshDomainName,
-      refreshExpiration: this.refreshExpiration,
-      isMobile: this.isMobile,
-    });
-
-    if (!this.refreshToken) {
-      return null;
-    }
-
-    try {
-      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: obfuscateToken(session.token),
-      });
-
-      if (this.onRefreshToken) {
-        this.onRefreshToken(session.token, session);
-      }
-
-      this.setToken(session.token);
-      return session.token;
-    } catch (error: any) {
-      logger.error('token refresh, error', error);
-
-      if (this.onRefreshTokenError) {
-        this.onRefreshTokenError(error);
-      }
-    }
-
-    return null;
-  }
-
-  setToken(token: string) {
-    this.client.setToken(token);
-  }
-
-  setTenant(tenant: string) {
-    this.client.setTenant(tenant);
-  }
-
-  setRefreshToken(refreshToken: string | null | undefined) {
-    this.refreshToken = refreshToken;
-  }
-
-  setRequestTimeout(requestTimeout: number) {
-    this.client.setRequestTimeout(requestTimeout);
-  }
-
-  setClientId(clientId: string | null | undefined) {
-    this.client.clientId = clientId;
-  }
-
-  setOnRefreshToken(onRefreshToken: (...args: Array<any>) => any) {
-    this.onRefreshToken = onRefreshToken;
-  }
-
-  setOnRefreshTokenError(callback: (...args: Array<any>) => any) {
-    this.onRefreshTokenError = callback;
-  }
-
-  setRefreshExpiration(refreshExpiration: number) {
-    this.refreshExpiration = refreshExpiration;
-  }
-
-  setRefreshBackend(refreshBackend: string) {
-    this.refreshBackend = refreshBackend;
-  }
-
-  setRefreshTenantId(tenantId: string | null | undefined) {
-    console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead');
-    this.refreshTenantId = tenantId;
-  }
-
-  setRefreshDomainName(domainName: string | null | undefined) {
-    this.refreshDomainName = domainName;
-  }
-
-  setIsMobile(isMobile: boolean) {
-    this.isMobile = isMobile;
-  }
-
-  setFetchOptions(fetchOptions: Record<string, any>) {
-    this.fetchOptions = fetchOptions;
-    this.client.setFetchOptions(fetchOptions);
-  }
-
-  disableErrorLogging() {
-    this.client.disableErrorLogging();
-  }
-
-}

package/src/checker/Checker.ts

@@ -1,73 +0,0 @@
-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: 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: (...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];
-      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,
-        });
-        onCheckResult(name, result);
-      } catch (e: any) {
-        logger.info(`Checking ${name} failure`, {
-          message: e.message,
-        });
-        onCheckResult(name, e);
-      }
-    }
-
-    logger.info('Engine check done.');
-  }
-
-  addCheck(check: Record<string, any>) {
-    this.checks.push(check);
-  }
-
-  async _addEngineVersion() {
-    if (!this.session.engineVersion) {
-      const apiClient = new WazoApiClient({
-        server: this.server,
-      });
-      apiClient.setToken(this.session.token);
-      const {
-        wazo_version: engineVersion,
-      } = await apiClient.confd.getInfos();
-      this.session.engineVersion = engineVersion;
-    }
-  }
-
-}
-
-export default Checker;

package/src/checker/checks/aor.ts

@@ -1,34 +0,0 @@
-import WazoApiClient from '../../api-client';
-
-export default {
-  name: 'List of AOR',
-  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;
-
-    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: any) {
-      if (e.status === 401) {
-        return 'Not available for this user';
-      }
-
-      throw e;
-    }
-  },
-};

package/src/checker/checks/api.ts

@@ -1,78 +0,0 @@
-import WazoApiClient from '../../api-client';
-import ServerError from '../../domain/ServerError';
-
-export default {
-  name: 'API',
-  check: async (server: string, session: any) => {
-    const client = new WazoApiClient({
-      server,
-    });
-    client.setToken(session.token);
-    client.disableErrorLogging();
-
-    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 as string);
-      await client.auth.getProviders(session.uuid as string);
-    } catch (e: any) {
-      handleApiError('wazo-auth', e);
-    }
-
-    try {
-      await client.callLogd.listCallLogs();
-    } catch (e: any) {
-      handleApiError('wazo-callogd', e);
-    }
-
-    try {
-      await client.calld.listCalls();
-    } catch (e: any) {
-      handleApiError('wazo-calld', e);
-    }
-
-    try {
-      await client.calld.listVoicemails();
-    } catch (e: any) {
-      // API throws a 404 when no voicemail
-      if (e.status !== 404) {
-        handleApiError('wazo-calld', e);
-      }
-    }
-
-    try {
-      await client.chatd.getState(session.uuid as string);
-      await client.chatd.getContactStatusInfo(session.uuid as string);
-      await client.chatd.getUserRooms();
-    } catch (e: any) {
-      handleApiError('wazo-chatd', e);
-    }
-
-    try {
-      await client.confd.getInfos();
-      await client.confd.getUser(session.uuid as string);
-    } catch (e: any) {
-      handleApiError('wazo-confd', e);
-    }
-
-    try {
-      await client.dird.listPersonalContacts();
-      await client.dird.listFavorites(session.primaryContext());
-      await client.dird.fetchWazoSource(session.primaryContext());
-      const conferenceSource = await client.dird.fetchConferenceSource(session.primaryContext());
-      await client.dird.fetchConferenceContacts(conferenceSource.items[0]);
-    } catch (e: any) {
-      handleApiError('wazo-dird', e);
-    }
-
-    try {
-      await client.webhookd.getSubscriptions();
-    } catch (e: any) {
-      handleApiError('wazo-webhookd', e);
-    }
-  },
-};

package/src/checker/checks/ice-ipv4.ts

@@ -1,80 +0,0 @@
-/* global MediaStream, RTCPeerConnection */
-import { parseCandidate } from '../../utils/webrtc';
-import isMobile from '../../utils/isMobile';
-
-const checkIsIPV4 = (ip: string) => {
-  const blocks = ip.split('.');
-
-  if (blocks.length !== 4) {
-    return false;
-  }
-
-  return blocks.every(block => parseInt(block, 10) >= 0 && parseInt(block, 10) <= 255);
-};
-
-export default {
-  name: 'Non IP v4 ice',
-  check: (server: string, session: any, externalAppConfig: Record<string, any>) => new Promise((resolve, reject) => {
-    if (typeof MediaStream === 'undefined') {
-      resolve('Skipped on node');
-      return;
-    }
-
-    const mobile = isMobile();
-    const offerOptions = {
-      offerToReceiveAudio: 1,
-    };
-    const ips: string[] = [];
-    const config: RTCConfiguration = {
-      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: string) => ({
-        urls: url,
-      })),
-      ...config.iceServers,
-      };
-    }
-
-    if (externalAppConfig && externalAppConfig.turn_servers) {
-      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);
-          ips.push(candidate.ip);
-        }
-      } else if (!e.candidate) {
-        if (!hasSrflxOrRelay) {
-          return reject(new Error('No `srflx` or `relay` found in candidate. Please consider using a TURN server.'));
-        }
-
-        if (ips.every(checkIsIPV4)) {
-          resolve(null);
-        } else {
-          const nonIPV4 = ips.find(ip => !checkIsIPV4(ip));
-          reject(new Error(`Non IPv4 ice candidate found : ${nonIPV4}.`));
-        }
-      }
-    };
-
-    // @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.ts

@@ -1,9 +0,0 @@
-import api from './api';
-import aor from './aor';
-import wazoWebsocket from './wazo-websocket';
-import webrtcTransport from './webrtc-transport';
-import webrtc from './webrtc';
-import SymmetricNat from './symmetric-nat';
-import iceIpv4 from './ice-ipv4';
-
-export default [aor, api, wazoWebsocket, webrtcTransport, webrtc, SymmetricNat, iceIpv4];

package/src/checker/checks/symmetric-nat.ts

@@ -1,69 +0,0 @@
-/* global MediaStream, RTCPeerConnection */
-import { parseCandidate } from '../../utils/webrtc';
-
-const timeoutDuration = 8000; // @see https://webrtchacks.com/symmetric-nat/
-
-export default {
-  name: 'Symmetric NAT',
-  check: (): Promise<string | void> => new Promise((resolve, reject) => {
-    if (typeof MediaStream === 'undefined') {
-      return resolve('Skipped on node');
-    }
-
-    const candidates: Record<string, 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',
-      }],
-    });
-    let timeout: string | number | NodeJS.Timeout | undefined;
-
-    const onEnded = () => {
-      clearTimeout(timeout);
-
-      if (Object.keys(candidates).length === 0) {
-        reject(new Error(`Timed out (${timeoutDuration}ms), ${nbCandidates} candidates : ${rawCandidates.join(', ')}`));
-        return;
-      }
-
-      const ports = candidates[Object.keys(candidates)[0]];
-
-      if (ports.length === 1) {
-        resolve();
-      } else {
-        reject(new Error('Symmetric NAT detected, you should use a TURN server.'));
-      }
-    };
-
-    timeout = setTimeout(onEnded, timeoutDuration);
-    pc.createDataChannel('wazo-check-nat');
-
-    pc.onicecandidate = (e: RTCPeerConnectionIceEvent) => {
-      nbCandidates++;
-
-      if (e.candidate) {
-        rawCandidates.push(e.candidate.candidate);
-      }
-
-      if (e.candidate && e.candidate.candidate.indexOf('srflx') !== -1) {
-        const cand = parseCandidate(e.candidate.candidate);
-        if (cand.relatedPort) {
-          if (!candidates[cand.relatedPort]) {
-            candidates[cand.relatedPort] = [];
-          }
-          candidates[cand.relatedPort].push(cand.port);
-        }
-      } else if (!e.candidate) {
-        onEnded();
-      }
-    };
-
-    pc.createOffer().then(offer => pc.setLocalDescription(offer));
-  }),
-};

package/src/checker/checks/wazo-websocket.ts

@@ -1,41 +0,0 @@
-import WebSocketClient, { SOCKET_EVENTS, HEARTBEAT_ENGINE_VERSION } from '../../websocket-client';
-
-export default {
-  name: 'Event transport (WS)',
-  check: (server: string, session: any) => new Promise<void>((resolve, reject) => {
-    const client = new WebSocketClient({
-      host: server,
-      token: session.token,
-      version: 2,
-    });
-
-    const handleError = (message: any) => {
-      client.close();
-      reject(new Error(message));
-    };
-
-    const handleSuccess = () => {
-      client.stopHeartbeat();
-      client.close();
-      resolve();
-    };
-
-    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(() => {
-          handleError('No response to heartbeat');
-        });
-        client.setOnHeartbeatCallback(() => {
-          handleSuccess();
-        });
-        client.startHeartbeat();
-      } else {
-        handleSuccess();
-      }
-    });
-    client.connect();
-  }),
-};

package/src/checker/checks/webrtc-transport.ts

@@ -1,42 +0,0 @@
-import WebRTCClient from '../../web-rtc-client';
-import { WazoSession } from '../../domain/types';
-
-export default {
-  name: 'WebRTC Transport (WS) ~30s',
-  check: (server: string, session: WazoSession): Promise<void> => new Promise((resolve, reject) => {
-    const [host, port = 443] = server.split(':');
-
-    const client = new WebRTCClient({
-      host,
-      port,
-      media: {
-        audio: true,
-      },
-    }, session);
-
-    const handleError = (message: any) => {
-      client.close();
-      reject(new Error(message));
-    };
-
-    const handleSuccess = async () => {
-      client.stopHeartbeat();
-      await client.close();
-      resolve();
-    };
-
-    client.on(client.TRANSPORT_ERROR, error => {
-      handleError(`Transport error : ${error}`);
-    });
-
-    client.on(client.REGISTERED, () => {
-      client.setOnHeartbeatTimeout(() => {
-        handleError('No response to heartbeat');
-      });
-      client.setOnHeartbeatCallback(() => {
-        handleSuccess();
-      });
-      client.startHeartbeat();
-    });
-  }),
-};

package/src/checker/checks/webrtc.ts

@@ -1,48 +0,0 @@
-/* global MediaStream */
-import WebRTCClient from '../../web-rtc-client';
-
-export default {
-  name: 'WebRTC',
-  check: (server: string, session: any) => new Promise<void | string>((resolve, reject) => {
-    if (typeof MediaStream === 'undefined') {
-      return resolve('Skipped on node');
-    }
-
-    const [host, port = 443] = server.split(':');
-
-    const client = new WebRTCClient({
-      host,
-      port,
-      media: {
-        audio: true,
-      },
-    }, session);
-
-    const handleError = (message: any) => {
-      client.close();
-      reject(new Error(message));
-    };
-
-    const handleSuccess = async () => {
-      client.stopHeartbeat();
-      await client.close();
-      resolve();
-    };
-
-    client.on(client.TRANSPORT_ERROR, error => {
-      handleError(`Transport error : ${error}`);
-    });
-    client.on(client.REGISTERED, () => {
-      const sipSession = client.call('*10');
-
-      if (!sipSession || !client.getSipSessionId(sipSession)) {
-        return handleError('Unable to make call through WebRTC');
-      }
-
-      setTimeout(() => {
-        client.hangup(sipSession);
-        handleSuccess();
-      }, 1000);
-    });
-  }),
-};

package/src/constants.ts

@@ -1,11 +0,0 @@
-export const AUTH_VERSION = '0.1';
-export const APPLICATION_VERSION = '1.0';
-export const CONFD_VERSION = '1.1';
-export const CTIDNG_VERSION = '1.0';
-export const DIRD_VERSION = '0.1';
-export const CALL_LOGD_VERSION = '1.0';
-export const CHATD_VERSION = '1.0';
-export const CALLD_VERSION = '1.0';
-export const AGENTD_VERSION = '1.0';
-export const WEBHOOKD_VERSION = '1.0';
-export const AMID_VERSION = '1.0';