@wazo/sdk 0.43.15 → 0.44.1

package/src/service/getApiClient.ts

@@ -1,113 +0,0 @@
-/* eslint-disable dot-notation */
-import WazoApiClient from '../api-client';
-import BaseApiClient from '../base-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.wazoRequestApiTimeout = global.wazoRequestApiTimeout || {};
-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 setRequestTimeout = (requestTimeout: number, forServer: string | null | undefined = null) => {
-  global.wazoRequestApiTimeout[String(forServer)] = requestTimeout;
-};
-export const setFetchOptions = (fetchOptions: Record<string, any>, forServer: string | null | undefined = null) => {
-  global.wazoFetchOptions[String(forServer)] = fetchOptions;
-};
-export const getFetchOptions = (forServer: string | null | undefined = null) =>
-  (forServer ? global.wazoFetchOptions[forServer] : global.wazoFetchOptions.null) || global.wazoFetchOptions.null;
-
-const fillClient = (apiClient: InstanceType<typeof BaseApiClient>) => {
-  const {
-    server,
-    token,
-    clientId,
-  } = apiClient.client;
-  const tenantId = global.wazoRefreshTenantId[server] || global.wazoRefreshTenantId.null || apiClient.refreshTenantId;
-  const requestTimeout = global.wazoRequestApiTimeout[server] || global.wazoRequestApiTimeout.null;
-  //  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);
-
-  if (requestTimeout) {
-    apiClient.setRequestTimeout(requestTimeout);
-  }
-};
-
-type ForServer = string | null;
-type TClient = new (...args: any[]) => BaseApiClient;
-
-const getApiClient = <T extends BaseApiClient = WazoApiClient>(forServer?: ForServer, Client: TClient = WazoApiClient): T => {
-  const server: string = forServer || global.wazoCurrentServer || '';
-
-  if (server in global.wazoClients) {
-    fillClient(global.wazoClients[server]);
-    return global.wazoClients[server];
-  }
-
-  global.wazoClients[server] = new Client({
-    server,
-  });
-
-  fillClient(global.wazoClients[server]);
-  return global.wazoClients[server];
-};
-
-export default getApiClient;

package/src/simple/Auth.ts

@@ -1,496 +0,0 @@
-/* eslint-disable max-classes-per-file */
-import Session from '../domain/Session';
-import { BACKEND_LDAP_USER, DEFAULT_BACKEND_USER, DETAULT_EXPIRATION } from '../api/auth';
-import getApiClient, {
-  setCurrentServer,
-  setApiToken,
-  setRefreshToken,
-  setApiClientId,
-  setRefreshExpiration,
-  setOnRefreshToken,
-  setFetchOptions,
-  setRefreshTenantId,
-  setRefreshDomainName,
-  setOnRefreshTokenError,
-  getFetchOptions,
-  setRequestTimeout,
-} from '../service/getApiClient';
-import IssueReporter from '../service/IssueReporter';
-import Wazo from './index';
-import SipLine from '../domain/SipLine';
-import { obfuscateToken } from '../utils/string';
-
-export class InvalidSubscription extends Error {}
-export class InvalidAuthorization extends Error {}
-export class NoTenantIdError extends Error {}
-export class NoDomainNameError extends Error {}
-export class NoSamlRouteError extends Error {}
-export class SamlConfigError extends Error {}
-
-const logger = IssueReporter.loggerFor('simple-auth');
-
-export class Auth {
-  clientId: string;
-
-  expiration: number;
-
-  minSubscriptionType: number | null;
-
-  authorizationName: string | null;
-
-  host: string | null;
-
-  session: Session | null;
-
-  onRefreshTokenCallback?: (token: string, session: Session) => void;
-
-  onRefreshTokenCallbackError?: (error: any) => void;
-
-  onHostFromHeadersCallback?: (stackHostFromHeaders: string) => void;
-
-  authenticated: boolean;
-
-  mobile: boolean;
-
-  BACKEND_WAZO: string;
-
-  BACKEND_LDAP: string;
-
-  usingEdgeServer: boolean | undefined;
-
-  onSetUsingEdgeServer?: (usingEdgeServer: boolean) => void;
-
-  constructor() {
-    this.expiration = DETAULT_EXPIRATION;
-    this.authenticated = false;
-    this.minSubscriptionType = null;
-    this.BACKEND_WAZO = DEFAULT_BACKEND_USER;
-    this.BACKEND_LDAP = BACKEND_LDAP_USER;
-  }
-
-  init(clientId: string, expiration: number, minSubscriptionType: number | null | undefined, authorizationName: string | null, mobile: boolean): void {
-    this.clientId = clientId;
-    this.expiration = expiration;
-    this.minSubscriptionType = typeof minSubscriptionType === 'undefined' ? null : minSubscriptionType;
-    this.authorizationName = authorizationName;
-    this.host = null;
-    this.session = null;
-    this.mobile = mobile || false;
-    setApiClientId(this.clientId);
-    setRefreshExpiration(this.expiration);
-    setOnRefreshToken((token: string, session: Session) => {
-      logger.info('on refresh token done', { token: obfuscateToken(token) });
-
-      setApiToken(token);
-      Wazo.Websocket.updateToken(token);
-
-      if (this.onRefreshTokenCallback) {
-        this.onRefreshTokenCallback(token, session);
-      }
-    });
-    setOnRefreshTokenError(error => {
-      logger.error('on refresh token error', error);
-
-      if (this.onRefreshTokenCallbackError) {
-        this.onRefreshTokenCallbackError(error);
-      }
-    });
-  }
-
-  setFetchOptions(options: Record<string, any>) {
-    setFetchOptions(options);
-  }
-
-  async logIn(username: string, password: string, backend?: string, extra?: string | Record<string, any>): Promise<Session | null> {
-    let tenantId: string | null = null;
-    let domainName = null;
-
-    if (typeof extra === 'string') {
-      tenantId = extra;
-    }
-
-    if (extra && typeof extra === 'object') {
-      domainName = extra.domainName;
-    }
-
-    if (backend && backend !== this.BACKEND_WAZO && !tenantId && !domainName) {
-      if (!tenantId) {
-        throw new NoTenantIdError('No tenant id');
-      }
-
-      if (!domainName) {
-        throw new NoDomainNameError('No domain name');
-      }
-    }
-
-    this.authenticated = false;
-    this.session = null;
-    const rawSession = await getApiClient().auth.logIn({
-      username,
-      password,
-      backend: backend as string,
-      tenantId: tenantId as string,
-      domainName: <unknown>domainName as string,
-      expiration: this.expiration,
-      mobile: this.mobile,
-    });
-
-    // Used for Proxy Authentication
-    if (rawSession) {
-      const stackHostFromHeaders = rawSession.getHostFromHeader();
-      if (stackHostFromHeaders) {
-        this.setHost(stackHostFromHeaders);
-
-        if (this.onHostFromHeadersCallback) {
-          this.onHostFromHeadersCallback(stackHostFromHeaders);
-        }
-      }
-    }
-
-    if (backend) {
-      getApiClient().setRefreshBackend(backend);
-    }
-
-    if (tenantId) {
-      getApiClient().setRefreshTenantId(tenantId);
-    }
-
-    if (domainName) {
-      getApiClient().setRefreshDomainName(domainName);
-    }
-
-    return this._onAuthenticated(rawSession as Session);
-  }
-
-  async samlLogIn(samlSessionId: string): Promise<Session | null> {
-    const rawSession = await getApiClient().auth.samlLogIn(samlSessionId);
-    return this._onAuthenticated(rawSession as Session);
-  }
-
-  async samlLogOut(): Promise<void | { location: string }> {
-    return await this.logout(false, true);
-  }
-
-  async initiateIdpAuthentication(domain: string, redirectUrl: string): Promise<{ location: string, saml_session_id: string } | undefined> {
-    try {
-      return await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
-    } catch (e: any) {
-      logger.error('Error during IdP authentication initialization:', e.message);
-
-      if (e.status === 404) {
-        throw new NoSamlRouteError('No route found for SAML SSO');
-      }
-
-      if (e.status === 500) {
-        throw new SamlConfigError('SAML/server configuration error');
-      }
-
-      throw e;
-    }
-  }
-
-  async logInViaRefreshToken(refreshToken: string): Promise<Session | null> {
-    const rawSession = await getApiClient().auth.refreshToken(refreshToken, '', this.expiration, this.mobile);
-    return this._onAuthenticated(rawSession as Session);
-  }
-
-  async validateToken(token: string, refreshToken?: string, headerUserUuid?: string): Promise<Session | undefined | null> {
-    if (!token) {
-      return;
-    }
-
-    if (this.usingEdgeServer && typeof headerUserUuid === 'string') {
-      logger.info('using edge server, setting user UUID header', { headerUserUuid });
-      this.setHttpUserUuidHeader(headerUserUuid);
-    }
-
-    if (refreshToken) {
-      setRefreshToken(refreshToken);
-    }
-
-    // Check if the token is valid
-    try {
-      const rawSession = await getApiClient().auth.authenticate(token);
-      return this._onAuthenticated(rawSession as Session);
-    } catch (e: any) {
-      logger.error('on validate token error', e);
-      console.warn(e);
-    }
-  }
-
-  async generateNewToken(refreshToken: string): Promise<Session | null | undefined> {
-    return getApiClient().auth.refreshToken(refreshToken, '', this.expiration);
-  }
-
-  async logout(deleteRefreshToken = true, saml = false): Promise<void | { location: string }> {
-    try {
-      Wazo.Websocket.close(true);
-
-      if (!saml && this.clientId && deleteRefreshToken) {
-        await getApiClient().auth.deleteRefreshToken(this.clientId);
-      }
-    } catch (e: any) {
-      // Nothing to
-    }
-
-    let response;
-
-    try {
-      if (this.session?.token) {
-        if (saml) {
-          response = await getApiClient().auth.samlLogOut();
-        } else {
-          await getApiClient().auth.logOut(this.session.token);
-        }
-      }
-    } catch (e: any) {
-      // Nothing to
-    }
-
-    setApiToken(null);
-    setRefreshToken(null);
-    this.session = null;
-    this.authenticated = false;
-    this.usingEdgeServer = undefined;
-    setFetchOptions({});
-
-    return response;
-  }
-
-  setOnHostFromHeaders(callback: (hostFromHeaders: string) => void) {
-    this.onHostFromHeadersCallback = callback;
-  }
-
-  setOnSetUsingEdgeServer(callback: (usingEdgeServer: boolean) => void) {
-    logger.info('setting onSetUsingEdgeServer callback', { callback: typeof callback === 'function' });
-    this.onSetUsingEdgeServer = callback;
-  }
-
-  setOnRefreshToken(callback: (...args: Array<any>) => any) {
-    this.onRefreshTokenCallback = callback;
-  }
-
-  setOnRefreshTokenError(callback: (...args: Array<any>) => any) {
-    this.onRefreshTokenCallbackError = callback;
-  }
-
-  checkAuthorizations(session: Session, authorizationName: string | null | undefined): void {
-    if (!authorizationName) {
-      return;
-    }
-
-    const {
-      authorizations,
-    } = session;
-
-    if (!authorizations.find(authorization => authorization.rules.find(rule => rule.name === authorizationName))) {
-      throw new InvalidAuthorization(`No authorization '${authorizationName || ''}' found for your account.`);
-    }
-  }
-
-  checkSubscription(session: Session, minSubscriptionType: number): void {
-    const userSubscriptionType = <number>session.profile?.subscriptionType || null;
-
-    if (userSubscriptionType === null || userSubscriptionType <= minSubscriptionType) {
-      const message = `Invalid subscription ${userSubscriptionType || 'n/a'}, required at least ${minSubscriptionType}`;
-      throw new InvalidSubscription(message);
-    }
-  }
-
-  setHost(host: string): void {
-    this.host = host;
-    setCurrentServer(host);
-  }
-
-  setApiToken(token: string): void {
-    setApiToken(token);
-  }
-
-  setRefreshToken(refreshToken: string): void {
-    setRefreshToken(refreshToken);
-  }
-
-  setRefreshTenantId(refreshTenantId: string): void {
-    console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead.');
-    setRefreshTenantId(refreshTenantId);
-    getApiClient().setRefreshTenantId(refreshTenantId);
-  }
-
-  setRefreshDomainName(domainName: string): void {
-    setRefreshDomainName(domainName);
-    getApiClient().setRefreshDomainName(domainName);
-  }
-
-  setRequestTimeout(requestTimeout: number): void {
-    setRequestTimeout(requestTimeout);
-    getApiClient().setRequestTimeout(requestTimeout);
-  }
-
-  forceRefreshToken(): Promise<string | null> {
-    return getApiClient().forceRefreshToken();
-  }
-
-  setIsMobile(mobile: boolean): void {
-    this.mobile = mobile;
-  }
-
-  getHost(): string | undefined {
-    return this.host || undefined;
-  }
-
-  getSession(): Session | undefined {
-    return this.session || undefined;
-  }
-
-  getFirstName(): string {
-    if (!this.session || !this.session.profile) {
-      return '';
-    }
-
-    return this.session.profile.firstName;
-  }
-
-  getLastName(): string {
-    if (!this.session || !this.session.profile) {
-      return '';
-    }
-
-    return this.session.profile.lastName;
-  }
-
-  setClientId(clientId: string): void {
-    this.clientId = clientId;
-    setApiClientId(this.clientId);
-  }
-
-  getName(): string {
-    return `${this.getFirstName()} ${this.getLastName()}`;
-  }
-
-  _getHttpUserUuidHeaders(uuid:string) {
-    return {
-      ...(getFetchOptions()?.headers || {}),
-      'X-User-UUID': uuid,
-    };
-  }
-
-  setHttpUserUuidHeader(uuid: string) {
-    logger.info('Setting http header user uuid', { uuid });
-
-    if (!uuid) {
-      logger.warn('attempting to set a null value to user uuid header');
-      return;
-    }
-
-    const headers = this._getHttpUserUuidHeaders(uuid);
-
-    setFetchOptions({
-      ...getFetchOptions(),
-      headers,
-    });
-  }
-
-  async checkHttpUserUuidHeader(uuid: string | null | undefined) {
-    logger.info('Checking user uuid http header', { uuid });
-
-    if (!uuid) {
-      return;
-    }
-
-    const headers = this._getHttpUserUuidHeaders(uuid);
-
-    try {
-      const response: Response = await getApiClient().client.head('auth/0.1/status', null, headers, (r: any) => r);
-
-      const allowsUserUuidHeader = response.headers.get('access-control-allow-headers')?.includes('X-User-UUID');
-
-      if (this.mobile && !allowsUserUuidHeader) {
-        throw new Error('Server does not allow user UUID header on mobile');
-      }
-
-      // If the previous request went well, it means that the header is accepted
-      this.setHttpUserUuidHeader(uuid);
-      this.usingEdgeServer = true;
-      logger.info('Setting usingEdgeServer value to TRUE', { requestHeaders: headers, responseHeaders: response.headers, allowsUserUuidHeader });
-    } catch (e) {
-      this.usingEdgeServer = false;
-      logger.info('Setting usingEdgeServer to FALSE', { justification: e });
-    }
-
-    if (typeof this.onSetUsingEdgeServer === 'function') {
-      logger.info('calling onSetUsingEdgeServer', { usingEdgeServer: this.usingEdgeServer });
-      this.onSetUsingEdgeServer(this.usingEdgeServer);
-    }
-  }
-
-  async _onAuthenticated(rawSession: Session): Promise<Session | null> {
-    if (this.authenticated && this.session) {
-      return this.session;
-    }
-
-    const session = rawSession;
-
-    if (!session) {
-      return null;
-    }
-
-    if (this.usingEdgeServer) {
-      this.setHttpUserUuidHeader(session.uuid as string);
-    } else if (typeof this.usingEdgeServer === 'undefined') {
-      await this.checkHttpUserUuidHeader(session.uuid);
-    }
-
-    setApiToken(session.token);
-
-    if (session.refreshToken) {
-      setRefreshToken(session.refreshToken);
-    }
-
-    try {
-      const [profile, {
-        wazo_version: engineVersion,
-      }] = await Promise.all([getApiClient().confd.getUser(session.uuid as string), getApiClient().confd.getInfos()]);
-      session.engineVersion = engineVersion;
-      session.profile = profile;
-      this.checkAuthorizations(session, this.authorizationName);
-
-      if (this.minSubscriptionType !== null) {
-        this.checkSubscription(session, +this.minSubscriptionType);
-      }
-    } catch (e: any) {
-      logger.error('on authenticated error', e);
-
-      // Destroy tokens when validation fails
-      if (this.clientId) {
-        await getApiClient().auth.deleteRefreshToken(this.clientId);
-      }
-
-      if (session) {
-        await getApiClient().auth.logOut(session.token);
-      }
-
-      throw e;
-    }
-
-    try {
-      const lineIds: string[] = session.profile?.lines.filter(line => !line.endpointSccp).map(line => String(line.id));
-      const sipLines = await getApiClient().confd.getUserLinesSip(session.uuid as string, lineIds);
-
-      session.profile.sipLines = sipLines.filter(line => line instanceof SipLine) as SipLine[];
-    } catch (e: any) { // When an user has only a sccp line, getSipLines return a 404
-    }
-
-    this.authenticated = true;
-    Wazo.Websocket.open(this.host as string, session);
-    this.session = session;
-    return session;
-  }
-
-}
-
-if (!global.wazoAuthInstance) {
-  global.wazoAuthInstance = new Auth();
-}
-
-// @ts-ignore: Circular definition of import alias 'default'.
-export default global.wazoAuthInstance;

package/src/simple/Configuration.ts

@@ -1,18 +0,0 @@
-import Wazo from '.';
-import getApiClient from '../service/getApiClient';
-import Profile from '../domain/Profile';
-
-export class Configuration {
-  async getCurrentUser(): Promise<Profile> {
-    const session = Wazo.Auth.getSession();
-    return getApiClient().confd.getUser(`${session ? session.uuid : ''}`);
-  }
-
-}
-
-if (!global.wazoConfigurationInstance) {
-  global.wazoConfigurationInstance = new Configuration();
-}
-
-// @ts-ignore: Circular definition of import alias 'default'.
-export default global.wazoConfigurationInstance;

package/src/simple/Directory.ts

@@ -1,16 +0,0 @@
-import type Contact from '../domain/Contact';
-import getApiClient from '../service/getApiClient';
-
-export class Directory {
-  async findMultipleContactsByNumber(numbers: string[], fields?: Record<string, any>): Promise<Contact[]> {
-    return getApiClient().dird.findMultipleContactsByNumber(numbers, fields);
-  }
-
-}
-
-if (!global.wazoDirectoryInstance) {
-  global.wazoDirectoryInstance = new Directory();
-}
-
-// @ts-ignore: Circular definition of import alias 'default'.
-export default global.wazoDirectoryInstance;