@cloudbase/oauth 2.25.3 → 2.25.4

package/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/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 {};

package/dist/esm/utils/base64.d.ts

@@ -0,0 +1,9 @@
+export declare function weBtoa(string: string): string;
+export declare const weAtob: (string: string) => string;
+export declare function base64_url_decode(str: string): string;
+export declare function weappJwtDecode(token: string, options?: any): any;
+export declare function weAppJwtDecodeAll(token: string): {
+    claims: any;
+    header: any;
+    signature: any;
+};

package/dist/esm/utils/base64.js

@@ -89,7 +89,7 @@ export function weappJwtDecode(token, options) {
         throw new Error(`Invalid token specified: ${e}` ? e.message : '');
     }
 }
-export function weappJwtDecodeAll(token) {
+export function weAppJwtDecodeAll(token) {
     if (typeof token !== 'string') {
         throw new Error('Invalid token specified');
     }

package/dist/esm/utils/encrypt.d.ts

@@ -0,0 +1,4 @@
+export declare const getEncryptInfo: ({ publicKey, payload }?: {
+    publicKey?: string;
+    payload?: any;
+}) => any;