@cloudbase/auth 1.7.3-alpha.0 → 1.8.1

package/src/providers/anonymousAuthProvider.ts

@@ -9,10 +9,10 @@ import { EVENTS, eventBus, LoginState } from '..';
 const { ERRORS, COMMUNITY_SITE_URL } = constants;
 const { throwError, isString } = utils;
 const { addEventListener } = events;
-const { catchErrorsDecorator, stopAuthLoginWithOAuth } = helpers;
+const { catchErrorsDecorator } = helpers;
 
 export class AnonymousAuthProvider extends AuthProvider {
-  constructor(config: ICloudbaseAuthConfig & { cache: ICloudbaseCache, request: ICloudbaseRequest }) {
+  constructor(config: ICloudbaseAuthConfig&{cache: ICloudbaseCache, request: ICloudbaseRequest}) {
     super(config);
 
     this._onConverted = this._onConverted.bind(this);
@@ -20,15 +20,14 @@ export class AnonymousAuthProvider extends AuthProvider {
     addEventListener(EVENTS.ANONYMOUS_CONVERTED, this._onConverted);
   }
 
-  @stopAuthLoginWithOAuth()
   @catchErrorsDecorator({
     title: '匿名登录失败',
     messages: [
       '请确认以下各项：',
       '  1 - 当前环境是否开启了匿名登录',
       '  2 - 调用 auth().anonymouseProvider().signIn() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async signIn(): Promise<ILoginState> {
     // 匿名登录前迁移cache到localstorage
@@ -41,7 +40,7 @@ export class AnonymousAuthProvider extends AuthProvider {
 
     const res = await this._request.send('auth.signInAnonymously', {
       anonymous_uuid,
-      refresh_token
+      refresh_token,
     });
     if (res.uuid && res.refresh_token) {
       await this._setAnonymousUUID(res.uuid);
@@ -51,7 +50,7 @@ export class AnonymousAuthProvider extends AuthProvider {
       eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
         env: this._config.env,
         loginType: LOGINTYPE.ANONYMOUS,
-        persistence: 'local'
+        persistence: 'local',
       });
 
       eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
@@ -59,17 +58,16 @@ export class AnonymousAuthProvider extends AuthProvider {
       const loginState = new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
       await loginState.checkLocalStateAsync();
       await loginState.user.refresh();
       return loginState;
-    } else {
-      throw new Error(JSON.stringify({
-        code: ERRORS.OPERATION_FAIL,
-        msg: JSON.stringify(res) || 'anonymous signIn failed'
-      }));
     }
+    throw new Error(JSON.stringify({
+      code: ERRORS.OPERATION_FAIL,
+      msg: JSON.stringify(res) || 'anonymous signIn failed',
+    }));
   }
   /**
    * 匿名转正
@@ -85,7 +83,7 @@ export class AnonymousAuthProvider extends AuthProvider {
     const res = await this._request.send('auth.linkAndRetrieveDataWithTicket', {
       anonymous_uuid,
       refresh_token,
-      ticket
+      ticket,
     });
     if (res.refresh_token) {
       // 转正后清除本地保存的匿名uuid
@@ -97,14 +95,13 @@ export class AnonymousAuthProvider extends AuthProvider {
       const loginState = new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
       await loginState.checkLocalStateAsync();
 
       return loginState;
-    } else {
-      throwError(ERRORS.OPERATION_FAIL, JSON.stringify(res) || 'linkAndRetrieveDataWithTicket failed');
     }
+    throwError(ERRORS.OPERATION_FAIL, JSON.stringify(res) || 'linkAndRetrieveDataWithTicket failed');
   }
   private async _setAnonymousUUID(id: string) {
     const { anonymousUuidKey, loginTypeKey } = this._cache.keys;
@@ -123,4 +120,4 @@ export class AnonymousAuthProvider extends AuthProvider {
     // 匿名转正后迁移cache
     await this._cache.updatePersistenceAsync(this._config.persistence);
   }
-}
+}

package/src/providers/base.ts

@@ -1,4 +1,4 @@
-import { ICloudbaseConfig, ICloudbase } from '@cloudbase/types';
+import { ICloudbaseConfig } from '@cloudbase/types';
 import { ICloudbaseCache } from '@cloudbase/types/cache';
 import { ICloudbaseRequest } from '@cloudbase/types/request';
 import { ICloudbaseAuthConfig } from '@cloudbase/types/auth';
@@ -8,13 +8,11 @@ export abstract class AuthProvider {
   protected readonly _config: ICloudbaseConfig;
   protected readonly _cache: ICloudbaseCache;
   protected readonly _request: ICloudbaseRequest;
-  protected readonly _fromApp: ICloudbase;
 
-  constructor(config: ICloudbaseAuthConfig & { cache: ICloudbaseCache, request: ICloudbaseRequest }) {
+  constructor(config: ICloudbaseAuthConfig&{cache: ICloudbaseCache, request: ICloudbaseRequest}) {
     this._config = config;
     this._cache = config.cache;
     this._request = config.request;
-    this._fromApp = config._fromApp
   }
   /**
    * 判断本地是否已经有登录态，如果有且没过期，则返回true，否则清理本地登录态
@@ -30,16 +28,15 @@ export abstract class AuthProvider {
         const loginState = new LoginState({
           envId: this._config.env,
           cache: this._cache,
-          request: this._request
+          request: this._request,
         });
         await loginState.checkLocalStateAsync();
 
         return loginState;
-      } else {
-        // access token存在但是过期了，那么删除掉重新拉
-        // await this._cache.removeStoreAsync(accessTokenKey);
-        // await this._cache.removeStoreAsync(accessTokenExpireKey);
       }
+      // access token存在但是过期了，那么删除掉重新拉
+      await this._cache.removeStoreAsync(accessTokenKey);
+      await this._cache.removeStoreAsync(accessTokenExpireKey);
     }
   }
   protected async setRefreshToken(refreshToken: string) {
@@ -64,15 +61,5 @@ export abstract class AuthProvider {
     const { userInfoKey } = this._cache.keys;
     await this._cache.setStoreAsync(userInfoKey, userInfo);
   }
-
-  // protected async stopAuthLoginWithOauth() {
-  //   const { _fromApp } = this._config
-  //   const checkRes = await checkFromAuthV1OrV2(_fromApp)
-  //   const { authType } = checkRes
-  //   console.log('authType', authType)
-  //   if (authType === 'oauth') {
-  //     throw Error('当前已使用 oauth 登录，请手动退出 oauth 登录后再进行 auth 登录')
-  //   }
-  // }
   abstract signIn(...args: any[]): Promise<any>;
-}
+}

package/src/providers/customAuthProvider.ts

@@ -7,11 +7,9 @@ import { eventBus, EVENTS, LoginState } from '..';
 
 const { ERRORS, COMMUNITY_SITE_URL } = constants;
 const { isString } = utils;
-const { catchErrorsDecorator, stopAuthLoginWithOAuth } = helpers;
+const { catchErrorsDecorator } = helpers;
 
 export class CustomAuthProvider extends AuthProvider {
-
-  @stopAuthLoginWithOAuth()
   @catchErrorsDecorator({
     title: '自定义登录失败',
     messages: [
@@ -20,20 +18,20 @@ export class CustomAuthProvider extends AuthProvider {
       '  2 - 调用 auth().customAuthProvider().signIn() 的语法或参数是否正确',
       '  3 - ticket 是否归属于当前环境',
       '  4 - 创建 ticket 的自定义登录私钥是否过期',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async signIn(ticket: string): Promise<ILoginState> {
     if (!isString(ticket)) {
       throw new Error(JSON.stringify({
         code: ERRORS.INVALID_PARAMS,
-        msg: 'ticket must be a string'
+        msg: 'ticket must be a string',
       }));
     }
     const { refreshTokenKey } = this._cache.keys;
     const res = await this._request.send('auth.signInWithTicket', {
       ticket,
-      refresh_token: await this._cache.getStoreAsync(refreshTokenKey) || ''
+      refresh_token: await this._cache.getStoreAsync(refreshTokenKey) || '',
     });
     if (res.refresh_token) {
       // 保存新refresh token并且刷新access token
@@ -43,7 +41,7 @@ export class CustomAuthProvider extends AuthProvider {
       eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
         env: this._config.env,
         loginType: LOGINTYPE.CUSTOM,
-        persistence: this._config.persistence
+        persistence: this._config.persistence,
       });
 
       eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
@@ -54,16 +52,15 @@ export class CustomAuthProvider extends AuthProvider {
       const loginState = new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
       await loginState.checkLocalStateAsync();
 
       return loginState;
-    } else {
-      throw new Error(JSON.stringify({
-        code: ERRORS.OPERATION_FAIL,
-        msg: 'custom signIn failed'
-      }));
     }
+    throw new Error(JSON.stringify({
+      code: ERRORS.OPERATION_FAIL,
+      msg: 'custom signIn failed',
+    }));
   }
-}
+}

package/src/providers/emailAuthProvider.ts

@@ -6,11 +6,9 @@ import { eventBus, EVENTS, LoginState } from '..';
 
 const { throwError, isString } = utils;
 const { ERRORS, COMMUNITY_SITE_URL } = constants;
-const { catchErrorsDecorator, stopAuthLoginWithOAuth } = helpers;
+const { catchErrorsDecorator } = helpers;
 
 export class EmailAuthProvider extends AuthProvider {
-
-  @stopAuthLoginWithOAuth()
   @catchErrorsDecorator({
     title: '邮箱密码登录失败',
     messages: [
@@ -18,8 +16,8 @@ export class EmailAuthProvider extends AuthProvider {
       '  1 - 调用 auth().emailAuthProvider() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱登录',
       '  3 - 邮箱地址与密码是否匹配',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async signIn(email: string, password: string): Promise<ILoginState> {
     if (!isString(email)) {
@@ -30,7 +28,7 @@ export class EmailAuthProvider extends AuthProvider {
       loginType: 'EMAIL',
       email,
       password,
-      refresh_token: this._cache.getStore(refreshTokenKey) || ''
+      refresh_token: this._cache.getStore(refreshTokenKey) || '',
     });
     const { refresh_token, access_token, access_token_expire } = res;
     if (refresh_token) {
@@ -46,17 +44,17 @@ export class EmailAuthProvider extends AuthProvider {
       eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
         env: this._config.env,
         loginType: LOGINTYPE.EMAIL,
-        persistence: this._config.persistence
+        persistence: this._config.persistence,
       });
       return new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
-    } else if (res.code) {
+    } if (res.code) {
       throwError(ERRORS.OPERATION_FAIL, `Email login fail[${res.code}] ${res.message}`);
     } else {
-      throwError(ERRORS.OPERATION_FAIL, `Email login fail`);
+      throwError(ERRORS.OPERATION_FAIL, 'Email login fail');
     }
   }
   /**
@@ -64,7 +62,6 @@ export class EmailAuthProvider extends AuthProvider {
    * @param email
    * @param password
    */
-  @stopAuthLoginWithOAuth()
   @catchErrorsDecorator({
     title: '邮箱注册失败',
     messages: [
@@ -72,13 +69,13 @@ export class EmailAuthProvider extends AuthProvider {
       '  1 - 调用 auth().signUpWithEmailAndPassword() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱登录',
       '  3 - 此邮箱地址是否已经被其他用户占用',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async signUp(email: string, password: string) {
     return this._request.send('auth.signUpWithEmailAndPassword', {
       email,
-      password
+      password,
     });
   }
   /**
@@ -93,12 +90,12 @@ export class EmailAuthProvider extends AuthProvider {
       '  2 - 当前环境是否开通了邮箱登录',
       '  3 - 此邮箱地址是否已经与当前用户绑定',
       '  4 - 此邮箱地址是否已经被其他用户占用',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async resetPassword(email: string) {
     return this._request.send('auth.sendPasswordResetEmail', {
-      email
+      email,
     });
   }
   /**
@@ -112,13 +109,13 @@ export class EmailAuthProvider extends AuthProvider {
       '请确认以下各项：',
       '  1 - 调用语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async resetPasswordWithToken(token: string, newPassword: string) {
     return this._request.send('auth.resetPasswordWithToken', {
       token,
-      newPassword
+      newPassword,
     });
   }
   /**
@@ -131,12 +128,12 @@ export class EmailAuthProvider extends AuthProvider {
       '请确认以下各项：',
       '  1 - 调用语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async activate(token: string) {
     return this._request.send('auth.activateEndUserMail', {
-      token
+      token,
     });
   }
-}
+}

package/src/providers/phoneAuthProvider.ts

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

package/src/providers/usernameAuthProvider.ts

@@ -6,10 +6,9 @@ import { utils, constants, helpers } from '@cloudbase/utilities';
 
 const { printWarn } = utils;
 const { ERRORS, COMMUNITY_SITE_URL } = constants;
-const { catchErrorsDecorator, stopAuthLoginWithOAuth } = helpers;
+const { catchErrorsDecorator } = helpers;
 
 export class UsernameAuthProvider extends AuthProvider {
-  @stopAuthLoginWithOAuth()
   @catchErrorsDecorator({
     title: '用户名密码登录失败',
     messages: [
@@ -17,14 +16,14 @@ export class UsernameAuthProvider extends AuthProvider {
       '  1 - 调用 auth().signInWithUsernameAndPassword() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了用户名密码登录',
       '  3 - 用户名密码是否匹配',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${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'
+        msg: 'username must be a string',
       }));
     }
     // 用户不设置密码
@@ -38,7 +37,7 @@ export class UsernameAuthProvider extends AuthProvider {
       loginType: LOGINTYPE.USERNAME,
       username,
       password,
-      refresh_token: await this._cache.getStoreAsync(refreshTokenKey) || ''
+      refresh_token: await this._cache.getStoreAsync(refreshTokenKey) || '',
     });
 
     const { refresh_token, access_token_expire, access_token } = res;
@@ -55,22 +54,22 @@ export class UsernameAuthProvider extends AuthProvider {
       eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
         env: this._config.env,
         loginType: LOGINTYPE.USERNAME,
-        persistence: this._config.persistence
+        persistence: this._config.persistence,
       });
       return new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
-    } else if (res.code) {
+    } if (res.code) {
       throw new Error(JSON.stringify({
         code: ERRORS.OPERATION_FAIL,
-        msg: `login by username failed:[${res.code}] ${res.message}`
+        msg: `login by username failed:[${res.code}] ${res.message}`,
       }));
     } else {
       throw new Error(JSON.stringify({
         code: ERRORS.OPERATION_FAIL,
-        msg: 'login by username failed'
+        msg: 'login by username failed',
       }));
     }
   }