@lark-apaas/client-toolkit 1.0.8-alpha.1 → 1.0.9

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

@@ -35,10 +35,6 @@ export interface ApiResponse<T = any> {
     status: number;
     /** 状态文本 */
     statusText: string;
-    /** 请求是否成功 (2xx 状态码) */
-    success: boolean;
-    /** 响应头（序列化为普通对象，可通过 postMessage 传递） */
-    headers?: Record<string, string>;
 }
 /**
  * API 错误类
@@ -49,28 +45,39 @@ export declare class ApiError extends Error {
     response?: Response;
     config?: RequestConfig;
     code?: string;
-    /** 业务错误响应数据 */
-    responseData?: any;
-    constructor(message: string, config?: RequestConfig, response?: Response, code?: string, responseData?: any);
-    /**
-     * 序列化为可传递的 JSON 对象（用于 postMessage 等场景）
-     * 移除不可序列化的对象（如 Response、Request 等）
-     */
-    toJSON(): object;
+    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)
  * - 完善的错误处理和边界检查
+ * - 请求/响应拦截器
  * - 超时控制和请求取消
  * - 支持多种响应类型
- * - 所有响应数据可序列化（可通过 postMessage 传递）
  */
 declare class ApiProxy {
     /** 默认配置 */
     private defaultConfig;
+    /** 请求拦截器队列 */
+    private requestInterceptors;
+    /** 响应拦截器队列 */
+    private responseInterceptors;
+    /** 错误拦截器队列 */
+    private errorInterceptors;
     /** 活跃的请求控制器 Map */
     private activeRequests;
     /**
@@ -78,6 +85,18 @@ declare class ApiProxy {
      * @param baseConfig 基础配置
      */
     constructor(baseConfig?: Partial<RequestConfig>);
+    /**
+     * 添加请求拦截器
+     */
+    useRequestInterceptor(interceptor: RequestInterceptor): void;
+    /**
+     * 添加响应拦截器
+     */
+    useResponseInterceptor(interceptor: ResponseInterceptor): void;
+    /**
+     * 添加错误拦截器
+     */
+    useErrorInterceptor(interceptor: ErrorInterceptor): void;
     /**
      * 验证 URL 格式
      */
@@ -95,9 +114,17 @@ declare class ApiProxy {
      */
     private parseResponse;
     /**
-     * 将 Headers 对象序列化为普通对象（可通过 postMessage 传递）
+     * 执行请求拦截器
+     */
+    private runRequestInterceptors;
+    /**
+     * 执行响应拦截器
+     */
+    private runResponseInterceptors;
+    /**
+     * 执行错误拦截器
      */
-    private serializeHeaders;
+    private runErrorInterceptors;
     /**
      * 生成请求唯一键
      */

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

@@ -4,8 +4,7 @@ class ApiError extends Error {
     response;
     config;
     code;
-    responseData;
-    constructor(message, config, response, code, responseData){
+    constructor(message, config, response, code){
         super(message);
         this.name = 'ApiError';
         this.config = config;
@@ -13,27 +12,8 @@ class ApiError extends Error {
         this.status = response?.status;
         this.statusText = response?.statusText;
         this.code = code;
-        this.responseData = responseData;
         Object.setPrototypeOf(this, ApiError.prototype);
     }
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            code: this.code,
-            status: this.status,
-            statusText: this.statusText,
-            responseData: this.responseData,
-            config: this.config ? {
-                url: this.config.url,
-                method: this.config.method,
-                headers: this.config.headers,
-                params: this.config.params,
-                timeout: this.config.timeout,
-                responseType: this.config.responseType
-            } : void 0
-        };
-    }
 }
 class ApiProxy {
     defaultConfig = {
@@ -43,9 +23,12 @@ class ApiProxy {
         headers: {
             'Content-Type': 'application/json',
             'X-Suda-Csrf-Token': window.csrfToken || '',
-            'Cache-Control': 'no-store, no-cache'
+            'Cache-Control': 'no-store'
         }
     };
+    requestInterceptors = [];
+    responseInterceptors = [];
+    errorInterceptors = [];
     activeRequests = new Map();
     constructor(baseConfig){
         if (baseConfig) this.defaultConfig = {
@@ -53,6 +36,18 @@ class ApiProxy {
             ...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;
@@ -120,12 +115,35 @@ class ApiProxy {
             throw new ApiError(`Failed to parse response as ${responseType}`, void 0, response, 'PARSE_ERROR');
         }
     }
-    serializeHeaders(headers) {
-        const serialized = {};
-        headers.forEach((value, key)=>{
-            serialized[key] = value;
-        });
-        return serialized;
+    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()}`;
@@ -142,8 +160,15 @@ class ApiProxy {
                 ...config.headers
             }
         };
-        const requestKey = this.generateRequestKey(mergedConfig);
-        return await this.executeRequest(mergedConfig, requestKey);
+        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;
@@ -172,28 +197,27 @@ class ApiProxy {
             const response = await fetch(fullUrl, fetchOptions);
             if (timeoutId) clearTimeout(timeoutId);
             this.activeRequests.delete(requestKey);
-            let data;
-            try {
-                data = 204 === response.status || 304 === response.status ? null : await this.parseResponse(response, config.responseType || 'json');
-            } catch (parseError) {
-                console.error('Failed to parse response:', parseError);
-                data = null;
-            }
+            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,
-                success: response.ok,
-                headers: this.serializeHeaders(response.headers)
+                statusText: response.statusText
             };
-            return apiResponse;
+            return await this.runResponseInterceptors(apiResponse);
         } catch (error) {
+            let errorResponse = null, errorResponseString = '';
+            if (error.response && error.config.responseType) errorResponse = await this.parseResponse(error.response, error.config.responseType || 'json');
+            try {
+                errorResponseString = JSON.stringify(errorResponse);
+            } catch (error) {
+                throw new ApiError(error instanceof Error ? error.message : 'Response parse error', config, void 0, 'UNKNOWN_ERROR');
+            }
             if (timeoutId) clearTimeout(timeoutId);
             this.activeRequests.delete(requestKey);
-            if (error instanceof ApiError) throw error;
             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');
-            throw new ApiError(error instanceof Error ? error.message : 'Unknown error', config, void 0, 'UNKNOWN_ERROR');
+            throw new ApiError(errorResponseString, config, errorResponse, 'UNKNOWN_ERROR');
         }
     }
     async get(url, config) {

package/lib/utils/getAppId.js

@@ -2,10 +2,11 @@ function getAppId(path) {
     if (window.MIAODA_APP_ID) return window.MIAODA_APP_ID;
     let prefix;
     prefix = path.includes('/ai/feida/runtime/') ? '/ai/feida/runtime/' : path.includes('/spark/r/') ? '/spark/r/' : '/ai/miaoda/';
-    if (!path.startsWith(prefix)) return null;
+    const windowAppId = window.appId || null;
+    if (!path.startsWith(prefix)) return windowAppId;
     const remainder = path.substring(prefix.length);
     const nextSlashIndex = remainder.indexOf('/');
-    if (-1 === nextSlashIndex) return remainder;
-    return remainder.substring(0, nextSlashIndex);
+    if (-1 === nextSlashIndex) return remainder || windowAppId;
+    return remainder.substring(0, nextSlashIndex) || windowAppId;
 }
 export { getAppId };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/client-toolkit",
-  "version": "1.0.8-alpha.1",
+  "version": "1.0.9",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [