@cloudbase/oauth 3.0.0 → 3.0.1

package/dist/esm/captcha/captcha.d.ts

@@ -1,7 +1,9 @@
 import { SimpleStorage, RequestFunction } from '../oauth2client/interface';
 import { AuthClientRequestOptions } from '../oauth2client/models';
 import { SDKAdapterInterface } from '@cloudbase/adapter-interface';
+import { Auth } from '../auth/apis';
 export interface CaptchaOptions {
+    env: string;
     clientId: string;
     request: RequestFunction;
     storage: SimpleStorage;
@@ -9,6 +11,7 @@ export interface CaptchaOptions {
     adapter?: SDKAdapterInterface & {
         isMatch?: () => boolean;
     };
+    oauthInstance?: Auth;
 }
 type OpenURIWithCallbackFuction = (url: string) => Promise<CaptchaToken>;
 export interface CaptchaToken {
@@ -31,7 +34,6 @@ export declare class Captcha {
     isMatch(): boolean;
     request<T>(url: string, options?: CaptchaRequestOptions): Promise<T>;
     private getDefaultOpenURIWithCallback;
-    private defaultOpenURIWithCallback;
     private getCaptchaToken;
     private appendCaptchaTokenToURL;
     private saveCaptchaToken;

package/dist/esm/captcha/captcha.js

@@ -1,7 +1,7 @@
 import { ApiUrls, ErrorType } from '../auth/consts';
 import { defaultStorage } from '../oauth2client/oauth2client';
-import { isInMpWebView, isMp } from '../utils/mp';
-import MyURLSearchParams from '../utils/urlSearchParams';
+import { isMp } from '../utils/mp';
+import { openURIWithCallback } from './captcha-dom';
 export class Captcha {
     constructor(opts) {
         if (!opts.openURIWithCallback) {
@@ -11,7 +11,7 @@ export class Captcha {
             opts.storage = defaultStorage;
         }
         this.config = opts;
-        this.tokenSectionName = `captcha_${opts.clientId}`;
+        this.tokenSectionName = `captcha_${opts.clientId || opts.env}`;
     }
     isMatch() {
         return this.config?.adapter?.isMatch?.() || isMp();
@@ -42,65 +42,7 @@ export class Captcha {
         return resp;
     }
     getDefaultOpenURIWithCallback() {
-        if (!this.isMatch() && !isInMpWebView()) {
-            if (window.location.search.indexOf('__captcha') > 0) {
-                document.body.style.display = 'none';
-            }
-            if (document.getElementById('captcha_panel_wrap') === null) {
-                const elementDiv = document.createElement('div');
-                elementDiv.style.cssText = 'background-color: rgba(0, 0, 0, 0.7);position: fixed;left: 0px;right: 0px;top: 0px;bottom: 0px;padding: 9vw 0 0 0;display: none;z-index:100;';
-                elementDiv.setAttribute('id', 'captcha_panel_wrap');
-                setTimeout(() => {
-                    document.body.appendChild(elementDiv);
-                }, 0);
-            }
-        }
-        return this.defaultOpenURIWithCallback;
-    }
-    async defaultOpenURIWithCallback(url, opts) {
-        const { width = '355px', height = '355px' } = opts || {};
-        const matched = url.match(/^(data:.*)$/);
-        if (matched) {
-            return Promise.reject({
-                error: ErrorType.UNIMPLEMENTED,
-                error_description: 'need to impl captcha data',
-            });
-        }
-        const target = document.getElementById('captcha_panel_wrap');
-        const iframe = document.createElement('iframe');
-        target.innerHTML = '';
-        iframe.setAttribute('src', url);
-        iframe.setAttribute('id', 'review-panel-iframe');
-        iframe.style.cssText = `min-width:${width};display:block;height:${height};margin:0 auto;background-color: rgb(255, 255, 255);border: none;`;
-        target.appendChild(iframe);
-        target.style.display = 'block';
-        return new Promise((resolve, reject) => {
-            iframe.onload = function () {
-                try {
-                    const windowLocation = window.location;
-                    const iframeLocation = iframe.contentWindow.location;
-                    if (iframeLocation.host + iframeLocation.pathname === windowLocation.host + windowLocation.pathname) {
-                        target.style.display = 'none';
-                        const iframeUrlParams = new MyURLSearchParams(iframeLocation.search);
-                        const captchToken = iframeUrlParams.get('captcha_token');
-                        if (captchToken) {
-                            return resolve({
-                                captcha_token: captchToken,
-                                expires_in: Number(iframeUrlParams.get('expires_in')),
-                            });
-                        }
-                        return reject({
-                            error: iframeUrlParams.get('error'),
-                            error_description: iframeUrlParams.get('error_description'),
-                        });
-                    }
-                    target.style.display = 'block';
-                }
-                catch (error) {
-                    target.style.display = 'block';
-                }
-            };
-        });
+        return (url) => openURIWithCallback(url, this.config.oauthInstance);
     }
     async getCaptchaToken(forceNewToken, state) {
         if (!forceNewToken) {
@@ -109,41 +51,16 @@ export class Captcha {
                 return captchaToken;
             }
         }
-        let captchaTokenResp;
-        if (!this.isMatch() && !isInMpWebView()) {
-            const redirect_uri = `${window.location.origin + window.location.pathname}?__captcha=on`;
-            captchaTokenResp = await this.config.request(ApiUrls.GET_CAPTCHA_URL, {
-                method: 'POST',
-                body: {
-                    client_id: this.config.clientId,
-                    redirect_uri,
-                    state,
-                },
-                withCredentials: false,
-            });
-            if (captchaTokenResp.captcha_token) {
-                const captchaToken = {
-                    captcha_token: captchaTokenResp.captcha_token,
-                    expires_in: captchaTokenResp.expires_in,
-                };
-                this.saveCaptchaToken(captchaToken);
-                return captchaTokenResp.captcha_token;
-            }
-        }
-        else {
-            const captchaDataResp = await this.config.request(ApiUrls.CAPTCHA_DATA_URL, {
-                method: 'POST',
-                body: {
-                    state,
-                    redirect_uri: '',
-                },
-                withCredentials: false,
-            });
-            captchaTokenResp = {
-                url: `${captchaDataResp.data}?state=${encodeURIComponent(state)}&token=${encodeURIComponent(captchaDataResp.token)}`,
-            };
-        }
-        const captchaToken = await this.config.openURIWithCallback(captchaTokenResp.url);
+        const captchaDataResp = await this.config.request(ApiUrls.CAPTCHA_DATA_URL, {
+            method: 'POST',
+            body: {
+                state,
+                redirect_uri: '',
+            },
+            withCredentials: false,
+        });
+        const captchaTokenUrl = `${captchaDataResp.data}?state=${encodeURIComponent(state)}&token=${encodeURIComponent(captchaDataResp.token)}`;
+        const captchaToken = await this.config.openURIWithCallback(captchaTokenUrl);
         this.saveCaptchaToken(captchaToken);
         return captchaToken.captcha_token;
     }

package/dist/esm/index.d.ts

@@ -1,13 +1,23 @@
 import { OAuth2Client } from './oauth2client/oauth2client';
 import { AuthOptions, Auth } from './auth/apis';
+import { Credentials } from './oauth2client/models';
 export { Auth } from './auth/apis';
-export { AUTH_API_PREFIX } from './auth/consts';
+export { AUTH_API_PREFIX, OAUTH_TYPE } from './auth/consts';
+export { AuthError } from './auth/auth-error';
 export * as authModels from './auth/models';
-export type { ProviderProfile } from './auth/models';
+export type { ProviderProfile, UserInfo, ModifyUserBasicInfoRequest } from './auth/models';
 export type { Credentials, OAuth2ClientOptions, ResponseError, AuthClientRequestOptions } from './oauth2client/models';
 export type { AuthOptions } from './auth/apis';
+export { weAppJwtDecodeAll } from './utils/base64';
+export { LOGIN_STATE_CHANGED_TYPE, EVENTS, AUTH_STATE_CHANGED_TYPE } from './auth/consts';
 export declare class CloudbaseOAuth {
     oauth2client: OAuth2Client;
     authApi: Auth;
+    private detectSessionInUrl;
     constructor(authOptions: AuthOptions);
+    initializeSession(onUserObtained?: (data: {
+        session: Credentials;
+        user?: any;
+        type?: string;
+    }, error?: any) => void | Promise<void>): void;
 }

package/dist/esm/index.js

@@ -2,12 +2,16 @@ import { OAuth2Client } from './oauth2client/oauth2client';
 import { Auth } from './auth/apis';
 import { AUTH_API_PREFIX } from './auth/consts';
 export { Auth } from './auth/apis';
-export { AUTH_API_PREFIX } from './auth/consts';
+export { AUTH_API_PREFIX, OAUTH_TYPE } from './auth/consts';
+export { AuthError } from './auth/auth-error';
 import * as authModels_1 from './auth/models';
 export { authModels_1 as authModels };
+export { weAppJwtDecodeAll } from './utils/base64';
+export { LOGIN_STATE_CHANGED_TYPE, EVENTS, AUTH_STATE_CHANGED_TYPE } from './auth/consts';
 export class CloudbaseOAuth {
     constructor(authOptions) {
-        const { apiOrigin, apiPath = AUTH_API_PREFIX, clientId, env, storage, request, baseRequest, anonymousSignInFunc, wxCloud, adapter, onCredentialsError, headers, i18n, publishable_key } = authOptions;
+        const { apiOrigin, apiPath = AUTH_API_PREFIX, clientId, env, storage, request, baseRequest, anonymousSignInFunc, wxCloud, adapter, onCredentialsError, headers, i18n, useWxCloud, eventBus, detectSessionInUrl, debug, } = authOptions;
+        this.detectSessionInUrl = detectSessionInUrl ?? false;
         this.oauth2client = new OAuth2Client({
             apiOrigin,
             apiPath,
@@ -20,7 +24,9 @@ export class CloudbaseOAuth {
             onCredentialsError,
             headers: headers || {},
             i18n,
-            publishable_key,
+            useWxCloud,
+            eventBus,
+            debug,
         });
         this.authApi = new Auth({
             credentialsClient: this.oauth2client,
@@ -28,5 +34,16 @@ export class CloudbaseOAuth {
             request: request ? this.oauth2client.request.bind(this.oauth2client) : undefined,
             adapter,
         });
+        if (detectSessionInUrl) {
+            this.oauth2client.setGetInitialSession(this.authApi.getInitialSession.bind(this.authApi));
+        }
+    }
+    initializeSession(onUserObtained) {
+        if (!this.detectSessionInUrl) {
+            this.oauth2client.initialize(Promise.resolve({ error: null }));
+            return;
+        }
+        this.oauth2client.setOnInitialSessionObtained(onUserObtained);
+        this.oauth2client.initialize();
     }
 }

package/dist/esm/oauth2client/interface.d.ts

@@ -1,7 +1,7 @@
 import { Credentials, AuthClientRequestOptions } from './models';
 export declare abstract class AuthClient {
     abstract request: RequestFunction;
-    abstract setCredentials(credentials?: Credentials): void;
+    abstract setCredentials(credentials?: Credentials): Promise<void>;
     abstract getAccessToken(): Promise<string>;
 }
 export type RequestFunction = <T>(url: string, options?: AuthClientRequestOptions) => Promise<T>;

package/dist/esm/oauth2client/models.d.ts

@@ -35,6 +35,7 @@ export interface AuthClientRequestOptions extends RequestOptions {
     withBasicAuth?: boolean;
     retry?: number;
     useWxCloud?: boolean;
+    getCredentials?: () => Credentials | Promise<Credentials | null> | null;
     [key: string]: any;
 }
 export interface OAuth2ClientOptions {
@@ -56,5 +57,18 @@ export interface OAuth2ClientOptions {
     wxCloud?: any;
     onCredentialsError?: AuthOptions['onCredentialsError'];
     i18n?: ICloudbaseConfig['i18n'];
-    publishable_key?: string;
+    useWxCloud?: boolean;
+    eventBus?: any;
+    debug?: boolean;
+    getInitialSession?: () => Promise<{
+        data: {
+            session: Credentials;
+            user?: any;
+        } | null;
+        error: Error | null;
+    }>;
+    onInitialSessionObtained?: (data: {
+        session: Credentials;
+        user?: any;
+    }) => void | Promise<void>;
 }

package/dist/esm/oauth2client/oauth2client.d.ts

@@ -23,11 +23,45 @@ declare class DefaultStorage implements SimpleStorage {
     setItemSync(key: string, value: string): void;
 }
 export declare const defaultStorage: DefaultStorage;
+interface LocalCredentialsOptions {
+    tokenSectionName: string;
+    storage: SimpleStorage;
+    clientId: string;
+    credentials?: Credentials;
+}
+declare class LocalCredentials {
+    private tokenSectionName;
+    private storage;
+    private clientId;
+    private credentials;
+    private accessKeyCredentials;
+    private singlePromise;
+    constructor(options: LocalCredentialsOptions);
+    getStorageCredentialsSync(): Credentials | null;
+    setCredentials(credentials?: Credentials): Promise<void>;
+    setAccessKeyCredentials(credentials?: Credentials): void;
+    getCredentials(): Promise<Credentials | null>;
+    private getStorageCredentials;
+}
 export declare class OAuth2Client implements AuthClient {
     private static defaultRetry;
     private static minRetry;
     private static maxRetry;
     private static retryInterval;
+    localCredentials: LocalCredentials;
+    initializePromise: Promise<{
+        error: Error | null;
+    }> | null;
+    protected lockAcquired: boolean;
+    protected pendingInLock: Promise<any>[];
+    protected logDebugMessages: boolean;
+    protected getInitialSession?: () => Promise<{
+        data: {
+            session: Credentials;
+            user?: any;
+        } | null;
+        error: Error | null;
+    }>;
     private apiOrigin;
     private apiPath;
     private clientId;
@@ -35,7 +69,6 @@ export declare class OAuth2Client implements AuthClient {
     private retry;
     private clientSecret?;
     private baseRequest;
-    private localCredentials;
     private storage;
     private deviceID?;
     private tokenInURL?;
@@ -44,11 +77,30 @@ export declare class OAuth2Client implements AuthClient {
     private singlePromise;
     private anonymousSignInFunc;
     private wxCloud;
+    private useWxCloud;
+    private eventBus;
     private basicAuth;
     private onCredentialsError;
-    private publishable_key;
+    private onInitialSessionObtained?;
     constructor(options: OAuth2ClientOptions);
+    setGetInitialSession(callback: () => Promise<{
+        data: {
+            session: Credentials;
+            user?: any;
+        } | null;
+        error: Error | null;
+    }>): void;
+    setOnInitialSessionObtained(callback: (data: {
+        session: Credentials;
+        user?: any;
+    }) => void | Promise<void>): void;
+    initialize(func?: Promise<{
+        error: Error | null;
+    }>): Promise<{
+        error: Error | null;
+    }>;
     setCredentials(credentials?: Credentials): Promise<void>;
+    setAccessKeyCredentials(credentials?: Credentials): void;
     getAccessToken(): Promise<string>;
     request<T>(url: string, options?: AuthClientRequestOptions): Promise<T>;
     wxCloudCallFunction<T>(url: string, options?: RequestOptions): Promise<T>;
@@ -57,7 +109,10 @@ export declare class OAuth2Client implements AuthClient {
     getCredentialsAsync(): Promise<Credentials | null>;
     getScope(): Promise<string>;
     getGroups(): Promise<string[]>;
-    refreshToken(credentials: Credentials): Promise<Credentials>;
+    refreshToken(credentials: Credentials, options?: {
+        throwError?: boolean;
+    }): Promise<Credentials>;
+    private _refreshToken;
     private anonymousLogin;
     private checkRetry;
     private formatRetry;
@@ -66,5 +121,9 @@ export declare class OAuth2Client implements AuthClient {
     private defaultRefreshTokenFunc;
     private getDeviceId;
     private unAuthenticatedError;
+    private _debug;
+    private _initialize;
+    private _acquireLock;
+    private _getCredentials;
 }
 export {};