@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.5

package/node_modules/@cloudbase/oauth/dist/esm/captcha/captcha.d.ts

@@ -0,0 +1,42 @@
+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;
+    openURIWithCallback?: OpenURIWithCallbackFuction;
+    adapter?: SDKAdapterInterface & {
+        isMatch?: () => boolean;
+    };
+    oauthInstance?: Auth;
+}
+type OpenURIWithCallbackFuction = (url: string) => Promise<CaptchaToken>;
+export interface CaptchaToken {
+    captcha_token: string;
+    expires_in: number;
+    expires_at?: Date | null;
+}
+export interface CaptchaRequestOptions extends AuthClientRequestOptions {
+    withCaptcha?: boolean;
+}
+export interface GetCaptchaResponse {
+    captcha_token?: string;
+    expires_in?: number;
+    url?: string;
+}
+export declare class Captcha {
+    private config;
+    private tokenSectionName;
+    constructor(opts: CaptchaOptions);
+    isMatch(): boolean;
+    request<T>(url: string, options?: CaptchaRequestOptions): Promise<T>;
+    private getDefaultOpenURIWithCallback;
+    private getCaptchaToken;
+    private appendCaptchaTokenToURL;
+    private saveCaptchaToken;
+    private findCaptchaToken;
+}
+export {};

package/node_modules/@cloudbase/oauth/dist/esm/captcha/captcha.js

@@ -0,0 +1,104 @@
+import { ApiUrls, ErrorType } from '../auth/consts';
+import { defaultStorage } from '../oauth2client/oauth2client';
+import { isMp } from '../utils/mp';
+import { openURIWithCallback } from './captcha-dom';
+export class Captcha {
+    constructor(opts) {
+        if (!opts.openURIWithCallback) {
+            opts.openURIWithCallback = this.getDefaultOpenURIWithCallback();
+        }
+        if (!opts.storage) {
+            opts.storage = defaultStorage;
+        }
+        this.config = opts;
+        this.tokenSectionName = `captcha_${opts.clientId || opts.env}`;
+    }
+    isMatch() {
+        return this.config?.adapter?.isMatch?.() || isMp();
+    }
+    async request(url, options) {
+        if (!options) {
+            options = {};
+        }
+        if (!options.method) {
+            options.method = 'GET';
+        }
+        const state = `${options.method}:${url}`;
+        let reqURL = url;
+        if (options.withCaptcha) {
+            reqURL = await this.appendCaptchaTokenToURL(url, state, false);
+        }
+        let resp;
+        try {
+            resp = await this.config.request(reqURL, options);
+        }
+        catch (err) {
+            if (err.error === ErrorType.CAPTCHA_REQUIRED || err.error === ErrorType.CAPTCHA_INVALID) {
+                url = await this.appendCaptchaTokenToURL(url, state, err.error === ErrorType.CAPTCHA_INVALID);
+                return this.config.request(url, options);
+            }
+            return Promise.reject(err);
+        }
+        return resp;
+    }
+    getDefaultOpenURIWithCallback() {
+        return (url) => openURIWithCallback(url, this.config.oauthInstance);
+    }
+    async getCaptchaToken(forceNewToken, state) {
+        if (!forceNewToken) {
+            const captchaToken = await this.findCaptchaToken();
+            if (captchaToken) {
+                return captchaToken;
+            }
+        }
+        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;
+    }
+    async appendCaptchaTokenToURL(url, state, forceNewToken) {
+        const captchaToken = await this.getCaptchaToken(forceNewToken, state);
+        if (url.indexOf('?') > 0) {
+            url += `&captcha_token=${captchaToken}`;
+        }
+        else {
+            url += `?captcha_token=${captchaToken}`;
+        }
+        return url;
+    }
+    async saveCaptchaToken(token) {
+        token.expires_at = new Date(Date.now() + (token.expires_in - 10) * 1000);
+        const tokenStr = JSON.stringify(token);
+        await this.config.storage.setItem(this.tokenSectionName, tokenStr);
+    }
+    async findCaptchaToken() {
+        const tokenStr = await this.config.storage.getItem(this.tokenSectionName);
+        if (tokenStr !== undefined && tokenStr !== null) {
+            try {
+                const captchaToken = JSON.parse(tokenStr);
+                if (captchaToken?.expires_at) {
+                    captchaToken.expires_at = new Date(captchaToken.expires_at);
+                }
+                const isExpired = captchaToken.expires_at < new Date();
+                if (isExpired) {
+                    return null;
+                }
+                return captchaToken.captcha_token;
+            }
+            catch (error) {
+                await this.config.storage.removeItem(this.tokenSectionName);
+                return null;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@cloudbase/oauth/dist/esm/index.d.ts

@@ -0,0 +1,22 @@
+import { OAuth2Client } from './oauth2client/oauth2client';
+import { AuthOptions, Auth } from './auth/apis';
+import { Credentials } from './oauth2client/models';
+export { Auth } from './auth/apis';
+export { AuthError, AuthErrorCategory } from './auth/auth-error';
+export * as authModels 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 { AUTH_API_PREFIX, OAUTH_TYPE, DEFAULT_NODE_ACCESS_SCOPE, 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/node_modules/@cloudbase/oauth/dist/esm/index.js

@@ -0,0 +1,64 @@
+import { OAuth2Client } from './oauth2client/oauth2client';
+import { Auth } from './auth/apis';
+import { AUTH_API_PREFIX } from './auth/consts';
+export { Auth } from './auth/apis';
+export { AuthError, AuthErrorCategory } from './auth/auth-error';
+import * as authModels_1 from './auth/models';
+export { authModels_1 as authModels };
+export { weAppJwtDecodeAll } from './utils/base64';
+export { AUTH_API_PREFIX, OAUTH_TYPE, DEFAULT_NODE_ACCESS_SCOPE, 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, useWxCloud, eventBus, detectSessionInUrl, debug, } = authOptions;
+        this.detectSessionInUrl = detectSessionInUrl ?? false;
+        this.oauth2client = new OAuth2Client({
+            apiOrigin,
+            apiPath,
+            clientId,
+            env,
+            storage,
+            baseRequest: baseRequest || request,
+            anonymousSignInFunc,
+            wxCloud,
+            onCredentialsError,
+            headers: headers || {},
+            i18n,
+            useWxCloud,
+            eventBus,
+            debug,
+        });
+        this.authApi = new Auth({
+            credentialsClient: this.oauth2client,
+            ...authOptions,
+            request: request ? this.oauth2client.request.bind(this.oauth2client) : undefined,
+            adapter,
+        });
+        if (detectSessionInUrl) {
+            this.oauth2client.setGetInitialSession(this.authApi.getInitialSession.bind(this.authApi));
+        }
+        else {
+            try {
+                const url = new URL(window.location.href);
+                const code = url.searchParams.get('code');
+                const state = url.searchParams.get('state');
+                const cacheData = JSON.parse(sessionStorage.getItem(state) || 'null');
+                if (code && state && cacheData?.hash) {
+                    url.hash = cacheData.hash;
+                    window.history.replaceState(null, '', url.toString());
+                    window.location.replace(url.toString());
+                }
+            }
+            catch (error) {
+            }
+        }
+    }
+    initializeSession(onUserObtained) {
+        if (!this.detectSessionInUrl) {
+            this.oauth2client.initialize(Promise.resolve({ error: null }));
+            return;
+        }
+        this.oauth2client.setOnInitialSessionObtained(onUserObtained);
+        this.oauth2client.initialize();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/consts.d.ts

@@ -0,0 +1,20 @@
+export { ErrorType } from '../auth/consts';
+export declare enum Syntax {
+    CLIENT_ID = "client_id",
+    CLIENT_SECRET = "client_secret",
+    RESPONSE_TYPE = "response_type",
+    SCOPE = "scope",
+    STATE = "state",
+    REDIRECT_URI = "redirect_uri",
+    ERROR = "error",
+    ERROR_DESCRIPTION = "error_description",
+    ERROR_URI = "error_uri",
+    GRANT_TYPE = "grant_type",
+    CODE = "code",
+    ACCESS_TOKEN = "access_token",
+    TOKEN_TYPE = "token_type",
+    EXPIRES_IN = "expires_in",
+    USERNAME = "username",
+    PASSWORD = "password",
+    REFRESH_TOKEN = "refresh_token"
+}

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/consts.js

@@ -0,0 +1,22 @@
+export { ErrorType } from '../auth/consts';
+export var Syntax;
+(function (Syntax) {
+    Syntax["CLIENT_ID"] = "client_id";
+    Syntax["CLIENT_SECRET"] = "client_secret";
+    Syntax["RESPONSE_TYPE"] = "response_type";
+    Syntax["SCOPE"] = "scope";
+    Syntax["STATE"] = "state";
+    Syntax["REDIRECT_URI"] = "redirect_uri";
+    Syntax["ERROR"] = "error";
+    Syntax["ERROR_DESCRIPTION"] = "error_description";
+    Syntax["ERROR_URI"] = "error_uri";
+    Syntax["GRANT_TYPE"] = "grant_type";
+    Syntax["CODE"] = "code";
+    Syntax["ACCESS_TOKEN"] = "access_token";
+    Syntax["TOKEN_TYPE"] = "token_type";
+    Syntax["EXPIRES_IN"] = "expires_in";
+    Syntax["USERNAME"] = "username";
+    Syntax["PASSWORD"] = "password";
+    Syntax["REFRESH_TOKEN"] = "refresh_token";
+})(Syntax || (Syntax = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL29hdXRoMmNsaWVudC9jb25zdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBQzFDLE1BQU0sQ0FBTixJQUFZLE1Ba0JYO0FBbEJELFdBQVksTUFBTTtJQUNoQixpQ0FBdUIsQ0FBQTtJQUN2Qix5Q0FBK0IsQ0FBQTtJQUMvQix5Q0FBK0IsQ0FBQTtJQUMvQix5QkFBZSxDQUFBO0lBQ2YseUJBQWUsQ0FBQTtJQUNmLHVDQUE2QixDQUFBO0lBQzdCLHlCQUFlLENBQUE7SUFDZixpREFBdUMsQ0FBQTtJQUN2QyxpQ0FBdUIsQ0FBQTtJQUN2QixtQ0FBeUIsQ0FBQTtJQUN6Qix1QkFBYSxDQUFBO0lBQ2IsdUNBQTZCLENBQUE7SUFDN0IsbUNBQXlCLENBQUE7SUFDekIsbUNBQXlCLENBQUE7SUFDekIsK0JBQXFCLENBQUE7SUFDckIsK0JBQXFCLENBQUE7SUFDckIseUNBQStCLENBQUE7QUFDakMsQ0FBQyxFQWxCVyxNQUFNLEtBQU4sTUFBTSxRQWtCakIifQ==

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/interface.d.ts

@@ -0,0 +1,15 @@
+import { Credentials, AuthClientRequestOptions } from './models';
+export declare abstract class AuthClient {
+    abstract request: RequestFunction;
+    abstract setCredentials(credentials?: Credentials): Promise<void>;
+    abstract getAccessToken(): Promise<string>;
+}
+export type RequestFunction = <T>(url: string, options?: AuthClientRequestOptions) => Promise<T>;
+export interface SimpleStorage {
+    getItem: (key: string) => Promise<string | null>;
+    removeItem: (key: string) => Promise<void>;
+    setItem: (key: string, value: string) => Promise<void>;
+    getItemSync: (key: string) => string | null;
+    removeItemSync: (key: string) => void;
+    setItemSync: (key: string, value: string) => void;
+}

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/interface.js

@@ -0,0 +1,3 @@
+export class AuthClient {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL29hdXRoMmNsaWVudC9pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsTUFBTSxPQUFnQixVQUFVO0NBb0IvQiJ9

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/models.d.ts

@@ -0,0 +1,74 @@
+import { SimpleStorage } from './interface';
+import { ErrorType } from './consts';
+import { AuthOptions } from '../auth/apis';
+import { ICloudbaseConfig } from '@cloudbase/types';
+export interface Credentials {
+    token_type?: string | null;
+    access_token?: string | null;
+    refresh_token?: string | null;
+    scope?: string | null;
+    expires_in?: number | null;
+    expires_at?: Date | null;
+    sub?: string | null;
+    groups?: string[] | null;
+    version?: string;
+}
+export interface ResponseError {
+    error: ErrorType;
+    error_description?: string | null;
+    error_uri?: string | null;
+    details?: any | null;
+}
+export interface RequestOptions {
+    body?: any | null;
+    headers?: any | null;
+    method?: string;
+    [key: string]: any;
+}
+export type RequestFunction = <T>(url: string, options?: RequestOptions) => Promise<T>;
+export interface AuthClientRequestOptions extends RequestOptions {
+    headers?: {
+        'x-request-id'?: string;
+        [key: string]: any;
+    } | null;
+    withCredentials?: boolean;
+    withBasicAuth?: boolean;
+    retry?: number;
+    useWxCloud?: boolean;
+    getCredentials?: () => Credentials | Promise<Credentials | null> | null;
+    [key: string]: any;
+}
+export interface OAuth2ClientOptions {
+    devMode?: boolean;
+    apiOrigin: string;
+    apiPath?: string;
+    clientId: string;
+    env: string;
+    retry?: number;
+    baseRequest?: <T>(url: string, options?: RequestOptions) => Promise<T>;
+    storage?: SimpleStorage;
+    clientSecret?: string;
+    refreshTokenFunc?: (refreshToken?: string) => Promise<Credentials>;
+    tokenInURL?: boolean;
+    headers?: {
+        [key: string]: string;
+    };
+    anonymousSignInFunc?: (Credentials: any) => Promise<Credentials | void>;
+    wxCloud?: any;
+    onCredentialsError?: AuthOptions['onCredentialsError'];
+    i18n?: ICloudbaseConfig['i18n'];
+    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/node_modules/@cloudbase/oauth/dist/esm/oauth2client/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL29hdXRoMmNsaWVudC9tb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/oauth2client.d.ts

@@ -0,0 +1,129 @@
+import { ErrorType } from './consts';
+import { AuthClient, SimpleStorage } from './interface';
+import { Credentials, ResponseError, RequestOptions, RequestFunction, OAuth2ClientOptions, AuthClientRequestOptions } from './models';
+export interface ToResponseErrorOptions {
+    error?: ErrorType;
+    error_description?: string | null;
+    error_uri?: string | null;
+    details?: any | null;
+}
+export declare const defaultRequest: RequestFunction;
+export declare const toResponseError: (error: ResponseError | Error, options?: ToResponseErrorOptions) => ResponseError;
+export declare function generateRequestId(): string;
+declare class DefaultStorage implements SimpleStorage {
+    private readonly _env;
+    constructor(opts?: {
+        env: string;
+    });
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, value: string): Promise<void>;
+    getItemSync(key: string): string | null;
+    removeItemSync(key: string): void;
+    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;
+    private i18n;
+    private retry;
+    private clientSecret?;
+    private baseRequest;
+    private storage;
+    private deviceID?;
+    private tokenInURL?;
+    private refreshTokenFunc;
+    private headers?;
+    private singlePromise;
+    private anonymousSignInFunc;
+    private wxCloud;
+    private useWxCloud;
+    private eventBus;
+    private basicAuth;
+    private onCredentialsError;
+    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>;
+    getCredentials(): Promise<Credentials | null>;
+    getCredentialsSync(): Credentials | null;
+    getCredentialsAsync(): Promise<Credentials | null>;
+    getScope(): Promise<string>;
+    getGroups(): Promise<string[]>;
+    refreshToken(credentials: Credentials, options?: {
+        throwError?: boolean;
+    }): Promise<Credentials>;
+    private _refreshToken;
+    private anonymousLogin;
+    private checkRetry;
+    private formatRetry;
+    private sleep;
+    private anonymousSignIn;
+    private defaultRefreshTokenFunc;
+    private getDeviceId;
+    private unAuthenticatedError;
+    private _debug;
+    private _initialize;
+    private _acquireLock;
+    private _getCredentials;
+}
+export {};