@cloudbase/auth 1.7.3-alpha.0 → 1.8.2

package/src/index.ts

@@ -1,23 +1,18 @@
+/* eslint-disable new-cap */
 import { ICloudbase } from '@cloudbase/types';
 import { events, adapters, utils, constants, helpers } from '@cloudbase/utilities';
 import { ICloudbaseCache } from '@cloudbase/types/cache';
 import { ICloudbaseRequest } from '@cloudbase/types/request';
 import { ICloudbaseAuthConfig, ICredential, IUser, IUserInfo, IAuthProvider, ILoginState } from '@cloudbase/types/auth';
 import { ICloudbaseComponent } from '@cloudbase/types/component';
-import { checkFromAuthV2 } from './common'
-
-import { LOGINTYPE, OAUTH2_LOGINTYPE_PREFIX } from './constants';
-
-import { AuthProvider } from './providers/base';
-
-import { OAuth2AuthProvider, IOAuth2AuthProviderOptions } from './providers/oauth2AuthProvider';
-
+import { WeixinAuthProvider } from './providers/weixinAuthProvider';
 import { AnonymousAuthProvider } from './providers/anonymousAuthProvider';
 import { CustomAuthProvider } from './providers/customAuthProvider';
+import { LOGINTYPE } from './constants';
+import { AuthProvider } from './providers/base';
 import { EmailAuthProvider } from './providers/emailAuthProvider';
-import { PhoneAuthProvider, SIGN_METHOD } from './providers/phoneAuthProvider'
 import { UsernameAuthProvider } from './providers/usernameAuthProvider';
-import { WeixinAuthProvider } from './providers/weixinAuthProvider';
+import { PhoneAuthProvider, SIGN_METHOD } from './providers/phoneAuthProvider';
 
 declare const cloudbase: ICloudbase;
 
@@ -97,12 +92,12 @@ class User implements IUser {
     this.avatarUrl = this._getLocalUserInfo('avatarUrl');
     this.email = this._getLocalUserInfo('email');
     this.hasPassword = Boolean(this._getLocalUserInfo('hasPassword'));
-    this.phone = this._getLocalUserInfo('phone')
-    this.username = this._getLocalUserInfo('username')
+    this.phone = this._getLocalUserInfo('phone');
+    this.username = this._getLocalUserInfo('username');
     this.location = {
       country: this._getLocalUserInfo('country'),
       province: this._getLocalUserInfo('province'),
-      city: this._getLocalUserInfo('city')
+      city: this._getLocalUserInfo('city'),
     };
   }
   /**
@@ -122,12 +117,12 @@ class User implements IUser {
     this.avatarUrl = await this._getLocalUserInfoAsync('avatarUrl');
     this.email = await this._getLocalUserInfoAsync('email');
     this.hasPassword = Boolean(await this._getLocalUserInfoAsync('hasPassword'));
-    this.phone = await this._getLocalUserInfoAsync('phone')
-    this.username = await this._getLocalUserInfoAsync('username')
+    this.phone = await this._getLocalUserInfoAsync('phone');
+    this.username = await this._getLocalUserInfoAsync('username');
     this.location = {
       country: await this._getLocalUserInfoAsync('country'),
       province: await this._getLocalUserInfoAsync('province'),
-      city: await this._getLocalUserInfoAsync('city')
+      city: await this._getLocalUserInfoAsync('city'),
     };
   }
 
@@ -143,8 +138,8 @@ class User implements IUser {
       '  2 - 此账户是否已经绑定自定义登录',
       '  3 - ticket 参数是否归属当前环境',
       '  4 - 创建 ticket 的自定义登录私钥是否过期',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public linkWithTicket(ticket: string): Promise<void> {
     if (typeof ticket !== 'string') {
@@ -163,8 +158,8 @@ class User implements IUser {
       '  1 - 调用 User.linkWithRedirect() 的语法或参数是否正确',
       '  2 - 此账户是否已经绑定此第三方',
       '  3 - 此第三方是否已经授权',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public linkWithRedirect(provider: IAuthProvider): void {
     provider.signInWithRedirect();
@@ -177,8 +172,8 @@ class User implements IUser {
     messages: [
       '请确认以下各项：',
       '  1 - 调用 User.getLinkedUidList() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async getLinkedUidList() {
     const { data } = await this._request.send('auth.getLinkedUidList', {});
@@ -192,7 +187,7 @@ class User implements IUser {
     }
     return {
       users,
-      hasPrimaryUid
+      hasPrimaryUid,
     };
   }
   /**
@@ -205,8 +200,8 @@ class User implements IUser {
     messages: [
       '请确认以下各项：',
       '  1 - 调用 User.setPrimaryUid() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public setPrimaryUid(uid: string) {
     return this._request.send('auth.setPrimaryUid', { uid });
@@ -221,8 +216,8 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用 User.unlink() 的语法或参数是否正确',
       '  2 - 当前账户是否已经与此登录方式解绑',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public unlink(loginType: 'CUSTOM' | 'WECHAT-OPEN' | 'WECHAT-PUBLIC' | 'WECHAT-UNION' | 'PHONE') {
     return this._request.send('auth.unlink', { platform: loginType });
@@ -237,8 +232,8 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用 User.update() 的语法或参数是否正确',
       '  2 - 用户信息中是否包含非法值',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async update(userInfo: IUserInfo): Promise<void> {
     const { nickName, gender, avatarUrl, province, country, city } = userInfo;
@@ -256,13 +251,13 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用 User.updatePassword() 的语法或参数是否正确',
       '  3 - 新密码中是否包含非法字符',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public updatePassword(newPassword: string, oldPassword: string) {
     return this._request.send('auth.updatePassword', {
       oldPassword,
-      newPassword
+      newPassword,
     });
   }
   /**
@@ -275,13 +270,13 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用 User.updateEmail() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了邮箱密码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public updateEmail(newEmail: string, password?: string) {
     return this._request.send('auth.updateEmail', {
       newEmail,
-      password
+      password,
     });
   }
   /**
@@ -294,8 +289,8 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用 User.updateUsername() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了用户名密码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public updateUsername(username: string) {
     if (typeof username !== 'string') {
@@ -303,7 +298,7 @@ class User implements IUser {
     }
 
     return this._request.send('auth.updateUsername', {
-      username
+      username,
     });
   }
   /**
@@ -314,8 +309,8 @@ class User implements IUser {
     messages: [
       '请确认以下各项：',
       '  1 - 调用 User.refresh() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async refresh(): Promise<IUserInfo> {
     const action = 'auth.getUserInfo';
@@ -335,13 +330,13 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用 auth().linkWithPhoneNumber() 的语法或参数是否正确',
       '  2 - 当前环境是否开通了短信验证码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async linkWithPhoneNumber(phoneNumber: string, phoneCode: string) {
     return this._request.send('auth.linkOrUpdatePhoneNumber', {
       phoneNumber: transformPhone(phoneNumber),
-      phoneCode
+      phoneCode,
     });
   }
   /**
@@ -355,13 +350,13 @@ class User implements IUser {
       '请确认以下各项：',
       '  1 - 调用语法或参数是否正确',
       '  2 - 当前环境是否开通了短信验证码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async updatePhoneNumber(phoneNumber: string, phoneCode: string) {
     return this._request.send('auth.linkOrUpdatePhoneNumber', {
       phoneNumber: transformPhone(phoneNumber),
-      phoneCode
+      phoneCode,
     });
   }
 
@@ -395,15 +390,15 @@ class User implements IUser {
       'gender',
       'avatarUrl',
       'phone',
-      'username'
-    ].forEach(infoKey => {
+      'username',
+    ].forEach((infoKey) => {
       this[infoKey] = userInfo[infoKey];
     });
 
     this.location = {
-      country: userInfo['country'],
-      province: userInfo['province'],
-      city: userInfo['city']
+      country: userInfo.country,
+      province: userInfo.province,
+      city: userInfo.city,
     };
   }
 
@@ -432,7 +427,7 @@ export class LoginState implements ILoginState {
 
     this.user = new User({
       cache,
-      request
+      request,
     });
   }
 
@@ -446,7 +441,7 @@ export class LoginState implements ILoginState {
     this.credential = {
       refreshToken,
       accessToken,
-      accessTokenExpire
+      accessTokenExpire,
     };
 
     this._loginType = this._cache.getStore(this._cache.keys.loginTypeKey);
@@ -462,7 +457,7 @@ export class LoginState implements ILoginState {
     this.credential = {
       refreshToken,
       accessToken,
-      accessTokenExpire
+      accessTokenExpire,
     };
 
     this._loginType = await this._cache.getStoreAsync(this._cache.keys.loginTypeKey);
@@ -488,17 +483,17 @@ export class LoginState implements ILoginState {
   }
 
   get loginType() {
-    return this._loginType
+    return this._loginType;
   }
 
   get isPhoneAuth() {
-    return this.loginType === LOGINTYPE.PHONE
+    return this.loginType === LOGINTYPE.PHONE;
   }
 }
 
 class Auth {
   private readonly _config: ICloudbaseAuthConfig;
-  private readonly _cache: ICloudbaseCache
+  private readonly _cache: ICloudbaseCache;
   private readonly _request: ICloudbaseRequest;
   private readonly _runtime: string;
   private _anonymousAuthProvider: AnonymousAuthProvider;
@@ -507,16 +502,12 @@ class Auth {
   private _emailAuthProvider: EmailAuthProvider;
   private _usernameAuthProvider: UsernameAuthProvider;
   private _phoneAuthProvider: PhoneAuthProvider;
-  // private _fromApp: ICloudbase
-
-  private _oAuth2AuthProvider: OAuth2AuthProvider;
 
   constructor(config: ICloudbaseAuthConfig & { cache: ICloudbaseCache, request: ICloudbaseRequest, runtime?: string }) {
     this._config = config;
     this._cache = config.cache;
     this._request = config.request;
-    this._runtime = config.runtime || RUNTIME.WEB
-    // this._fromApp = config._fromApp
+    this._runtime = config.runtime || RUNTIME.WEB;
 
     eventBus.on(EVENTS.LOGIN_TYPE_CHANGED, this._onLoginTypeChanged.bind(this));
   }
@@ -527,7 +518,7 @@ class Auth {
   get currentUser() {
     if (this._cache.mode === 'async') {
       // async storage的平台调用此API提示
-      printWarn(ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use getCurrenUser insteed');
+      printWarn(ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use getCurrentUser insteed');
       return;
     }
 
@@ -535,9 +526,8 @@ class Auth {
 
     if (loginState) {
       return loginState.user || null;
-    } else {
-      return null;
     }
+    return null;
   }
 
   /**
@@ -548,6 +538,7 @@ class Auth {
   }
 
   /**
+   * @deprecated
    * 获取当前登录的用户信息-异步
    */
   @catchErrorsDecorator({
@@ -555,24 +546,30 @@ class Auth {
     messages: [
       '请确认以下各项：',
       '  1 - 调用 auth().getCurrenUser() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async getCurrenUser() {
-    const { _fromApp } = this._config
-    const authObj = await checkFromAuthV2(_fromApp)
-    const { authType, instance } = authObj
-    if (authType === 'oauth') {
-      return await instance.getUserInfo()
-    }
-
+    return await this.getCurrentUser();
+  }
+  /**
+   * 获取当前登录的用户信息-异步
+   */
+  @catchErrorsDecorator({
+    title: '获取用户信息失败',
+    messages: [
+      '请确认以下各项：',
+      '  1 - 调用 auth().getCurrentUser() 的语法或参数是否正确',
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
+  })
+  public async getCurrentUser() {
     const loginState = await this.getLoginState();
     if (loginState) {
       await loginState.user.checkLocalInfoAsync();
       return loginState.user || null;
-    } else {
-      return null;
     }
+    return null;
   }
   /**
    * 获取当前登录类型-异步
@@ -583,7 +580,7 @@ class Auth {
   public async getAccessToken() {
     return {
       accessToken: (await this._request.getAccessToken()).accessToken,
-      env: this._config.env
+      env: this._config.env,
     };
   }
   public weixinAuthProvider({ appid, scope, state }): WeixinAuthProvider {
@@ -592,7 +589,7 @@ class Auth {
         ...this._config,
         cache: this._cache,
         request: this._request,
-        runtime: this._runtime
+        runtime: this._runtime,
       }, appid, scope, state);
     }
     return this._weixinAuthProvider;
@@ -603,7 +600,6 @@ class Auth {
         ...this._config,
         cache: this._cache,
         request: this._request,
-        // _fromApp: this._fromApp
       });
     }
     return this._anonymousAuthProvider;
@@ -613,7 +609,7 @@ class Auth {
       this._customAuthProvider = new CustomAuthProvider({
         ...this._config,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
     }
     return this._customAuthProvider;
@@ -623,7 +619,7 @@ class Auth {
       this._emailAuthProvider = new EmailAuthProvider({
         ...this._config,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
     }
     return this._emailAuthProvider;
@@ -633,7 +629,7 @@ class Auth {
       this._usernameAuthProvider = new UsernameAuthProvider({
         ...this._config,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
     }
     return this._usernameAuthProvider;
@@ -644,53 +640,11 @@ class Auth {
       this._phoneAuthProvider = new PhoneAuthProvider({
         ...this._config,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
     }
     return this._phoneAuthProvider;
   }
-
-  /**
-   * oAuth2AuthProvider
-   * options
-   * {
-   *   providerId: 'google',
-   *   scope: 'openid+email+profile',
-   *   redirectUri: 'https://'
-   * }
-   * @param {Object}  options
-   * @param {string}  options.providerId            - 供应商Id，如 WeChat、Google、Github 等
-   * @param {string}  options.clientId              - 客户端Id，平台提供的客户端标识Id
-   * @param {string}  [options.responseType=token]  - 响应类型：token、code
-   * @param {string}  options.scope                 - 权限范围
-   * @param {string}  options.redirectUri           - 授权成功回调地址
-   * @param {boolean} options.syncProfile           - 是否同步用户 Profile 信息
-   * @param {boolean} options.forceDisableSignUp    - 是否强制关闭用户注册
-   * @returns
-   */
-  public oAuth2AuthProvider(options: IOAuth2AuthProviderOptions = {}): OAuth2AuthProvider {
-    if (!this._oAuth2AuthProvider) {
-      this._oAuth2AuthProvider = new OAuth2AuthProvider({
-        ...this._config,
-        cache: this._cache,
-        request: this._request,
-        runtime: this._runtime
-      }, options)
-    }
-    return this._oAuth2AuthProvider
-  }
-
-  /**
-   * signWithOAuth2Popup - OAuth2弹窗登录
-   */
-  public signWithOAuth2Popup() {
-    this._oAuth2AuthProvider.signInWithPopup()
-  }
-
-  public signInWithOAuth2Modal(elemId: string) {
-    this._oAuth2AuthProvider.signInWithModal(elemId)
-  }
-
   /**
    * 用户名密码登录
    * @param username
@@ -708,8 +662,8 @@ class Auth {
     messages: [
       '请确认以下各项：',
       '  1 - 调用 auth().isUsernameRegistered() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async isUsernameRegistered(username: string): Promise<boolean> {
     if (typeof username !== 'string') {
@@ -717,7 +671,7 @@ class Auth {
     }
 
     const { data } = await this._request.send('auth.isUsernameRegistered', {
-      username
+      username,
     });
     return data?.isRegistered;
   }
@@ -753,83 +707,39 @@ class Auth {
       '请确认以下各项：',
       '  1 - 调用 auth().signOut() 的语法或参数是否正确',
       '  2 - 当前用户是否为匿名登录（匿名登录不支持signOut）',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async signOut() {
-    // 兼容 oauth
-    const { _fromApp } = this._config
-    const authObj = await checkFromAuthV2(_fromApp)
-    const { authType, instance } = authObj
-    if (authType === 'oauth') {
-      return await instance.signOut()
-    }
-
-    const loginType = await this.getLoginType()
+    // const loginType = await this.getLoginType();
     // if (loginType === LOGINTYPE.ANONYMOUS) {
     //   throw new Error(JSON.stringify({
     //     code: ERRORS.INVALID_OPERATION,
     //     msg: 'anonymous user doesn\'t support signOut action'
-    //   }))
+    //   }));
     // }
-    const { refreshTokenKey, accessTokenKey, accessTokenExpireKey } = this._cache.keys
+    const { refreshTokenKey, accessTokenKey, accessTokenExpireKey } = this._cache.keys;
+    const action = 'auth.logout';
 
     const refresh_token = await this._cache.getStoreAsync(refreshTokenKey);
     if (!refresh_token) {
-      return
-    }
-
-    if (loginType.startsWith(OAUTH2_LOGINTYPE_PREFIX)) {
-      const accessToken = await this._cache.getStoreAsync(accessTokenKey)
-      const accessTokenExpire = Number(await this._cache.getStoreAsync(accessTokenExpireKey))
-      if (accessToken) {
-        if (Date.now() < accessTokenExpire) {
-          const resp = await this._request.fetch('/auth/v1/revoke', {
-            method: 'POST',
-            headers: {
-              'Accept': 'application/json',
-              'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({
-              token: accessToken
-            })
-          })
-          const seqIdFromHeader = resp.headers.get('SeqId') || resp.headers.get('RequestId')
-          if (resp.status >= 400 && resp.status < 500) {
-            const body: any = await resp.json()
-            const seqId = body.request_id || seqIdFromHeader
-            throw new Error(`[OAuth2AuthProvider][status:${resp.status}][${body.error}(${body.error_code})] ${body.error_description} (${seqId})`)
-          }
-          else if (resp.status >= 500) {
-            const body: any = await resp.json()
-            const seqId = body.request_id || seqIdFromHeader
-            throw new Error(`[OAuth2AuthProvider][status:${resp.status}][${body.error}(${body.error_code})] ${body.error_description} (${seqId})`)
-          }
-        }
-        else {
-          // console.warn(`[SignOut] accesstoken expired`)
-        }
-      }
-      else {
-        // console.warn(`[SignOut] accesstoken not exists`)
-      }
-    }
-    else {
-      await this._request.send('auth.logout', { refresh_token })
+      return;
     }
+    const res = await this._request.send(action, { refresh_token });
 
-    this._cache.removeStoreAsync(refreshTokenKey)
-    this._cache.removeStoreAsync(accessTokenKey)
-    this._cache.removeStoreAsync(accessTokenExpireKey)
+    this._cache.removeStoreAsync(refreshTokenKey);
+    this._cache.removeStoreAsync(accessTokenKey);
+    this._cache.removeStoreAsync(accessTokenExpireKey);
 
-    eventBus.fire(EVENTS.LOGIN_STATE_CHANGED)
+    eventBus.fire(EVENTS.LOGIN_STATE_CHANGED);
     eventBus.fire(EVENTS.LOGIN_TYPE_CHANGED, {
       env: this._config.env,
       loginType: LOGINTYPE.NULL,
-      persistence: this._config.persistence
-    })
+      persistence: this._config.persistence,
+    });
+
 
-    return true
+    return res;
   }
   public async onLoginStateChanged(callback: Function) {
     eventBus.on(EVENTS.LOGIN_STATE_CHANGED, async () => {
@@ -859,14 +769,6 @@ class Auth {
    * 获取本地登录态-同步
    */
   public hasLoginState(): ILoginState | null {
-    // 兼容oauth 逻辑，判断当前登录体系 auth or oauth
-    const { _fromApp } = this._config
-    const oauthInstance = _fromApp.oauthInstance
-    const oauthLoginState = oauthInstance?.hasLoginStateSync()
-    if (oauthLoginState) {
-      return oauthLoginState
-    }
-
     if (this._cache.mode === 'async') {
       // async storage的平台调用此API提示
       printWarn(ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use getLoginState insteed');
@@ -879,13 +781,12 @@ class Auth {
       const loginState = new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
       loginState.checkLocalState();
       return loginState;
-    } else {
-      return null;
     }
+    return null;
   }
   /**
    * 获取本地登录态-异步
@@ -896,38 +797,22 @@ class Auth {
     messages: [
       '请确认以下各项：',
       '  1 - 调用 auth().getLoginState() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async getLoginState() {
-    // 检查当前登录体系 auth or oauth
-    // const { _fromApp } = this._config
-    // const authObj = await checkFromAuthV1OrV2(_fromApp)
-    // const { authType, instance } = authObj
-    // if (authType === 'oauth') {
-    //   return await instance.getLoginState()
-    // }
-    const { _fromApp } = this._config
-    const oauthInstance = _fromApp.oauthInstance || (_fromApp as any).oauth()
-    const oauthLoginState = oauthInstance && await oauthInstance.getLoginState()
-    if (oauthLoginState) {
-      return oauthLoginState
-    }
-
-    // auth 体系走默认逻辑
     const { refreshTokenKey } = this._cache.keys;
     const refreshToken = await this._cache.getStoreAsync(refreshTokenKey);
     if (refreshToken) {
       const loginState = new LoginState({
         envId: this._config.env,
         cache: this._cache,
-        request: this._request
+        request: this._request,
       });
       await loginState.checkLocalStateAsync();
       return loginState;
-    } else {
-      return null;
     }
+    return null;
   }
 
   public shouldRefreshAccessToken(hook) {
@@ -940,8 +825,8 @@ class Auth {
       '请确认以下各项：',
       '  1 - 是否已登录',
       '  2 - 调用 auth().getUserInfo() 的语法或参数是否正确',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async getUserInfo(): Promise<any> {
     const action = 'auth.getUserInfo';
@@ -949,12 +834,11 @@ class Auth {
     const res = await this._request.send(action, {});
     if (res.code) {
       return res;
-    } else {
-      return {
-        ...res.data,
-        requestId: res.seqId
-      };
     }
+    return {
+      ...res.data,
+      requestId: res.seqId,
+    };
   }
   /**
    * 获取Http鉴权header，用于云接入 HTTP 访问云函数时的鉴权
@@ -964,7 +848,7 @@ class Auth {
     const refreshToken = this._cache.getStore(refreshTokenKey);
     const accessToken = this._cache.getStore(accessTokenKey);
     return {
-      'x-cloudbase-credentials': accessToken + '/@@/' + refreshToken
+      'x-cloudbase-credentials': `${accessToken}/@@/${refreshToken}`,
     };
   }
   /**
@@ -978,7 +862,7 @@ class Auth {
     const refreshToken = await this._cache.getStoreAsync(refreshTokenKey);
     const accessToken = await this._cache.getStoreAsync(accessTokenKey);
     return {
-      'x-cloudbase-credentials': accessToken + '/@@/' + refreshToken
+      'x-cloudbase-credentials': `${accessToken}/@@/${refreshToken}`,
     };
   }
 
@@ -993,14 +877,14 @@ class Auth {
       '请确认以下各项：',
       '  1 - 调用语法或参数是否正确',
       '  2 - 当前环境是否开通了短信验证码登录',
-      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`
-    ]
+      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,
+    ],
   })
   public async sendPhoneCode(phoneNumber: string): Promise<boolean> {
     const { data } = await this._request.send('auth.sendPhoneCode', {
-      phoneNumber: transformPhone(phoneNumber)
+      phoneNumber: transformPhone(phoneNumber),
     });
-    return data.SendStatus === 'Ok'
+    return data.SendStatus === 'Ok';
   }
 
   /**
@@ -1033,7 +917,7 @@ class Auth {
   }) {
     return this.phoneAuthProvider().signIn({
       ...param,
-      signMethod: SIGN_METHOD.FORCERESETPWD
+      signMethod: SIGN_METHOD.FORCERESETPWD,
     });
   }
 
@@ -1058,7 +942,7 @@ const EVENTS = {
   // 匿名账户被转正后触发
   ANONYMOUS_CONVERTED: 'anonymousConverted',
   // access token刷新后触发
-  ACCESS_TOKEN_REFRESHD: 'refreshAccessToken'
+  ACCESS_TOKEN_REFRESHD: 'refreshAccessToken',
 };
 
 const component: ICloudbaseComponent = {
@@ -1071,10 +955,10 @@ const component: ICloudbaseComponent = {
       EVENTS.LOGIN_STATE_EXPIRED,
       EVENTS.LOGIN_STATE_CHANGED,
       EVENTS.ACCESS_TOKEN_REFRESHD,
-      EVENTS.ANONYMOUS_CONVERTED
-    ]
+      EVENTS.ANONYMOUS_CONVERTED,
+    ],
   },
-  entity: function (config: Pick<ICloudbaseAuthConfig, 'region' | 'persistence'> = { region: '', persistence: 'local' }) {
+  entity(config: Pick<ICloudbaseAuthConfig, 'region' | 'persistence'> = { region: '', persistence: 'local' }) {
     if (this.authInstance) {
       printWarn(ERRORS.INVALID_OPERATION, 'every cloudbase instance should has only one auth object');
       return this.authInstance;
@@ -1083,7 +967,7 @@ const component: ICloudbaseComponent = {
     // 如不明确指定persistence则优先取各平台adapter首选，其次session
     const newPersistence = config.persistence || adapter.primaryStorage;
     if (newPersistence && (newPersistence !== this.config.persistence)) {
-      this.updateConfig({ persistence: newPersistence })
+      this.updateConfig({ persistence: newPersistence });
     }
 
     const { env, persistence, debug } = this.config;
@@ -1094,12 +978,11 @@ const component: ICloudbaseComponent = {
       debug,
       cache: this.cache,
       request: this.request,
-      runtime: runtime,
-      _fromApp: this
+      runtime,
     });
     return this.authInstance;
-  }
-}
+  },
+};
 
 try {
   // 尝试自动注册至全局变量cloudbase
@@ -1112,7 +995,7 @@ export {
   Auth,
   AuthProvider,
   EVENTS,
-  eventBus
+  eventBus,
 };
 /**
  * @api 手动注册至cloudbase app
@@ -1145,9 +1028,9 @@ export function registerProvider(name: string, provider: IProvider) {
     if (!this[privateName]) {
       this[privateName] = new provider({
         ...options,
-        ...this._config
+        ...this._config,
       });
     }
     return this[privateName];
   };
-}
+}