@cloudbase/auth 1.6.1 → 2.0.0-alpha.0

package/src/providers/emailAuthProvider.ts

@@ -1,139 +0,0 @@
-import { constants,utils,helpers } from '@cloudbase/utilities';
-import { ILoginState } from '@cloudbase/types/auth';
-import { AuthProvider } from './base';
-import { LOGINTYPE } from '../constants';
-import { eventBus, EVENTS, LoginState } from '..';
-
-const { throwError, isString } = utils;
-const { ERRORS, COMMUNITY_SITE_URL } = constants;
-const { catchErrorsDecorator } = helpers;
-
-export class EmailAuthProvider extends AuthProvider {
-  @catchErrorsDecorator({
-    title: '邮箱密码登录失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().emailAuthProvider() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了邮箱登录',
-      '  3 - 邮箱地址与密码是否匹配',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async signIn(email: string, password: string): Promise<ILoginState> {
-    if (!isString(email)) {
-      throwError(ERRORS.INVALID_PARAMS,'email must be a string');
-    }
-    const { refreshTokenKey } = this._cache.keys;
-    const res = await this._request.send('auth.signIn', {
-      loginType: 'EMAIL',
-      email,
-      password,
-      refresh_token: this._cache.getStore(refreshTokenKey) || ''
-    });
-    const { refresh_token, access_token, access_token_expire } = res;
-    if (refresh_token) {
-      await this.setRefreshToken(refresh_token);
-      if (access_token && access_token_expire) {
-        await this.setAccessToken(access_token, access_token_expire);
-      } else {
-        await this._request.refreshAccessToken();
-      }
-      // set user info
-      await this.refreshUserInfo();
-      eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
-      eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
-        env: this._config.env,
-        loginType: LOGINTYPE.EMAIL,
-        persistence: this._config.persistence
-      });
-      return new LoginState({
-        envId: this._config.env,
-        cache: this._cache,
-        request: this._request
-      });
-    } else if (res.code) {
-      throwError(ERRORS.OPERATION_FAIL,`Email login fail[${res.code}] ${res.message}`);
-    } else {
-      throwError(ERRORS.OPERATION_FAIL,`Email login fail`);
-    }
-  }
-  /**
-   * 注册
-   * @param email 
-   * @param password 
-   */
-  @catchErrorsDecorator({
-    title: '邮箱注册失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().signUpWithEmailAndPassword() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了邮箱登录',
-      '  3 - 此邮箱地址是否已经被其他用户占用',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async signUp(email:string, password:string) {
-    return this._request.send('auth.signUpWithEmailAndPassword', {
-      email,
-      password
-    });
-  }
-  /**
-   * 发起重置密码请求，发起后推送邮件到指定邮箱
-   * @param email 
-   */
-  @catchErrorsDecorator({
-    title: '重置密码失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().sendPasswordResetEmail() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了邮箱登录',
-      '  3 - 此邮箱地址是否已经与当前用户绑定',
-      '  4 - 此邮箱地址是否已经被其他用户占用',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async resetPassword(email:string) {
-    return this._request.send('auth.sendPasswordResetEmail', {
-      email
-    });
-  }
-  /**
-   * 重置密码
-   * @param token 
-   * @param newPassword 
-   */
-  @catchErrorsDecorator({
-    title: '重置密码失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用语法或参数是否正确',
-      '  2 - 当前环境是否开通了邮箱登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async resetPasswordWithToken(token:string, newPassword:string) {
-    return this._request.send('auth.resetPasswordWithToken', {
-      token,
-      newPassword
-    });
-  }
-  /**
-   * 激活邮箱
-   * @param token 
-   */
-  @catchErrorsDecorator({
-    title: '邮箱激活失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用语法或参数是否正确',
-      '  2 - 当前环境是否开通了邮箱登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async activate(token: string) {
-    return this._request.send('auth.activateEndUserMail', {
-      token
-    });
-  }
-}

package/src/providers/phoneAuthProvider.ts

@@ -1,130 +0,0 @@
-import { constants, utils, helpers } from '@cloudbase/utilities';
-import { ILoginState } from '@cloudbase/types/auth';
-import { AuthProvider } from './base';
-import { LOGINTYPE } from '../constants';
-import { eventBus, EVENTS, LoginState } from '..';
-
-const { throwError, isString, transformPhone } = utils;
-const { ERRORS, COMMUNITY_SITE_URL } = constants;
-const { catchErrorsDecorator } = helpers;
-
-export const SIGN_METHOD = {
-  SIGNIN: 'SIGNIN',
-  SIGNUP: 'SIGNUP',
-  FORCERESETPWD: 'FORCERESETPWD'
-}
-
-export class PhoneAuthProvider extends AuthProvider {
-  @catchErrorsDecorator({
-    title: '手机号登录失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().SmsAuthProvider() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了短信验证码登录',
-      '  3 - 短信验证码/密码是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async signIn(param: {
-    phoneNumber: string
-    phoneCode?: string
-    password?: string
-    signMethod?: string
-  }): Promise<ILoginState> {
-    let { phoneNumber, phoneCode, password, signMethod } = param
-    if (!isString(phoneNumber)) {
-      throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
-    }
-
-    if (!isString(phoneCode) && !isString(password)) {
-      throwError(ERRORS.INVALID_PARAMS, 'phoneCode or password must be a string');
-    }
-
-    if (!signMethod) {
-      signMethod = SIGN_METHOD.SIGNIN
-    }
-
-    const { refreshTokenKey } = this._cache.keys;
-    const res = await this._request.send('auth.signIn', {
-      loginType: LOGINTYPE.PHONE,
-      phoneNumber: transformPhone(phoneNumber),
-      phoneCode,
-      password,
-      refresh_token: this._cache.getStore(refreshTokenKey) || '',
-      signMethod
-    });
-    const { refresh_token, access_token, access_token_expire } = res;
-    if (refresh_token) {
-      await this.setRefreshToken(refresh_token);
-      if (access_token && access_token_expire) {
-        await this.setAccessToken(access_token, access_token_expire);
-      } else {
-        await this._request.refreshAccessToken();
-      }
-      // set user info
-      await this.refreshUserInfo();
-      eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
-      eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
-        env: this._config.env,
-        loginType: LOGINTYPE.PHONE,
-        persistence: this._config.persistence
-      });
-      return new LoginState({
-        envId: this._config.env,
-        cache: this._cache,
-        request: this._request
-      });
-    } else if (res.code) {
-      throwError(ERRORS.OPERATION_FAIL, `Phone login fail[${res.code}] ${res.message}`);
-    } else {
-      throwError(ERRORS.OPERATION_FAIL, `Phone login fail`);
-    }
-  }
-  /**
-   * 手机号注册
-   * @param phoneNumber
-   * @param phoneCode
-   * @param password
-   */
-  @catchErrorsDecorator({
-    title: '手机短信注册失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().signUpWithPhoneCode() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了短信验证码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async signUp(phoneNumber: string, phoneCode: string, password?: string): Promise<ILoginState> {
-    return this.signIn({
-      phoneNumber,
-      phoneCode,
-      password,
-      signMethod: SIGN_METHOD.SIGNUP
-    })
-  }
-
-  /**
-   * 手机号注册
-   * @param phoneNumber
-   * @param phoneCode
-   * @param password
-   */
-  @catchErrorsDecorator({
-    title: '手机密码重置失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().forceResetPwd() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了短信验证码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async forceResetPwd(phoneNumber: string, phoneCode: string, password: string): Promise<ILoginState> {
-    return this.signIn({
-      phoneNumber,
-      phoneCode,
-      password,
-      signMethod: SIGN_METHOD.FORCERESETPWD
-    })
-  }
-}

package/src/providers/usernameAuthProvider.ts

@@ -1,76 +0,0 @@
-import { AuthProvider } from './base';
-import { ILoginState } from '@cloudbase/types/auth';
-import { eventBus, EVENTS, LoginState } from '..';
-import { LOGINTYPE } from '../constants';
-import { utils, constants, helpers } from '@cloudbase/utilities';
-
-const { printWarn } = utils;
-const { ERRORS, COMMUNITY_SITE_URL } = constants;
-const { catchErrorsDecorator } = helpers;
-
-export class UsernameAuthProvider extends AuthProvider {
-  @catchErrorsDecorator({
-    title: '用户名密码登录失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().signInWithUsernameAndPassword() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了用户名密码登录',
-      '  3 - 用户名密码是否匹配',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async signIn(username: string, password: string): Promise<ILoginState> {
-    if (typeof username !== 'string') {
-      throw new Error(JSON.stringify({
-        code: ERRORS.INVALID_PARAMS,
-        msg: 'username must be a string'
-      }));
-    }
-    // 用户不设置密码
-    if (typeof password !== 'string') {
-      password = '';
-      printWarn(ERRORS.INVALID_PARAMS,'password is empty');
-    }
-
-    const { refreshTokenKey } = this._cache.keys;
-    const res = await this._request.send('auth.signIn',{
-      loginType: LOGINTYPE.USERNAME,
-      username,
-      password,
-      refresh_token: await this._cache.getStoreAsync(refreshTokenKey) || ''
-    });
-
-    const { refresh_token, access_token_expire, access_token } = res;
-    if (refresh_token) {
-      await this.setRefreshToken(refresh_token);
-      if (access_token && access_token_expire) {
-        await this.setAccessToken(access_token, access_token_expire);
-      } else {
-        await this._request.refreshAccessToken();
-      }
-      // set user info
-      await this.refreshUserInfo();
-      eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
-      eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
-        env: this._config.env,
-        loginType: LOGINTYPE.USERNAME,
-        persistence: this._config.persistence
-      });
-      return new LoginState({
-        envId: this._config.env,
-        cache: this._cache,
-        request: this._request
-      });
-    } else if (res.code) {
-      throw new Error(JSON.stringify({
-        code: ERRORS.OPERATION_FAIL,
-        msg: `login by username failed:[${res.code}] ${res.message}`
-      }));
-    } else {
-      throw new Error(JSON.stringify({
-        code: ERRORS.OPERATION_FAIL,
-        msg: 'login by username failed'
-      }));
-    }
-  }
-}

package/src/providers/weixinAuthProvider.ts

@@ -1,193 +0,0 @@
-import { AuthProvider } from './base';
-import { ICloudbaseAuthConfig } from '@cloudbase/types/auth';
-import { ICloudbaseCache } from '@cloudbase/types/cache';
-import { ICloudbaseRequest } from '@cloudbase/types/request';
-import { constants, adapters,utils, helpers } from '@cloudbase/utilities/';
-import { eventBus, EVENTS, LoginState } from '..';
-import { LOGINTYPE } from '../constants';
-
-const { getSdkName, ERRORS, COMMUNITY_SITE_URL } = constants;
-const { RUNTIME } = adapters;
-const { getQuery, getHash, removeParam, printWarn } = utils;
-const { catchErrorsDecorator } = helpers;
-
-export class WeixinAuthProvider extends AuthProvider {
-  private readonly _scope: string;
-  private readonly _state: string;
-  private readonly _appid: string;
-  private readonly _runtime:string;
-
-  constructor(config: ICloudbaseAuthConfig&{cache:ICloudbaseCache,request:ICloudbaseRequest,runtime:string}, appid: string, scope: string, state?: string) {
-    super(config);
-
-    this._runtime = config.runtime;
-    this._appid = appid;
-    this._scope = scope;
-    this._state = state || 'weixin';
-  }
-  
-  public async signIn(){
-    return printWarn(ERRORS.OPERATION_FAIL,'API signIn has been deprecated, please use signInWithRedirect insteed');
-  }
-  @catchErrorsDecorator({
-    title: '跳转微信公众号授权失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().weixinAuthProvider().signInWithRedirect() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async signInWithRedirect() {
-    return this._redirect();
-  }
-  @catchErrorsDecorator({
-    title: '微信公众号登录失败',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().weixinAuthProvider().getRedirectResult() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了微信公众号登录授权',
-      '  3 - 微信公众号的 AppId 与 AppSecret 配置是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  public async getRedirectResult(options:{ withUnionId?: boolean; syncUserInfo?: boolean }) {
-    const code = getWeixinCode();
-    if (!code) {
-      return null;
-    }
-    return this._signInWithCode(code,options);
-  }
-  @catchErrorsDecorator({
-    title: '获取微信重定向绑定结果',
-    messages: [
-      '请确认以下各项：',
-      '  1 - 调用 auth().weixinAuthProvider().getLinkRedirectResult() 的语法或参数是否正确',
-      '  2 - 当前环境是否开通了微信公众号登录授权',
-      '  3 - 微信公众号的 AppId 与 AppSecret 配置是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
-  })
-  async getLinkRedirectResult(options: { withUnionId?: boolean } = {}) {
-    const { withUnionId = false } = options;
-    const code = getWeixinCode();
-    if (!code) {
-      return null;
-    }
-    const { _appid: appid } = this;
-    const loginType = (scope => {
-      switch (scope) {
-        case 'snsapi_login':
-          return 'WECHAT-OPEN';
-        default:
-          return 'WECHAT-PUBLIC';
-      }
-    })(this._scope);
-    const hybridMiniapp = this._runtime === RUNTIME.WX_MP ? '1' : '0';
-    return this._request.send('auth.linkWithWeixinCode', { 
-      payload: { 
-        appid, 
-        loginType, 
-        code, 
-        hybridMiniapp, 
-        withUnionId
-      }
-    });
-  }
-
-  private _redirect(): any {
-    let currUrl = removeParam('code', location.href);
-    currUrl = removeParam('state', currUrl);
-    currUrl = encodeURIComponent(currUrl);
-
-    let host = '//open.weixin.qq.com/connect/oauth2/authorize';
-    if (this._scope === 'snsapi_login') {
-      host = '//open.weixin.qq.com/connect/qrconnect';
-    }
-    try{
-      location.href = `${host}?appid=${this._appid}&redirect_uri=${currUrl}&response_type=code&scope=${this._scope}&state=${this._state}#wechat_redirect`;
-    }catch(e){
-      throw new Error(`[${getSdkName()}][${ERRORS.UNKOWN_ERROR}]${e}`)
-    }
-  }
-
-  private async _signInWithCode(code:string,options) {
-    const { accessTokenKey, accessTokenExpireKey, refreshTokenKey } = this._cache.keys;
-    // 有code，用code换refresh token
-    const loginType = (scope => {
-      switch (scope) {
-        case 'snsapi_login':
-          return 'WECHAT-OPEN';
-        default:
-          return 'WECHAT-PUBLIC';
-      }
-    })(this._scope);
-
-    const refreshTokenRes = await this._getRefreshTokenByWXCode(this._appid, loginType, code,options);
-    const { refreshToken } = refreshTokenRes;
-
-    // 本地存下
-    await this._cache.setStoreAsync(refreshTokenKey, refreshToken);
-    if (refreshTokenRes.accessToken) {
-      await this._cache.setStoreAsync(accessTokenKey, refreshTokenRes.accessToken);
-    }
-    if (refreshTokenRes.accessTokenExpire) {
-      await this._cache.setStoreAsync(accessTokenExpireKey, String(refreshTokenRes.accessTokenExpire + Date.now()));
-    }
-    eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
-    // 抛出登录类型更改事件
-    eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, { 
-      env: this._config.env,
-      loginType: LOGINTYPE.WECHAT, 
-      persistence: this._config.persistence 
-    });
-    await this.refreshUserInfo();
-    const loginState = new LoginState({
-      envId: this._config.env,
-      cache: this._cache,
-      request: this._request
-    });
-    await loginState.checkLocalStateAsync();
-    
-    return loginState;
-  }
-
-  private async _getRefreshTokenByWXCode(
-    appid: string, 
-    loginType: string, 
-    code: string,
-    options: any = {}
-  ): Promise<{ refreshToken: string; accessToken: string; accessTokenExpire: number }> {
-    const { withUnionId = false, createUser = true } = options;
-    // snsapi_userinfo 和 snsapi_login 才可以获取用户的微信信息
-    const syncUserInfo = this._scope === 'snsapi_base' ? false : options.syncUserInfo || false;
-
-    const action = 'auth.signIn';
-    const hybridMiniapp = this._runtime === RUNTIME.WX_MP ? '1' : '0';
-    return this._request.send(action, { 
-      appid, 
-      loginType, 
-      hybridMiniapp,
-      syncUserInfo,
-      loginCredential: code,
-      withUnionId,
-      createUser
-    }).then(res => {
-      if (res.code) {
-        throw new Error(`[${getSdkName()}][${ERRORS.OPERATION_FAIL}] failed login via wechat: ${res.code}`);
-      }
-      if (res.refresh_token) {
-        return {
-          refreshToken: res.refresh_token,
-          accessToken: res.access_token,
-          accessTokenExpire: res.access_token_expire
-        };
-      } else {
-        throw new Error(`[${getSdkName()}][${ERRORS.OPERATION_FAIL}] action:getJwt not return refreshToken`);
-      }
-    });
-  }
-}
-
-function getWeixinCode () {
-  return getQuery('code') || getHash('code');
-};