@lark-apaas/miaoda-core 0.0.1-alpha.6 → 0.0.1-alpha.7

package/lib/components/AppContainer/api-proxy/core.d.ts

@@ -0,0 +1,182 @@
+/**
+ * HTTP 请求方法类型
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+/**
+ * 请求配置接口
+ */
+export interface RequestConfig {
+    /** 请求 URL */
+    url: string;
+    /** 请求方法 */
+    method?: HttpMethod;
+    /** 请求头 */
+    headers?: Record<string, string>;
+    /** 请求参数(用于 GET 请求的查询参数) */
+    params?: Record<string, any>;
+    /** 请求体数据 */
+    data?: any;
+    /** 超时时间(毫秒) */
+    timeout?: number;
+    /** 响应类型 */
+    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
+    /** 是否携带凭证 */
+    credentials?: RequestCredentials;
+    /** AbortSignal 用于取消请求 */
+    signal?: AbortSignal;
+}
+/**
+ * 响应数据接口
+ */
+export interface ApiResponse<T = any> {
+    /** 响应数据 */
+    data: T;
+    /** HTTP 状态码 */
+    status: number;
+    /** 状态文本 */
+    statusText: string;
+}
+/**
+ * API 错误类
+ */
+export declare class ApiError extends Error {
+    status?: number;
+    statusText?: string;
+    response?: Response;
+    config?: RequestConfig;
+    code?: string;
+    constructor(message: string, config?: RequestConfig, response?: Response, code?: string);
+}
+/**
+ * 请求拦截器类型
+ */
+export type RequestInterceptor = (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
+/**
+ * 响应拦截器类型
+ */
+export type ResponseInterceptor = <T = any>(response: ApiResponse<T>) => ApiResponse<T> | Promise<ApiResponse<T>>;
+/**
+ * 错误拦截器类型
+ */
+export type ErrorInterceptor = (error: ApiError) => any;
+/**
+ * 通用接口测试 API 代理类
+ *
+ * 特性:
+ * - 支持所有 RESTful 请求方法 (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)
+ * - 完善的错误处理和边界检查
+ * - 请求/响应拦截器
+ * - 超时控制和请求取消
+ * - 支持多种响应类型
+ */
+declare class ApiProxy {
+    /** 默认配置 */
+    private defaultConfig;
+    /** 请求拦截器队列 */
+    private requestInterceptors;
+    /** 响应拦截器队列 */
+    private responseInterceptors;
+    /** 错误拦截器队列 */
+    private errorInterceptors;
+    /** 活跃的请求控制器 Map */
+    private activeRequests;
+    /**
+     * 构造函数
+     * @param baseConfig 基础配置
+     */
+    constructor(baseConfig?: Partial<RequestConfig>);
+    /**
+     * 添加请求拦截器
+     */
+    useRequestInterceptor(interceptor: RequestInterceptor): void;
+    /**
+     * 添加响应拦截器
+     */
+    useResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * 添加错误拦截器
+     */
+    useErrorInterceptor(interceptor: ErrorInterceptor): void;
+    /**
+     * 验证 URL 格式
+     */
+    private validateUrl;
+    /**
+     * 构建完整 URL (包含查询参数)
+     */
+    private buildUrl;
+    /**
+     * 序列化请求体
+     */
+    private serializeData;
+    /**
+     * 解析响应数据
+     */
+    private parseResponse;
+    /**
+     * 执行请求拦截器
+     */
+    private runRequestInterceptors;
+    /**
+     * 执行响应拦截器
+     */
+    private runResponseInterceptors;
+    /**
+     * 执行错误拦截器
+     */
+    private runErrorInterceptors;
+    /**
+     * 生成请求唯一键
+     */
+    private generateRequestKey;
+    /**
+     * 核心请求方法
+     */
+    request<T = any>(config: RequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * 执行实际请求
+     */
+    private executeRequest;
+    /**
+     * GET 请求
+     */
+    get<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * POST 请求
+     */
+    post<T = any>(url: string, data?: any, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * PUT 请求
+     */
+    put<T = any>(url: string, data?: any, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * DELETE 请求
+     */
+    delete<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * PATCH 请求
+     */
+    patch<T = any>(url: string, data?: any, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * HEAD 请求
+     */
+    head<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * OPTIONS 请求
+     */
+    options<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
+    /**
+     * 取消指定的请求
+     */
+    cancelRequest(requestKey: string): void;
+    /**
+     * 取消所有活跃请求
+     */
+    cancelAllRequests(): void;
+    /**
+     * 获取活跃请求数量
+     */
+    getActiveRequestCount(): number;
+}
+declare const apiProxy: ApiProxy;
+export default apiProxy;

package/lib/components/AppContainer/api-proxy/core.js

@@ -0,0 +1,287 @@
+class ApiError extends Error {
+    status;
+    statusText;
+    response;
+    config;
+    code;
+    constructor(message, config, response, code){
+        super(message);
+        this.name = 'ApiError';
+        this.config = config;
+        this.response = response;
+        this.status = response?.status;
+        this.statusText = response?.statusText;
+        this.code = code;
+        Object.setPrototypeOf(this, ApiError.prototype);
+    }
+}
+class ApiProxy {
+    defaultConfig = {
+        timeout: 30000,
+        responseType: 'json',
+        credentials: 'same-origin',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Suda-Csrf-Token': window.csrfToken || ''
+        }
+    };
+    requestInterceptors = [];
+    responseInterceptors = [];
+    errorInterceptors = [];
+    activeRequests = new Map();
+    constructor(baseConfig){
+        if (baseConfig) this.defaultConfig = {
+            ...this.defaultConfig,
+            ...baseConfig
+        };
+    }
+    useRequestInterceptor(interceptor) {
+        if ('function' != typeof interceptor) throw new TypeError('Request interceptor must be a function');
+        this.requestInterceptors.push(interceptor);
+    }
+    useResponseInterceptor(interceptor) {
+        if ('function' != typeof interceptor) throw new TypeError('Response interceptor must be a function');
+        this.responseInterceptors.push(interceptor);
+    }
+    useErrorInterceptor(interceptor) {
+        if ('function' != typeof interceptor) throw new TypeError('Error interceptor must be a function');
+        this.errorInterceptors.push(interceptor);
+    }
+    validateUrl(url) {
+        if (!url || 'string' != typeof url) return false;
+        if (url.startsWith('/') || url.startsWith('./') || url.startsWith('../')) return true;
+        try {
+            new URL(url);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    buildUrl(url, params) {
+        if (!params || 0 === Object.keys(params).length) return url;
+        try {
+            const urlObj = new URL(url, window.location.origin);
+            Object.entries(params).forEach(([key, value])=>{
+                if (null != value) urlObj.searchParams.append(key, String(value));
+            });
+            return urlObj.toString();
+        } catch (error) {
+            console.error('Failed to build URL:', error);
+            return url;
+        }
+    }
+    serializeData(data, contentType) {
+        if (null == data) return null;
+        if (data instanceof FormData) return data;
+        if (data instanceof Blob || data instanceof File) return data;
+        if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) return data;
+        if (data instanceof URLSearchParams) return data;
+        const type = contentType?.toLowerCase() || '';
+        if (type.includes('application/json')) try {
+            return JSON.stringify(data);
+        } catch (error) {
+            throw new ApiError('Failed to serialize JSON data', void 0, void 0, 'SERIALIZATION_ERROR');
+        }
+        if (type.includes('application/x-www-form-urlencoded')) {
+            if ('object' == typeof data) return new URLSearchParams(data).toString();
+            return String(data);
+        }
+        if ('object' == typeof data) try {
+            return JSON.stringify(data);
+        } catch (error) {
+            throw new ApiError('Failed to serialize data', void 0, void 0, 'SERIALIZATION_ERROR');
+        }
+        return String(data);
+    }
+    async parseResponse(response, responseType) {
+        try {
+            switch(responseType){
+                case 'json':
+                    const text = await response.text();
+                    return text ? JSON.parse(text) : null;
+                case 'text':
+                    return await response.text();
+                case 'blob':
+                    return await response.blob();
+                case 'arrayBuffer':
+                    return await response.arrayBuffer();
+                case 'formData':
+                    return await response.formData();
+                default:
+                    return await response.text();
+            }
+        } catch (error) {
+            throw new ApiError(`Failed to parse response as ${responseType}`, void 0, response, 'PARSE_ERROR');
+        }
+    }
+    async runRequestInterceptors(config) {
+        let modifiedConfig = {
+            ...config
+        };
+        for (const interceptor of this.requestInterceptors)try {
+            modifiedConfig = await interceptor(modifiedConfig);
+        } catch (error) {
+            console.error('Request interceptor error:', error);
+            throw new ApiError('Request interceptor failed', modifiedConfig, void 0, 'INTERCEPTOR_ERROR');
+        }
+        return modifiedConfig;
+    }
+    async runResponseInterceptors(response) {
+        let modifiedResponse = response;
+        for (const interceptor of this.responseInterceptors)try {
+            modifiedResponse = await interceptor(modifiedResponse);
+        } catch (error) {
+            console.error('Response interceptor error:', error);
+        }
+        return modifiedResponse;
+    }
+    async runErrorInterceptors(error) {
+        for (const interceptor of this.errorInterceptors)try {
+            const result = await interceptor(error);
+            if (void 0 !== result) return result;
+        } catch (err) {
+            console.error('Error interceptor failed:', err);
+        }
+        throw error;
+    }
+    generateRequestKey(config) {
+        return `${config.method || 'GET'}_${config.url}_${Date.now()}_${Math.random()}`;
+    }
+    async request(config) {
+        if (!config || 'object' != typeof config) throw new ApiError('Request config is required and must be an object', config, void 0, 'INVALID_CONFIG');
+        if (!config.url) throw new ApiError('Request URL is required', config, void 0, 'MISSING_URL');
+        if (!this.validateUrl(config.url)) throw new ApiError('Invalid URL format', config, void 0, 'INVALID_URL');
+        const mergedConfig = {
+            ...this.defaultConfig,
+            ...config,
+            headers: {
+                ...this.defaultConfig.headers,
+                ...config.headers
+            }
+        };
+        const finalConfig = await this.runRequestInterceptors(mergedConfig);
+        const requestKey = this.generateRequestKey(finalConfig);
+        try {
+            const response = await this.executeRequest(finalConfig, requestKey);
+            return response;
+        } catch (error) {
+            const apiError = error instanceof ApiError ? error : new ApiError(error instanceof Error ? error.message : 'Unknown error', finalConfig, void 0, 'REQUEST_FAILED');
+            return await this.runErrorInterceptors(apiError);
+        }
+    }
+    async executeRequest(config, requestKey) {
+        let abortController;
+        if (config.signal) {
+            abortController = new AbortController();
+            config.signal.addEventListener('abort', ()=>abortController.abort());
+        } else abortController = new AbortController();
+        this.activeRequests.set(requestKey, abortController);
+        let timeoutId = null;
+        if (config.timeout && config.timeout > 0) timeoutId = setTimeout(()=>{
+            abortController.abort();
+        }, config.timeout);
+        try {
+            const fullUrl = this.buildUrl(config.url, config.params);
+            const fetchOptions = {
+                method: config.method || 'GET',
+                headers: config.headers,
+                credentials: config.credentials,
+                signal: abortController.signal
+            };
+            const methodsWithoutBody = [
+                'GET',
+                'HEAD'
+            ];
+            if (config.data && !methodsWithoutBody.includes(config.method || 'GET')) fetchOptions.body = this.serializeData(config.data, config.headers?.['Content-Type']);
+            const response = await fetch(fullUrl, fetchOptions);
+            if (timeoutId) clearTimeout(timeoutId);
+            this.activeRequests.delete(requestKey);
+            if (!response.ok) throw new ApiError(`HTTP Error: ${response.status} ${response.statusText}`, config, response, 'HTTP_ERROR');
+            const data = await this.parseResponse(response, config.responseType || 'json');
+            const apiResponse = {
+                data,
+                status: response.status,
+                statusText: response.statusText
+            };
+            return await this.runResponseInterceptors(apiResponse);
+        } catch (error) {
+            if (timeoutId) clearTimeout(timeoutId);
+            this.activeRequests.delete(requestKey);
+            if (error instanceof Error && 'AbortError' === error.name) throw new ApiError(config.timeout ? 'Request timeout' : 'Request cancelled', config, void 0, 'ABORT_ERROR');
+            if (error instanceof TypeError) throw new ApiError('Network error or CORS issue', config, void 0, 'NETWORK_ERROR');
+            if (error instanceof ApiError) throw error;
+            throw new ApiError(error instanceof Error ? error.message : 'Unknown error', config, void 0, 'UNKNOWN_ERROR');
+        }
+    }
+    async get(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'GET'
+        });
+    }
+    async post(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'POST',
+            data
+        });
+    }
+    async put(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'PUT',
+            data
+        });
+    }
+    async delete(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'DELETE'
+        });
+    }
+    async patch(url, data, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'PATCH',
+            data
+        });
+    }
+    async head(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'HEAD'
+        });
+    }
+    async options(url, config) {
+        return this.request({
+            ...config,
+            url,
+            method: 'OPTIONS'
+        });
+    }
+    cancelRequest(requestKey) {
+        const controller = this.activeRequests.get(requestKey);
+        if (controller) {
+            controller.abort();
+            this.activeRequests.delete(requestKey);
+        }
+    }
+    cancelAllRequests() {
+        this.activeRequests.forEach((controller)=>{
+            controller.abort();
+        });
+        this.activeRequests.clear();
+    }
+    getActiveRequestCount() {
+        return this.activeRequests.size;
+    }
+}
+const apiProxy = new ApiProxy();
+const core = apiProxy;
+export { ApiError, core as default };

package/lib/components/AppContainer/utils/api-panel.d.ts

@@ -0,0 +1,38 @@
+/**
+ * api panel
+ * 获取open-api.json
+ */
+declare function getOpenApiJson(): Promise<{}>;
+/**
+ * 获取日志json
+ */
+declare function getLogJson(): Promise<{}>;
+/**
+ * GET 请求
+ */
+declare function api_get(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+/**
+ * POST 请求
+ */
+declare function api_post(url: any, data: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+/**
+ * PUT 请求
+ */
+declare function api_put(url: any, data: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+/**
+ * DELETE 请求
+ */
+declare function api_delete(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+/**
+ * PATCH 请求
+ */
+declare function api_patch(url: any, data: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+/**
+ * HEAD 请求
+ */
+declare function api_head(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+/**
+ * OPTIONS 请求
+ */
+declare function api_options(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
+export { getOpenApiJson, getLogJson, api_get, api_post, api_put, api_delete, api_patch, api_head, api_options, };

package/lib/components/AppContainer/utils/api-panel.js

@@ -0,0 +1,60 @@
+import { normalizeBasePath } from "../../../utils/utils.js";
+import core from "../api-proxy/core.js";
+async function getOpenApiJson() {
+    let apiJson = {};
+    try {
+        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+        const res = await fetch(`${basePath}/openapi.json`);
+        apiJson = await res.json();
+    } catch (error) {
+        console.warn('get openapi.json error', error);
+    }
+    return apiJson;
+}
+async function getLogJson() {
+    let logJson = {};
+    try {
+        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+        const res = await fetch(`${basePath}/log.json`);
+        logJson = await res.json();
+    } catch (error) {
+        console.warn('get log.json error', error);
+    }
+    return logJson;
+}
+async function api_get(url, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core.get(`${basePath}${url}`, config);
+    return res;
+}
+async function api_post(url, data, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core.post(`${basePath}${url}`, data, config);
+    return res;
+}
+async function api_put(url, data, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core.put(`${basePath}${url}`, data, config);
+    return res;
+}
+async function api_delete(url, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core["delete"](`${basePath}${url}`, config);
+    return res;
+}
+async function api_patch(url, data, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core.patch(`${basePath}${url}`, data, config);
+    return res;
+}
+async function api_head(url, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core.head(`${basePath}${url}`, config);
+    return res;
+}
+async function api_options(url, config) {
+    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+    const res = await core.options(`${basePath}${url}`, config);
+    return res;
+}
+export { api_delete, api_get, api_head, api_options, api_patch, api_post, api_put, getLogJson, getOpenApiJson };

package/lib/components/AppContainer/utils/childApi.js

@@ -1,5 +1,5 @@
 import { normalizeBasePath } from "../../../utils/utils.js";
-import { apiTest } from "./api-fetch.js";
+import { api_delete, api_get, api_head, api_options, api_patch, api_post, api_put, getLogJson, getOpenApiJson } from "./api-panel.js";
 async function getRoutes() {
     let routes = [
         {
@@ -17,6 +17,16 @@ async function getRoutes() {
 }
 const childApi = {
     getRoutes,
-    apiTest: apiTest
+    apiProxy: {
+        api_get: api_get,
+        api_post: api_post,
+        api_put: api_put,
+        api_delete: api_delete,
+        api_patch: api_patch,
+        api_head: api_head,
+        api_options: api_options,
+        getOpenApiJson: getOpenApiJson,
+        getLogJson: getLogJson
+    }
 };
 export { childApi };

package/lib/types/iframe-events.d.ts

@@ -47,5 +47,15 @@ export interface ParentApi {
 }
 export interface ChildApi {
     getRoutes: () => Promise<any[]>;
-    apiTest: (fullUrl: string, fetchOptions: RequestInit) => Promise<any>;
+    apiProxy: {
+        api_get: (url: string, config?: any) => Promise<any>;
+        api_post: (url: string, data?: any, config?: any) => Promise<any>;
+        api_put: (url: string, data?: any, config?: any) => Promise<any>;
+        api_delete: (url: string, config?: any) => Promise<any>;
+        api_patch: (url: string, data?: any, config?: any) => Promise<any>;
+        api_head: (url: string, config?: any) => Promise<any>;
+        api_options: (url: string, config?: any) => Promise<any>;
+        getOpenApiJson: () => Promise<any>;
+        getLogJson: () => Promise<any>;
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/miaoda-core",
-  "version": "0.0.1-alpha.6",
+  "version": "0.0.1-alpha.7",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [

package/lib/components/AppContainer/utils/api-fetch.d.ts

@@ -1 +0,0 @@
-export declare function apiTest(fullUrl: string, fetchOptions: RequestInit): Promise<Response>;

package/lib/components/AppContainer/utils/api-fetch.js

@@ -1,10 +0,0 @@
-import { normalizeBasePath } from "../../../utils/utils.js";
-async function apiTest(fullUrl, fetchOptions) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    fetchOptions.headers = {
-        ...fetchOptions.headers,
-        'X-Suda-Csrf-Token': window.csrfToken || ''
-    };
-    return fetch(`${basePath}${fullUrl}`, fetchOptions);
-}
-export { apiTest };