@cloudbase/js-sdk 3.8.2-beta.1 → 3.8.2

package/app/dist/libs/adapter-node/constants.d.ts

@@ -0,0 +1,33 @@
+export declare const ERROR: {
+    INVALID_PARAM: {
+        code: string;
+        message: string;
+    };
+    SYS_ERR: {
+        code: string;
+        message: string;
+    };
+    STORAGE_REQUEST_FAIL: {
+        code: string;
+        message: string;
+    };
+    STORAGE_FILE_NONEXIST: {
+        code: string;
+        message: string;
+    };
+    TCB_CLS_UNOPEN: {
+        code: string;
+        message: string;
+    };
+    INVALID_CONTEXT: {
+        code: string;
+        message: string;
+    };
+};
+export declare const ADMIN_PATH = "/admin";
+export declare const CLIENT_AUTH_PATH = "/auth/v1/token/clientCredential";
+export declare const checkCustomUserIdRegex: RegExp;
+export declare enum SECRET_TYPE {
+    'SECRET' = "SECRET",
+    'SESSION_SECRET' = "SESSION_SECRET"
+}

package/app/dist/libs/adapter-node/context.d.ts

@@ -0,0 +1,18 @@
+import type { IContextParam, ICompleteCloudbaseContext } from './types';
+import { ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+export declare function parseContext(context: IContextParam): any;
+export declare const getCloudbaseContext: (context?: IContextParam) => ICompleteCloudbaseContext;
+export declare function getTcbContextConfig(): any;
+export declare function getServerInjectUrl(): string;
+export declare function getGatewayUrl(): string;
+export declare let INIT_CONFIG: ICloudbaseConfig;
+export declare const getSecretInfo: (config?: ICloudbaseConfig) => {
+    env: string;
+    secretId: any;
+    secretKey: any;
+    sessionToken: any;
+    accessKey: string;
+    secretType: string;
+    credentials: any;
+    context: any;
+};

package/app/dist/libs/adapter-node/index.d.ts

@@ -0,0 +1,26 @@
+import { SDKAdapterInterface } from '@cloudbase/adapter-interface';
+import { ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+export { NodeRequest } from './request';
+export { parseQueryString, createWebStreamFromNodeReadableStream, E, TcbError, SYMBOL_CURRENT_ENV, SYMBOL_DEFAULT_ENV, isValidEnvFormat, isPageModuleName, filterValue, filterUndefined, processReturn, setThrowOnCode } from './utils';
+export { getCloudbaseContext, parseContext, getSecretInfo, getServerInjectUrl, getGatewayUrl, getTcbContextConfig } from './context';
+export { getWxCloudToken, buildAdminUrl, sendWxRequest, sendWxFormDataRequest, callWxOpenApi, callCompatibleWxOpenApi, callWxPayApi, wxCallContainerApi, getWxOptions } from './wx';
+export type { ICreateTicketOpts, IGetUserInfoResult, IGetEndUserInfoResult, IUserInfoQuery, IContextParam, ICompleteCloudbaseContext, ISCFContext, ICallWxOpenApiOptions, ICallWxOpenApiResult, ITemplateNotifyReq, Extension, } from './types';
+declare function isMatch(): boolean;
+declare function genAdapter(options: any): SDKAdapterInterface & {
+    getSecretInfo: (config?: ICloudbaseConfig) => {
+        env: string;
+        secretId: string;
+        secretKey: string;
+        sessionToken: string;
+        accessKey: string;
+        secretType: string;
+        credentials?: string;
+    };
+    nodeTool: (app: any, config: ICloudbaseConfig) => void;
+};
+declare const adapter: {
+    genAdapter: typeof genAdapter;
+    isMatch: typeof isMatch;
+    runtime: string;
+};
+export default adapter;

package/app/dist/libs/adapter-node/metadata.d.ts

@@ -0,0 +1,14 @@
+export declare const kMetadataBaseUrl = "http://metadata.tencentyun.com";
+export declare const kAppIdPath = "meta-data/app-id";
+export declare const kSecurityCredentialsPath = "meta-data/cam/security-credentials";
+export declare enum kMetadataVersions {
+    'v20170919' = "2017-09-19",
+    'v1.0' = "1.0",
+    'latest' = "latest"
+}
+export declare function isAppId(appIdStr: string): boolean;
+export declare function lookup(path: string, options?: {
+    timeout?: number;
+}): Promise<string>;
+export declare function lookupAppId(): Promise<string>;
+export declare function lookupCredentials(ruleName: string): Promise<string>;

package/app/dist/libs/adapter-node/optional-require.d.ts

@@ -0,0 +1 @@
+export declare function optionalRequire<T = any>(moduleNameParts: string[], installHint?: string): T | null;

package/app/dist/libs/adapter-node/request.d.ts

@@ -0,0 +1,44 @@
+import { IFetchOptions, IRequestConfig, IRequestOptions, ResponseObject, SDKRequestInterface } from '@cloudbase/adapter-interface';
+import type { ICustomReqOpts } from './types';
+import { ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+export declare class NodeRequest implements SDKRequestInterface {
+    config: IRequestConfig & ICloudbaseConfig;
+    private readonly timeout;
+    private readonly restrictedMethods;
+    constructor(config: IRequestConfig & ICloudbaseConfig);
+    getClientCredential(opts: {
+        origin: string;
+    }): Promise<any>;
+    getRealUrl(url: string, headers: Record<string, any>, body: any): string;
+    getReqOptions: (url: string, options: {
+        method?: any;
+        headers: any;
+        body?: any;
+        credentials?: string;
+        withCredentials?: boolean;
+        signal?: AbortSignal;
+        url?: any;
+    }) => Promise<{
+        method?: any;
+        headers: any;
+        body?: any;
+        credentials?: string;
+        withCredentials?: boolean;
+        signal?: AbortSignal;
+        url?: any;
+    }>;
+    get: (options: IRequestOptions) => Promise<ResponseObject>;
+    post: (options: IRequestOptions) => Promise<ResponseObject>;
+    put: (options: IRequestOptions) => Promise<ResponseObject>;
+    upload: (options: IRequestOptions) => Promise<ResponseObject>;
+    download: (options: IRequestOptions) => Promise<unknown>;
+    fetch: (options: Omit<IFetchOptions, "signal"> & {
+        signal?: AbortSignal;
+        customReqOpts?: ICustomReqOpts;
+    }) => Promise<ResponseObject>;
+    request: (options: IRequestOptions, enableAbort?: boolean) => Promise<ResponseObject>;
+    private getFetchFn;
+    private createAbortController;
+    private applyDuplexIfNeeded;
+    private isNpmFormData;
+}

package/app/dist/libs/adapter-node/tool.d.ts

@@ -0,0 +1,2 @@
+import { ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+export declare const nodeTool: (app: any, config: ICloudbaseConfig) => void;

package/app/dist/libs/adapter-node/types.d.ts

@@ -0,0 +1,103 @@
+export interface ICreateTicketOpts {
+    refresh?: number;
+    expire?: number;
+}
+export interface IGetUserInfoResult {
+    openId: string;
+    appId: string;
+    uid: string;
+    customUserId: string;
+    isAnonymous: boolean;
+}
+export interface IContextParam {
+    memory_limit_in_mb: number;
+    time_limit_in_ms: number;
+    request_id: string;
+    environ?: string;
+    environment?: string;
+    function_version: string;
+    function_name: string;
+    namespace: string;
+}
+export interface IUserInfoQuery {
+    platform?: string;
+    platformId?: string;
+    uid?: string;
+}
+export interface ICompleteCloudbaseContext {
+    _SCF_TCB_LOG?: string;
+    LOGINTYPE?: string;
+    QQ_APPID?: string;
+    QQ_OPENID?: string;
+    SCF_NAMESPACE: string;
+    TCB_CONTEXT_CNFG?: string;
+    TCB_CONTEXT_KEYS: string[];
+    TCB_CUSTOM_USER_ID?: string;
+    TCB_ENV: string;
+    TCB_HTTP_CONTEXT?: string;
+    TCB_ISANONYMOUS_USER?: string;
+    TCB_ROUTE_KEY?: string;
+    TCB_SEQID: string;
+    TCB_SESSIONTOKEN?: string;
+    TCB_SOURCE_IP?: string;
+    TCB_SOURCE?: string;
+    TCB_TRACELOG?: string;
+    TCB_UUID?: string;
+    TENCENTCLOUD_RUNENV: string;
+    TENCENTCLOUD_SECRETID: string;
+    TENCENTCLOUD_SECRETKEY: string;
+    TENCENTCLOUD_SESSIONTOKEN: string;
+    CLOUDBASE_APIKEY: string;
+    TRIGGER_SRC: string;
+    WX_API_TOKEN?: string;
+    WX_APPID?: string;
+    WX_CLIENTIP?: string;
+    WX_CLIENTIPV6?: string;
+    WX_CLOUDBASE_ACCESSTOKEN?: string;
+    WX_CONTEXT_KEYS: string[];
+    WX_OPENID?: string;
+    WX_TRIGGER_API_TOKEN_V0?: string;
+    WX_UNIONID?: string;
+}
+export interface IGetEndUserInfoResult {
+    userInfo?: {
+        openId: string;
+        appId: string;
+        uid: string;
+        customUserId: string;
+        isAnonymous: boolean;
+    };
+    requestId?: string;
+}
+export interface ICustomReqOpts {
+    timeout?: number;
+}
+export interface ITemplateNotifyReq {
+    notifyId: string;
+    data?: Record<string, unknown>;
+    url?: string;
+}
+export interface ISCFContext {
+    memoryLimitInMb: number;
+    timeLimitIns: number;
+    requestId: string;
+    functionVersion: string;
+    namespace: string;
+    functionName: string;
+    environ?: any;
+    environment?: any;
+}
+export interface ICallWxOpenApiOptions {
+    apiName: string;
+    apiOptions?: any;
+    cgiName?: string;
+    requestData: any;
+}
+export interface ICallWxOpenApiResult {
+    requestId?: string;
+    result?: any;
+}
+export interface Extension {
+    name: string;
+    invoke<T>(options: T, cloudbase: any): any;
+}

package/app/dist/libs/adapter-node/utils.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { ReadableStream } from 'web-streams-polyfill';
+export declare const isFormData: (obj: unknown) => boolean, toQueryString: (data: Record<string, any>) => string;
+export declare function getEnv(): Record<string, string | undefined>;
+export declare function getEnv(key: string): string | undefined;
+export declare const checkIsInScf: () => boolean;
+export declare function checkIsInCBR(): boolean;
+export declare function checkIsInSumeru(): boolean;
+export declare function checkIsInTencentCloud(): Promise<boolean>;
+export declare const getCurrRunEnvTag: () => Promise<string>;
+export declare const validateUid: (uid: string) => void;
+export declare function safeParseJson(text: string): any;
+export declare function obj2StrRecord(obj: object): Record<string, string>;
+export declare function headersInit2Indexable(h: HeadersInit): Record<string, string> | [string, string][];
+export declare function parseQueryString(search: string): Record<string, string | string[]>;
+export declare function createWebStreamFromNodeReadableStream(stream: NodeJS.ReadableStream): ReadableStream;
+interface IErrorInfo {
+    requestId?: string;
+    code?: string;
+    message?: string;
+}
+export declare class TcbError extends Error {
+    readonly code: string;
+    readonly message: string;
+    readonly requestId: string;
+    constructor(error: IErrorInfo);
+}
+export declare function E(errObj: IErrorInfo): TcbError;
+export declare function filterValue(o: any, value: any): void;
+export declare function filterUndefined(o: any): void;
+export declare function setThrowOnCode(value: boolean): void;
+export declare function processReturn(result: any): any;
+export declare function isPageModuleName(envId?: string): boolean;
+export declare function isValidEnvFormat(env?: string): boolean;
+export declare const SYMBOL_CURRENT_ENV: unique symbol;
+export declare const SYMBOL_DEFAULT_ENV: unique symbol;
+export {};

package/app/dist/libs/adapter-node/wx.d.ts

@@ -0,0 +1,39 @@
+import type { ICustomReqOpts } from './types';
+export declare function getWxCloudToken(): {
+    wxCloudApiToken: string;
+    wxCloudbaseAccesstoken?: string;
+};
+export declare function buildAdminUrl(config: any, scfContext?: any, serviceUrl?: string): string;
+export interface ISendWxRequestOptions {
+    requestInstance: any;
+    config: any;
+    scfContext?: any;
+    serviceUrl?: string;
+}
+export declare function sendWxRequest(options: ISendWxRequestOptions, action: string, params: any, reqOpts?: ICustomReqOpts): Promise<any>;
+export declare function sendWxFormDataRequest(options: ISendWxRequestOptions, action: string, params: any, reqOpts?: ICustomReqOpts): Promise<any>;
+export declare function getWxOptions(config: any, scfContext: any, serviceUrl: string, requestInstance: any): ISendWxRequestOptions;
+export declare function callWxOpenApi(wxOptions: ISendWxRequestOptions, { apiName, apiOptions, cgiName, requestData }: {
+    apiName: string;
+    apiOptions?: any;
+    cgiName?: string;
+    requestData: any;
+}, opts?: ICustomReqOpts): Promise<any>;
+export declare const callCompatibleWxOpenApi: (wxOptions: ISendWxRequestOptions, apiOpts: {
+    apiName: string;
+    apiOptions?: any;
+    cgiName?: string;
+    requestData: any;
+}, opts?: ICustomReqOpts) => Promise<any>;
+export declare const callWxPayApi: (wxOptions: ISendWxRequestOptions, apiOpts: {
+    apiName: string;
+    apiOptions?: any;
+    cgiName?: string;
+    requestData: any;
+}, opts?: ICustomReqOpts) => Promise<any>;
+export declare const wxCallContainerApi: (wxOptions: ISendWxRequestOptions, apiOpts: {
+    apiName: string;
+    apiOptions?: any;
+    cgiName?: string;
+    requestData: any;
+}, opts?: ICustomReqOpts) => Promise<any>;

package/app/dist/libs/adapter.d.ts

@@ -0,0 +1,3 @@
+import { ICloudbasePlatformInfo } from '@cloudbase/js-sdk/types';
+export declare const Platform: ICloudbasePlatformInfo;
+export declare const getWxDefaultAdapter: () => any;

package/app/dist/libs/cache.d.ts

@@ -0,0 +1,6 @@
+import { ICloudbaseCache, ICacheConfig } from '@cloudbase/js-sdk/types/cache';
+export declare function initCache(config: ICacheConfig & {
+    env: string;
+}): void;
+export declare function getCacheByEnvId(env: string): ICloudbaseCache;
+export declare function getLocalCache(env: string): ICloudbaseCache;

package/app/dist/libs/component.d.ts

@@ -0,0 +1,3 @@
+import { ICloudbaseComponent, ICloudbaseHook } from '@cloudbase/js-sdk/types/component';
+export declare function registerComponent(app: any, component: ICloudbaseComponent): void;
+export declare function registerHook(app: any, hook: ICloudbaseHook): void;

package/app/dist/libs/lang.d.ts

@@ -0,0 +1,23 @@
+export declare enum LANGS {
+    ZH = "zh-CN",
+    EN = "en-US"
+}
+export declare const LANG_HEADER_KEY = "Accept-Language";
+export declare const langMap: {
+    "en-US": {
+        '\u8BF7\u68C0\u67E5\u8C03\u7528\u65B9\u5F0F\uFF0C\u6216\u524D\u5F80\u4E91\u5F00\u53D1 AI+ \u9996\u9875\u67E5\u770B\u6587\u6863': string;
+        'AI+ \u8BF7\u6C42\u51FA\u9519\uFF0C\u9519\u8BEF\u7801': string;
+        错误信息: string;
+        未实现: string;
+        '\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301 wasm \u52A0\u8F7D': string;
+        '\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301\u52A8\u6001 js \u52A0\u8F7D': string;
+        请求超时: string;
+        '\u7F3A\u5C11 privatelink sdk \u5730\u5740': string;
+    };
+};
+export declare const t: (text: string, lang: LANGS) => any;
+export declare const i18nProxy: (platform: any, config: any) => {
+    t: (text: string) => any;
+    LANG_HEADER_KEY: string;
+    lang: any;
+};

package/app/dist/libs/request.d.ts

@@ -0,0 +1,62 @@
+import { IRequestOptions, ResponseObject, IUploadRequestOptions, IFetchOptions } from '@cloudbase/adapter-interface';
+import { EndPointKey, KV, ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+import { ICustomReqOpts } from '@cloudbase/js-sdk/types/functions';
+import { IGetAccessTokenResult, ICloudbaseRequestConfig } from '@cloudbase/js-sdk/types/request';
+export interface IGateWayOptions {
+    name?: string;
+    data?: any;
+    path?: string;
+    method: string;
+    header?: {};
+    url?: string;
+}
+export interface ICloudbaseRequest {
+    post: (options: IRequestOptions) => Promise<ResponseObject>;
+    upload: (options: IUploadRequestOptions) => Promise<ResponseObject>;
+    download: (options: IRequestOptions) => Promise<ResponseObject>;
+    request: (action: string, params: KV<any>, options?: KV<any>) => Promise<ResponseObject>;
+    send: (action: string, data: KV<any>) => Promise<any>;
+    fetch: (options: IFetchOptions) => Promise<ResponseObject>;
+}
+export declare class CloudbaseRequest implements ICloudbaseRequest {
+    config: ICloudbaseRequestConfig;
+    private reqClass;
+    private throwWhenRequestFail;
+    private localCache;
+    constructor(config: ICloudbaseRequestConfig & {
+        throw?: boolean;
+    });
+    getAccessToken(token?: any): Promise<any>;
+    getDefaultHeaders(): {
+        [x: string]: string;
+        'X-SDK-Version': string;
+    };
+    post(options: IRequestOptions, customReqOpts?: ICustomReqOpts): Promise<ResponseObject>;
+    upload(options: IUploadRequestOptions): Promise<ResponseObject>;
+    download(options: IRequestOptions): Promise<ResponseObject>;
+    getBaseEndPoint(endPointKey?: EndPointKey): string;
+    getOauthAccessTokenV2(oauthClient: any): Promise<IGetAccessTokenResult>;
+    request(action: string, params: KV<any>, options?: {
+        onUploadProgress?: Function;
+        pathname?: string;
+        parse?: boolean;
+        inQuery?: KV<any>;
+        search?: string;
+        defaultQuery?: KV<any>;
+        headers?: KV<string>;
+        endPointMode?: 'CLOUD_API' | 'GATEWAY';
+    }, customReqOpts?: ICustomReqOpts): Promise<ResponseObject>;
+    fetch(options: IFetchOptions & {
+        token?: string;
+        withCredentials?: boolean;
+        customReqOpts?: ICustomReqOpts;
+    }): Promise<ResponseObject>;
+    send(action: string, data?: KV<any>, options?: KV<any>, customReqOpts?: ICustomReqOpts): Promise<any>;
+    gateWay(options: IGateWayOptions, customReqOpts?: ICustomReqOpts): Promise<{
+        data: any;
+        statusCode?: number;
+        requestId: string;
+    }>;
+}
+export declare function initRequest(config: ICloudbaseRequestConfig & Partial<ICloudbaseConfig>): CloudbaseRequest;
+export declare function getRequestByEnvId(env: string): CloudbaseRequest;

package/auth/dist/adapter.d.ts

@@ -0,0 +1,2 @@
+import type { AuthOptions } from '@cloudbase/js-sdk/oauth';
+export declare const useAuthAdapter: (config: AuthOptions) => any;