@or-sdk/auth 0.24.9-beta.995.0 → 0.24.9

package/src/AuthForClient.ts

@@ -1,426 +0,0 @@
-import { AuthBase } from './AuthBase';
-import {
-  AuthBaseConfig, AuthDataStorage,
-  AuthResponse,
-  MultiUserLoginUserArgs,
-  MultiUserResponse,
-  MultiUserUpdateTwoFactorArgs,
-  MultiUserUploadIconArgs,
-  MultiUserUploadIconResponse,
-  SignInArgs,
-  User,
-} from './types';
-import _ from 'lodash';
-import { generateFingerPrint } from './utils';
-import { isNode } from 'browser-or-node';
-import axios from 'axios';
-
-export class AuthForClient extends AuthBase {
-  readonly dataStorage: AuthDataStorage;
-  constructor(params: AuthBaseConfig & {dataStorage: AuthDataStorage;}) {
-    super(params);
-    this.dataStorage = params.dataStorage;
-  }
-
-  /**
-   * Sign in
-   * ```typescript
-   * const user = await instance.signIn({
-   *   credentials: {
-   *     username: 'username',
-   *     password: 'password'
-   *   },
-   *   long: true,
-   *   captchaToken: 'captchaToken'
-   * });
-   * ```
-   */
-  async signIn({
-    credentials,
-    long = false,
-    allowGuestLogin = false,
-    captchaToken,
-    isCaptchaV2Checkbox,
-    verificationCode,
-    userToken,
-    rememberTwoFactor,
-  }: SignInArgs): Promise<AuthResponse> {
-    const fingerPrint = await generateFingerPrint();
-
-    const options = {
-      ...credentials,
-      captchaToken,
-      isCaptchaV2Checkbox,
-      verificationCode,
-      fingerPrint,
-      rememberTwoFactor,
-      ... userToken ? { userToken } : {},
-    };
-
-    const user = await this.sdkApi.makeRequest<AuthResponse>({
-      method: 'POST',
-      route: '/auth/token',
-      data: options,
-    });
-
-    this.validateGuest(user.role, allowGuestLogin);
-
-    if (!user.twoFactorCheck && !user.captchaCheck) {
-      if (user.tokenType === 'multi-user') {
-        this.dataStorage.saveMultiUser(user, long);
-      } else {
-        await this.dataStorage.saveUser({
-          long,
-          user,
-        });
-      }
-    }
-
-    return user;
-  }
-
-  /**
-   * Sign in with token
-   * ```typescript
-   * const user = await instance.signInWithToken({
-   *   token: 'token'
-   * });
-   * ```
-   */
-  async signInWithToken(
-    token: string | { token: string; allowGuestLogin?: boolean; shouldNotSaveCookies?: boolean; },
-    allowGuestLogin = false,
-    shouldNotSaveCookies = false
-  ): Promise<User> {
-    let userInfo = {};
-    if (_.isObject(token)) {
-      allowGuestLogin = _.get(token, 'allowGuestLogin', false);
-      shouldNotSaveCookies = _.get(token, 'shouldNotSaveCookies', false);
-      userInfo = _.get(token, 'userInfo', {});
-      token = token.token;
-    }
-
-    if (!token) {
-      return Promise.reject(new Error('No token given'));
-    }
-
-    this.dataStorage.checkDeprecatedData();
-
-    const user = await this.validateToken(token, allowGuestLogin);
-
-    _.assign(user, { token });
-
-    const allow = _.get(user, 'allow', false);
-    if (!allow) {
-      throw Error('Invalid Token');
-    }
-
-    if (!shouldNotSaveCookies) {
-      this.dataStorage.setItem({
-        ...userInfo,
-        ...user,
-      }, this.dataStorage.getCurrentExpire());
-    }
-
-    return user;
-  }
-
-  /**
-   * Sign out
-   * ```typescript
-   * await instance.signOut('token');
-   * ```
-   */
-  async signOut(token?: string, multiuserToken?: string): Promise<void> {
-    try {
-      const promises = [];
-      if (token) {
-        promises.push(this.sdkApi.makeRequest<void>({
-          method: 'DELETE',
-          route: '/auth/fingerprint-token',
-          customHeaders: {
-            ...this.addTokenToHeaders(token),
-          },
-        }));
-      }
-      if (multiuserToken) {
-        promises.push(this.sdkApi.makeRequest<void>({
-          method: 'DELETE',
-          route: '/multi-user/fingerprint-token',
-          ...this.addTokenToHeaders(multiuserToken),
-        }));
-      }
-      await Promise.all(promises);
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.log('Logout failed: ', error);
-    }
-    this.dataStorage.removeItem();
-  }
-
-  /**
-   * Validate user
-   * ```typescript
-   * const user = await instance.validateUser();
-   * ```
-   */
-  async validateUser(allowGuestLogin = false): Promise<User> {
-    this.dataStorage.checkDeprecatedData();
-    const userParams = this.dataStorage.user;
-
-    if (!userParams) {
-      return Promise.reject(new Error('No cached user params are available'));
-    }
-
-    const user = await this.validateToken(userParams.token || '', allowGuestLogin);
-
-    if (!user.identityProvider && userParams.identityProvider) {
-      user.identityProvider = userParams.identityProvider;
-    }
-    _.assign(user, { token: userParams.token });
-
-    const allow = _.get(user, 'allow', false);
-    if (!allow) {
-      throw Error('Invalid Token');
-    }
-
-    return user;
-  }
-
-  /**
-   * Get users list of a multi-user
-   * ```typescript
-   * const result = await instance.multiUserGetUsersList();
-   * ```
-   */
-  async multiUserGetUsersList(): Promise<any> {
-    if (!this.multiUserToken) return false;
-
-    return this.sdkApi.makeRequest<any>({
-      method: 'GET',
-      route: '/multi-user/list-users',
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-  }
-
-  /**
-   * Log in user of a multi-user
-   * ```typescript
-   * const result = await instance.multiUserLoginUser({
-   *  accountId: 'account-id',
-   *  id: 'id',
-   *  long: true
-   * });
-   * ```
-   */
-  async multiUserLoginUser({ accountId, id, long }: MultiUserLoginUserArgs): Promise<User> {
-    const user = await this.sdkApi.makeRequest<User>({
-      method: 'POST',
-      route: '/multi-user/user-token',
-      data: {
-        accountId,
-        id,
-      },
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-
-    await this.dataStorage.saveUser({
-      long,
-      user,
-    });
-
-    return user;
-  }
-
-  /**
-   * Get username for lock screen
-   * ```typescript
-   * const username = await instance.getUserNameForLockScreen(user);
-   * ```
-   */
-  async getUserNameForLockScreen(user: Pick<User, 'multiUserId'| 'username'| 'token'>): Promise<string> {
-    const multiUserCookie = this.dataStorage.multiUserData;
-    if (multiUserCookie.username) return multiUserCookie.username;
-
-    const { multiUserId, username, token } = user;
-    if (multiUserId) {
-      const { username } = await this.sdkApi.makeRequest<MultiUserResponse>({
-        method: 'GET',
-        route: '/user/multi-user',
-        customHeaders: {
-          ...this.addTokenToHeaders(token || ''),
-        },
-      });
-
-      return username;
-
-    }
-    return username;
-  }
-
-  /**
-   * Get profile for multi-user
-   * ```typescript
-   * const result = await instance.multiUserGetProfile();
-   * ```
-   */
-  async multiUserGetProfile(): Promise<any> {
-    return this.sdkApi.makeRequest<any>({
-      method: 'GET',
-      route: '/multi-user/profile',
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-  }
-
-
-  /**
-   * Update cookie expiration
-   * ```typescript
-   * instance.updateCookieExpiration();
-   * ```
-   */
-  updateCookieExpiration() {
-    this.dataStorage.updateExpiration();
-  }
-
-  /**
-   * Set profile for multi-user
-   * ```typescript
-   * const knowledgeModels = await instance.multiUserSetProfile(profile);
-   * ```
-   */
-  async multiUserSetProfile(profile: unknown): Promise<any> {
-    return this.sdkApi.makeRequest<any>({
-      method: 'POST',
-      route: '/multi-user/profile',
-      data: profile,
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-  }
-
-  /**
-   * Validate multi-user token
-   * ```typescript
-   * const result = await instance.validateMultiUserToken();
-   * ```
-   */
-  async validateMultiUserToken(): Promise<any> {
-    return this.sdkApi.makeRequest<any>({
-      method: 'GET',
-      route: '/multi-user/token',
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-  }
-
-  /**
-   * Upload icon for multi-user
-   * ```typescript
-   * const downloadUrl = await instance.multiUserUploadIcon({
-   *  name: 'name',
-   *  contentType: 'content-type',
-   *  file: file
-   * });
-   * ```
-   */
-  async multiUserUploadIcon(
-    { name, contentType, cacheControl = 'no-cache', file }: MultiUserUploadIconArgs
-  ): Promise<string> {
-    const data = await this.sdkApi.makeRequest<MultiUserUploadIconResponse>({
-      method: 'POST',
-      route: '/multi-user/sign-upload-url',
-      data: {
-        name,
-        contentType,
-        cacheControl,
-      },
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-
-    const FormDataLib = isNode ? require('form-data') : FormData;
-    const formData = new FormDataLib();
-
-    _.forEach(data.uploadParams.fields, (value, key) => {
-      formData.append(key, value);
-    });
-
-    formData.append('cache-control', cacheControl);
-    formData.append('content-type', contentType);
-    formData.append('File', file, name);
-
-    if (isNode) {
-      await new Promise<void>((resolve, reject) => {
-        formData.submit(data.uploadParams.url, (error: any) => {
-          if (error) return reject(error);
-          resolve();
-        });
-      });
-    } else {
-      await axios.post(data.uploadParams.url, formData);
-    }
-
-    return data.downloadUrl;
-  }
-
-  /**
-   * Confirm email change
-   * ```typescript
-   * const result = await instance.confirmEmailChange({ token: 'token' });
-   * ```
-   */
-  async confirmEmailChange({ token }: { token: string; }): Promise<any> {
-    return this.sdkApi.makeRequest<any>({
-      method: 'POST',
-      route: '/multi-user/change-email-finish',
-      data: {
-        token,
-      },
-    });
-  }
-
-  /**
-   * Update 2fa for multi-user
-   * ```typescript
-   * const result = await instance.multiUserUpdateTwoFactor({
-   *  secret: 'secret',
-   *  enabled: true,
-   *  codes: codes,
-   *  verificationCode: 'verification-code'
-   * });
-   * ```
-   */
-  async multiUserUpdateTwoFactor(
-    { secret, enabled, codes, verificationCode }: MultiUserUpdateTwoFactorArgs
-  ): Promise<any> {
-    return this.sdkApi.makeRequest<any>({
-      method: 'POST',
-      route: '/multi-user/twofactor',
-      data: {
-        secret,
-        enabled,
-        codes,
-        verificationCode,
-      },
-      customHeaders: {
-        ...this.addTokenToHeaders(this.multiUserToken),
-      },
-    });
-  }
-
-
-  private get multiUserToken(): string {
-    const { token = '' } = this.dataStorage.multiUserData;
-    return token;
-  }
-}