@cloudbase/auth 1.7.2-alpha.0 → 1.8.1

package/src/providers/anonymousAuthProvider.ts

@@ -12,7 +12,7 @@ const { addEventListener } = events;
 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);
@@ -26,10 +26,10 @@ export class AnonymousAuthProvider extends AuthProvider {
       '请确认以下各项：',
       '  1 - 当前环境是否开启了匿名登录',
       '  2 - 调用 auth().anonymouseProvider().signIn() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
-  public async signIn():Promise<ILoginState> {
+  public async signIn(): Promise<ILoginState> {
     // 匿名登录前迁移cache到localstorage
     await this._cache.updatePersistenceAsync('local');
     const { anonymousUuidKey, refreshTokenKey } = this._cache.keys;
@@ -40,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);
@@ -50,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);
@@ -58,25 +58,24 @@ 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',
+    }));
   }
   /**
    * 匿名转正
-   * @param ticket 
+   * @param ticket
    */
-  public async linkAndRetrieveDataWithTicket(ticket: string):Promise<ILoginState> {
-    if(!isString(ticket)){
-      throwError(ERRORS.INVALID_PARAMS,'ticket must be a string');
+  public async linkAndRetrieveDataWithTicket(ticket: string): Promise<ILoginState> {
+    if (!isString(ticket)) {
+      throwError(ERRORS.INVALID_PARAMS, 'ticket must be a string');
     }
     const { anonymousUuidKey, refreshTokenKey } = this._cache.keys;
     const anonymous_uuid = await this._cache.getStoreAsync(anonymousUuidKey);
@@ -84,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
@@ -96,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;
@@ -122,4 +120,4 @@ export class AnonymousAuthProvider extends AuthProvider {
     // 匿名转正后迁移cache
     await this._cache.updatePersistenceAsync(this._config.persistence);
   }
-}
+}

package/src/providers/base.ts

@@ -9,7 +9,7 @@ export abstract class AuthProvider {
   protected readonly _cache: ICloudbaseCache;
   protected readonly _request: ICloudbaseRequest;
 
-  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;
@@ -28,26 +28,25 @@ 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) {
+  protected async setRefreshToken(refreshToken: string) {
     const { accessTokenKey, accessTokenExpireKey, refreshTokenKey } = this._cache.keys;
     // refresh token设置前，先清掉 access token
     await this._cache.removeStoreAsync(accessTokenKey);
     await this._cache.removeStoreAsync(accessTokenExpireKey);
     await this._cache.setStoreAsync(refreshTokenKey, refreshToken);
   }
-  protected async setAccessToken(accessToken:string, accessTokenExpire:string) {
+  protected async setAccessToken(accessToken: string, accessTokenExpire: string) {
     const { accessTokenKey, accessTokenExpireKey } = this._cache.keys;
     await this._cache.setStoreAsync(accessTokenKey, accessToken);
     await this._cache.setStoreAsync(accessTokenExpireKey, accessTokenExpire);
@@ -62,5 +61,5 @@ export abstract class AuthProvider {
     const { userInfoKey } = this._cache.keys;
     await this._cache.setStoreAsync(userInfoKey, userInfo);
   }
-  abstract signIn(...args:any[]):Promise<any>;
-}
+  abstract signIn(...args: any[]): Promise<any>;
+}

package/src/providers/customAuthProvider.ts

@@ -10,7 +10,6 @@ const { isString } = utils;
 const { catchErrorsDecorator } = helpers;
 
 export class CustomAuthProvider extends AuthProvider {
-
   @catchErrorsDecorator({
     title: '自定义登录失败',
     messages: [
@@ -19,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
@@ -42,27 +41,26 @@ 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);
-      
+
       // set user info
       await this.refreshUserInfo();
-      
+
       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

@@ -1,4 +1,4 @@
-import { constants,utils,helpers } from '@cloudbase/utilities';
+import { constants, utils, helpers } from '@cloudbase/utilities';
 import { ILoginState } from '@cloudbase/types/auth';
 import { AuthProvider } from './base';
 import { LOGINTYPE } from '../constants';
@@ -16,19 +16,19 @@ 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)) {
-      throwError(ERRORS.INVALID_PARAMS,'email must be a string');
+      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) || ''
+      refresh_token: this._cache.getStore(refreshTokenKey) || '',
     });
     const { refresh_token, access_token, access_token_expire } = res;
     if (refresh_token) {
@@ -44,23 +44,23 @@ 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) {
-      throwError(ERRORS.OPERATION_FAIL,`Email login fail[${res.code}] ${res.message}`);
+    } 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');
     }
   }
   /**
    * 注册
-   * @param email 
-   * @param password 
+   * @param email
+   * @param password
    */
   @catchErrorsDecorator({
     title: '邮箱注册失败',
@@ -69,18 +69,18 @@ export class EmailAuthProvider extends AuthProvider {
       '  1 - 调用 auth().signUpWithEmailAndPassword() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱登录',
       '  3 - 此邮箱地址是否已经被其他用户占用',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
-  public async signUp(email:string, password:string) {
+  public async signUp(email: string, password: string) {
     return this._request.send('auth.signUpWithEmailAndPassword', {
       email,
-      password
+      password,
     });
   }
   /**
    * 发起重置密码请求，发起后推送邮件到指定邮箱
-   * @param email 
+   * @param email
    */
   @catchErrorsDecorator({
     title: '重置密码失败',
@@ -90,18 +90,18 @@ export class EmailAuthProvider extends AuthProvider {
       '  2 - 当前环境是否开通了邮箱登录',
       '  3 - 此邮箱地址是否已经与当前用户绑定',
       '  4 - 此邮箱地址是否已经被其他用户占用',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
-  public async resetPassword(email:string) {
+  public async resetPassword(email: string) {
     return this._request.send('auth.sendPasswordResetEmail', {
-      email
+      email,
     });
   }
   /**
    * 重置密码
-   * @param token 
-   * @param newPassword 
+   * @param token
+   * @param newPassword
    */
   @catchErrorsDecorator({
     title: '重置密码失败',
@@ -109,18 +109,18 @@ export class EmailAuthProvider extends AuthProvider {
       '请确认以下各项：',
       '  1 - 调用语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
-  public async resetPasswordWithToken(token:string, newPassword:string) {
+  public async resetPasswordWithToken(token: string, newPassword: string) {
     return this._request.send('auth.resetPasswordWithToken', {
       token,
-      newPassword
+      newPassword,
     });
   }
   /**
    * 激活邮箱
-   * @param token 
+   * @param token
    */
   @catchErrorsDecorator({
     title: '邮箱激活失败',
@@ -128,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';
@@ -11,8 +12,8 @@ const { catchErrorsDecorator } = helpers;
 export const SIGN_METHOD = {
   SIGNIN: 'SIGNIN',
   SIGNUP: 'SIGNUP',
-  FORCERESETPWD: 'FORCERESETPWD'
-}
+  FORCERESETPWD: 'FORCERESETPWD',
+};
 
 export class PhoneAuthProvider extends AuthProvider {
   @catchErrorsDecorator({
@@ -22,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
@@ -31,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');
     }
@@ -41,7 +42,7 @@ export class PhoneAuthProvider extends AuthProvider {
     }
 
     if (!signMethod) {
-      signMethod = SIGN_METHOD.SIGNIN
+      signMethod = SIGN_METHOD.SIGNIN;
     }
 
     const { refreshTokenKey } = this._cache.keys;
@@ -51,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) {
@@ -67,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');
     }
   }
   /**
@@ -92,16 +93,16 @@ export class PhoneAuthProvider extends AuthProvider {
       '请确认以下各项：',
       '  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,
+    });
   }
 
   /**
@@ -116,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

@@ -16,28 +16,28 @@ 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',
       }));
     }
     // 用户不设置密码
     if (typeof password !== 'string') {
       password = '';
-      printWarn(ERRORS.INVALID_PARAMS,'password is empty');
+      printWarn(ERRORS.INVALID_PARAMS, 'password is empty');
     }
 
     const { refreshTokenKey } = this._cache.keys;
-    const res = await this._request.send('auth.signIn',{
+    const res = await this._request.send('auth.signIn', {
       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;
@@ -54,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',
       }));
     }
   }