@wazo/sdk 0.38.22 → 0.39.0-beta.2

package/src/simple/{Auth.js → Auth.ts}

@@ -1,42 +1,80 @@
-// @flow
 /* 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,
-} from '../service/getApiClient';
+import getApiClient, { setCurrentServer, setApiToken, setRefreshToken, setApiClientId, setRefreshExpiration, setOnRefreshToken, setFetchOptions, setRefreshTenantId, setRefreshDomainName, setOnRefreshTokenError } from '../service/getApiClient';
 import IssueReporter from '../service/IssueReporter';
-
 import Wazo from './index';
+import SipLine from '../domain/SipLine';
 
 export class InvalidSubscription extends Error {}
 export class InvalidAuthorization extends Error {}
 export class NoTenantIdError extends Error {}
 export class NoDomainNameError extends Error {}
-
 const logger = IssueReporter.loggerFor('simple-auth');
 
-class Auth {
+export interface IAuth {
+  clientId: string;
+  expiration: number;
+  minSubscriptionType: number | null;
+  authorizationName: string | null;
+  host: string | null;
+  session: Session | null;
+  onRefreshTokenCallback: ((...args: Array<any>) => any) | null;
+  onRefreshTokenCallbackError: ((...args: Array<any>) => any) | null;
+  authenticated: boolean;
+  mobile: boolean;
+  BACKEND_WAZO: string;
+  BACKEND_LDAP: string;
+  init: (clientId: string, expiration: number, minSubscriptionType: number | null | undefined, authorizationName: string | null, mobile: boolean) => void;
+  setFetchOptions: (options: Record<string, any>) => void;
+  logIn: (username: string, password: string, backend?: string, extra?: string | Record<string, any>) => Promise<Session | null>;
+  logInViaRefreshToken: (refreshToken: string) => Promise<Session | null>;
+  validateToken: (token: string, refreshToken: string) => Promise<Session | undefined | null>;
+  generateNewToken: (refreshToken: string) => Promise<Session | null | undefined>;
+  logout: (deleteRefreshToken?: boolean) => Promise<void>;
+  setOnRefreshToken: (callback: (...args: Array<any>) => any) => void;
+  setOnRefreshTokenError: (callback: (...args: Array<any>) => any) => void;
+  checkAuthorizations: (session: Session, authorizationName: string | null | undefined) => void;
+  checkSubscription: (session: Session, minSubscriptionType: number) => void;
+  setHost: (host: string) => void;
+  setApiToken: (token: string) => void;
+  setRefreshToken: (refreshToken: string) => void ;
+  setRefreshTenantId: (refreshTenantId: string) => void;
+  setRefreshDomainName: (domainName: string) => void;
+  forceRefreshToken: () => void;
+  setIsMobile: (mobile: boolean) => void ;
+  getHost: () => string | undefined;
+  getSession: () => Session | undefined;
+  getFirstName: () => string;
+  getLastName: () => string;
+  setClientId: (clientId: string) => void;
+  getName: () => string ;
+  _onAuthenticated: (rawSession: Session) => Promise<Session | null>;
+}
+
+class Auth implements IAuth {
   clientId: string;
+
   expiration: number;
-  minSubscriptionType: ?number;
-  authorizationName: ?string;
-  host: ?string;
-  session: ?Session;
-  onRefreshTokenCallback: ?Function;
-  onRefreshTokenCallbackError: ?Function;
+
+  minSubscriptionType: number | null;
+
+  authorizationName: string | null;
+
+  host: string | null;
+
+  session: Session | null;
+
+  onRefreshTokenCallback: ((...args: Array<any>) => any) | null;
+
+  onRefreshTokenCallbackError: ((...args: Array<any>) => any) | null;
+
   authenticated: boolean;
+
   mobile: boolean;
+
   BACKEND_WAZO: string;
+
   BACKEND_LDAP: string;
 
   constructor() {
@@ -47,11 +85,7 @@ class Auth {
     this.BACKEND_LDAP = BACKEND_LDAP_USER;
   }
 
-  init(clientId: string,
-    expiration: number,
-    minSubscriptionType: ?number,
-    authorizationName: ?string,
-    mobile: boolean) {
+  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;
@@ -59,11 +93,12 @@ class Auth {
     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 });
+      logger.info('on refresh token done', {
+        token,
+      });
       setApiToken(token);
       Wazo.Websocket.updateToken(token);
 
@@ -71,7 +106,6 @@ class Auth {
         this.onRefreshTokenCallback(token, session);
       }
     });
-
     setOnRefreshTokenError(error => {
       logger.error('on refresh token error', error);
 
@@ -81,16 +115,18 @@ class Auth {
     });
   }
 
-  setFetchOptions(options: Object) {
+  setFetchOptions(options: Record<string, any>) {
     setFetchOptions(options);
   }
 
-  async logIn(username: string, password: string, backend?: string, extra?: string | Object) {
-    let tenantId = null;
+  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;
     }
@@ -110,9 +146,9 @@ class Auth {
     const rawSession = await getApiClient().auth.logIn({
       username,
       password,
-      backend,
-      tenantId,
-      domainName,
+      backend: backend as string,
+      tenantId: tenantId as string,
+      domainName: <unknown>domainName as string,
       expiration: this.expiration,
       mobile: this.mobile,
     });
@@ -129,17 +165,17 @@ class Auth {
       getApiClient().setRefreshDomainName(domainName);
     }
 
-    return this._onAuthenticated(rawSession);
+    return this._onAuthenticated(rawSession as Session);
   }
 
-  async logInViaRefreshToken(refreshToken: string) {
-    const rawSession = await getApiClient().auth.refreshToken(refreshToken, null, this.expiration, this.mobile);
-    return this._onAuthenticated(rawSession);
+  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) {
+  async validateToken(token: string, refreshToken: string): Promise<Session | undefined | null> {
     if (!token) {
-      return null;
+      return;
     }
 
     if (refreshToken) {
@@ -149,115 +185,114 @@ class Auth {
     // Check if the token is valid
     try {
       const rawSession = await getApiClient().auth.authenticate(token);
-      return this._onAuthenticated(rawSession);
-    } catch (e) {
+      return this._onAuthenticated(rawSession as Session);
+    } catch (e: any) {
       logger.error('on validate token error', e);
       console.warn(e);
-      return false;
     }
   }
 
-  async generateNewToken(refreshToken: string) {
-    return getApiClient().auth.refreshToken(refreshToken, null, this.expiration);
+  async generateNewToken(refreshToken: string): Promise<Session | null | undefined> {
+    return getApiClient().auth.refreshToken(refreshToken, '', this.expiration);
   }
 
-  async logout(deleteRefreshToken: boolean = true) {
+  async logout(deleteRefreshToken = true): Promise<void> {
     try {
       Wazo.Websocket.close(true);
 
       if (this.clientId && deleteRefreshToken) {
         await getApiClient().auth.deleteRefreshToken(this.clientId);
       }
-    } catch (e) {
-      // Nothing to
+    } catch (e: any) { // Nothing to
     }
 
     try {
-      await getApiClient().auth.logOut(this.session ? this.session.token : null);
-    } catch (e) {
-      // Nothing to
+      await getApiClient().auth.logOut(this.session?.token || '');
+    } catch (e: any) { // Nothing to
     }
 
     setApiToken(null);
     setRefreshToken(null);
-
     this.session = null;
     this.authenticated = false;
   }
 
-  setOnRefreshToken(callback: Function) {
+  setOnRefreshToken(callback: (...args: Array<any>) => any) {
     this.onRefreshTokenCallback = callback;
   }
 
-  setOnRefreshTokenError(callback: Function) {
+  setOnRefreshTokenError(callback: (...args: Array<any>) => any) {
     this.onRefreshTokenCallbackError = callback;
   }
 
-  checkAuthorizations(session: Session, authorizationName: ?string) {
+  checkAuthorizations(session: Session, authorizationName: string | null | undefined): void {
     if (!authorizationName) {
       return;
     }
-    const { authorizations } = session;
+
+    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) {
-    const userSubscriptionType = session.profile ? session.profile.subscriptionType : null;
-    if (userSubscriptionType === null || +userSubscriptionType <= minSubscriptionType) {
+  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) {
+  setHost(host: string): void {
     this.host = host;
-
     setCurrentServer(host);
   }
 
-  setApiToken(token: string) {
+  setApiToken(token: string): void {
     setApiToken(token);
   }
 
-  setRefreshToken(refreshToken: string) {
+  setRefreshToken(refreshToken: string): void {
     setRefreshToken(refreshToken);
   }
 
-  setRefreshTenantId(refreshTenantId: string) {
+  setRefreshTenantId(refreshTenantId: string): void {
     console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead.');
     setRefreshTenantId(refreshTenantId);
-
     getApiClient().setRefreshTenantId(refreshTenantId);
   }
 
-  setRefreshDomainName(domainName: string) {
+  setRefreshDomainName(domainName: string): void {
     setRefreshDomainName(domainName);
-
     getApiClient().setRefreshDomainName(domainName);
   }
 
-  forceRefreshToken() {
+  forceRefreshToken(): void {
     getApiClient().forceRefreshToken();
   }
 
-  setIsMobile(mobile: boolean) {
+  setIsMobile(mobile: boolean): void {
     this.mobile = mobile;
   }
 
-  getHost() {
-    return this.host;
+  getHost(): string | undefined {
+    return this.host || undefined;
   }
 
-  getSession() {
-    return this.session;
+  getSession(): Session | undefined {
+    return this.session || undefined;
   }
 
   getFirstName(): string {
     if (!this.session || !this.session.profile) {
       return '';
     }
+
     return this.session.profile.firstName;
   }
 
@@ -269,48 +304,49 @@ class Auth {
     return this.session.profile.lastName;
   }
 
-  setClientId(clientId: string) {
+  setClientId(clientId: string): void {
     this.clientId = clientId;
-
     setApiClientId(this.clientId);
   }
 
-  getName() {
+  getName(): string {
     return `${this.getFirstName()} ${this.getLastName()}`;
   }
 
-  async _onAuthenticated(rawSession: Session) {
+  async _onAuthenticated(rawSession: Session): Promise<Session | null> {
     if (this.authenticated && this.session) {
       return this.session;
     }
+
     const session = rawSession;
+
     if (!session) {
       return null;
     }
 
     setApiToken(session.token);
+
     if (session.refreshToken) {
       setRefreshToken(session.refreshToken);
     }
 
     try {
-      const [profile, { wazo_version: engineVersion }] = await Promise.all([
-        getApiClient().confd.getUser(session.uuid),
-        getApiClient().confd.getInfos(),
-      ]);
-
+      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) {
+    } catch (e: any) {
       // Destroy tokens when validation fails
       if (this.clientId) {
         await getApiClient().auth.deleteRefreshToken(this.clientId);
       }
+
       if (session) {
         await getApiClient().auth.logOut(session.token);
       }
@@ -319,26 +355,19 @@ class Auth {
     }
 
     try {
-      const sipLines = await getApiClient().confd.getUserLinesSip(
-        session.uuid,
-        // $FlowFixMe
-        session.profile.lines.map(line => line.id),
-      );
-
-      // $FlowFixMe
-      session.profile.sipLines = sipLines.filter(line => !!line);
-    } catch (e) {
-      // When an user has only a sccp line, getSipLines return a 404
+      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, session);
-
+    Wazo.Websocket.open(this.host as string, session);
     this.session = session;
-
     return session;
   }
+
 }
 
 if (!global.wazoAuthInstance) {

package/src/simple/{Configuration.js → Configuration.ts}

@@ -1,10 +1,9 @@
-// @flow
 import Auth from './Auth';
 import getApiClient from '../service/getApiClient';
+import Profile from '../domain/Profile';
 
 class Configuration {
-
-  async getCurrentUser() {
+  async getCurrentUser(): Promise<Profile> {
     const session = Auth.getSession();
     return getApiClient().confd.getUser(session ? session.uuid : '');
   }

package/src/simple/{Directory.js → Directory.ts}

@@ -1,9 +1,8 @@
-// @flow
+import type Contact from '../domain/Contact';
 import getApiClient from '../service/getApiClient';
 
 class Directory {
-
-  async findMultipleContactsByNumber(numbers: string[]) {
+  async findMultipleContactsByNumber(numbers: string[]): Promise<Contact[]> {
     return getApiClient().dird.findMultipleContactsByNumber(numbers);
   }