@vlian/framework 1.2.56 → 1.2.59

package/dist/request/core/RequestClient.d.ts

@@ -1,134 +0,0 @@
-/**
- * 请求客户端核心实现
- *
- * 这是请求库的核心，负责协调适配器和插件系统
- */
-import type { RequestOptions, Response, RequestClientConfig } from '../types';
-import type { RequestAdapter } from '../adapter/RequestAdapter';
-/**
- * 请求客户端类
- */
-export declare class RequestClient {
-    private config;
-    private pluginManager;
-    private adapter;
-    private adapterName;
-    /**
-     * 获取当前适配器名称
-     */
-    getAdapterName(): string | null;
-    constructor(config?: RequestClientConfig);
-    /**
-     * 初始化客户端
-     */
-    initialize(): Promise<void>;
-    /**
-     * 加载适配器
-     */
-    private loadAdapter;
-    /**
-     * 自动检测适配器
-     */
-    private detectAdapter;
-    /**
-     * 设置适配器
-     *
-     * @param adapter - 适配器实例或名称
-     */
-    setAdapter(adapter: RequestAdapter | string): Promise<void>;
-    /**
-     * 注册插件
-     *
-     * @param plugin - 请求插件
-     */
-    use(plugin: import('../plugin/RequestPlugin').RequestPlugin): void;
-    /**
-     * 注销插件
-     *
-     * @param name - 插件名称
-     */
-    unuse(name: string): void;
-    /**
-     * 执行请求
-     *
-     * @template TResponse - 响应数据类型
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    request<TResponse = unknown>(options: RequestOptions<TResponse>): Promise<Response<TResponse>>;
-    /**
-     * 执行实际的请求逻辑
-     *
-     * @template TResponse - 响应数据类型
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    private executeRequest;
-    /**
-     * GET 请求
-     *
-     * @template TResponse - 响应数据类型
-     * @param url - 请求 URL
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    get<TResponse = unknown>(url: string, options?: Omit<RequestOptions<TResponse>, 'url' | 'method'>): Promise<Response<TResponse>>;
-    /**
-     * POST 请求
-     *
-     * @template TResponse - 响应数据类型
-     * @param url - 请求 URL
-     * @param body - 请求体
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    post<TResponse = unknown>(url: string, body?: RequestOptions<TResponse>['body'], options?: Omit<RequestOptions<TResponse>, 'url' | 'method' | 'body'>): Promise<Response<TResponse>>;
-    /**
-     * PUT 请求
-     *
-     * @template TResponse - 响应数据类型
-     * @param url - 请求 URL
-     * @param body - 请求体
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    put<TResponse = unknown>(url: string, body?: RequestOptions<TResponse>['body'], options?: Omit<RequestOptions<TResponse>, 'url' | 'method' | 'body'>): Promise<Response<TResponse>>;
-    /**
-     * PATCH 请求
-     *
-     * @template TResponse - 响应数据类型
-     * @param url - 请求 URL
-     * @param body - 请求体
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    patch<TResponse = unknown>(url: string, body?: RequestOptions<TResponse>['body'], options?: Omit<RequestOptions<TResponse>, 'url' | 'method' | 'body'>): Promise<Response<TResponse>>;
-    /**
-     * DELETE 请求
-     *
-     * @template TResponse - 响应数据类型
-     * @param url - 请求 URL
-     * @param options - 请求配置选项
-     * @returns Promise 解析为响应对象
-     */
-    delete<TResponse = unknown>(url: string, options?: Omit<RequestOptions<TResponse>, 'url' | 'method'>): Promise<Response<TResponse>>;
-    /**
-     * 合并请求配置
-     *
-     * @param options - 请求配置选项
-     * @returns 合并后的配置
-     */
-    private mergeOptions;
-    /**
-     * 创建请求错误
-     */
-    private createError;
-    /**
-     * 标准化错误
-     */
-    private normalizeError;
-    /**
-     * 销毁客户端
-     */
-    destroy(): Promise<void>;
-}

package/dist/request/core/RequestClient.js

@@ -1,509 +0,0 @@
-/**
- * 请求客户端核心实现
- * 
- * 这是请求库的核心，负责协调适配器和插件系统
- */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { RequestError, RequestErrorType, RequestErrorCode } from "../types";
-import { adapterRegistry } from "../adapter/RequestAdapter";
-import { PluginManager, PluginLifecycleStage } from "../plugin/RequestPlugin";
-import { createRequestContext, completeRequestContext, failRequestContext } from "../runtime/RequestContext";
-import { getRequestQueueManager } from "../utils/RequestQueueManager";
-/**
- * 适配器环境要求映射
- * 
- * 注意：axios 可以在浏览器和 Node.js 环境中使用，因此不在此映射中限制
- */ const ADAPTER_ENVIRONMENT_MAP = {
-    fetch: 'browser',
-    ky: 'browser',
-    undici: 'node'
-};
-/**
- * 检测当前运行环境
- * 
- * @returns 运行环境类型
- */ function detectEnvironment() {
-    const isBrowser = typeof window !== 'undefined';
-    const isNode = typeof process !== 'undefined' && process.versions?.node;
-    if (isBrowser) {
-        return 'browser';
-    } else if (isNode) {
-        return 'node';
-    }
-    return 'unknown';
-}
-/**
- * 获取适配器的推荐替代方案
- * 
- * @param currentEnv - 当前环境
- * @returns 推荐的适配器列表
- */ function getRecommendedAdapters(currentEnv) {
-    if (currentEnv === 'browser') {
-        return [
-            'fetch',
-            'ky',
-            'axios'
-        ];
-    } else if (currentEnv === 'node') {
-        return [
-            'axios',
-            'undici'
-        ];
-    }
-    return [];
-}
-/**
- * 创建环境不匹配错误消息
- * 
- * @param adapterName - 适配器名称
- * @param adapterEnv - 适配器要求的环境
- * @param currentEnv - 当前环境
- * @returns 错误消息
- */ function createEnvironmentMismatchError(adapterName, adapterEnv, currentEnv) {
-    const recommendedAdapters = getRecommendedAdapters(currentEnv);
-    const recommendedList = recommendedAdapters.length > 0 ? recommendedAdapters.map((name)=>`"${name}"`).join(' 或 ') : '其他适配器';
-    const adapterEnvName = adapterEnv === 'browser' ? '浏览器' : 'Node.js';
-    const currentEnvName = currentEnv === 'browser' ? '浏览器' : currentEnv === 'node' ? 'Node.js' : '未知';
-    const firstRecommended = recommendedAdapters[0] || 'fetch';
-    const firstRecommendedFactory = firstRecommended === 'fetch' ? 'fetchAdapter' : firstRecommended === 'ky' ? 'kyAdapter' : firstRecommended === 'axios' ? 'axiosAdapter' : 'undiciAdapter';
-    let message = `\n❌ 适配器环境不匹配\n\n`;
-    message += `适配器 "${adapterName}" 要求运行在 ${adapterEnvName} 环境中，\n`;
-    message += `但当前运行在 ${currentEnvName} 环境中。\n\n`;
-    message += `💡 建议：请使用适合当前环境的适配器，如 ${recommendedList}。\n\n`;
-    message += `📝 使用示例：\n\n`;
-    message += `  // 方式 1：使用适配器名称字符串\n`;
-    message += `  import { createRequestClient } from '@vlian/framework/request';\n\n`;
-    message += `  const client = await createRequestClient({\n`;
-    message += `    defaultAdapter: '${firstRecommended}',\n`;
-    message += `  });\n\n`;
-    message += `  // 方式 2：使用适配器工厂函数\n`;
-    message += `  import { createRequestClient, ${firstRecommendedFactory} } from '@vlian/framework/request';\n\n`;
-    message += `  const client = await createRequestClient({\n`;
-    message += `    defaultAdapter: ${firstRecommendedFactory},\n`;
-    message += `  });\n`;
-    return message;
-}
-/**
- * 验证适配器环境是否匹配
- * 
- * @param adapterName - 适配器名称
- * @throws 如果环境不匹配，抛出包含友好提示的错误
- */ function validateAdapterEnvironment(adapterName) {
-    const adapterEnv = ADAPTER_ENVIRONMENT_MAP[adapterName];
-    if (!adapterEnv) {
-        // 未知适配器，不进行环境检查
-        return;
-    }
-    const currentEnv = detectEnvironment();
-    if (currentEnv === 'unknown') {
-        // 无法检测环境，跳过检查
-        return;
-    }
-    if (adapterEnv !== currentEnv) {
-        const errorMessage = createEnvironmentMismatchError(adapterName, adapterEnv, currentEnv);
-        throw new Error(errorMessage);
-    }
-}
-/**
- * 请求客户端类
- */ export class RequestClient {
-    /**
-   * 获取当前适配器名称
-   */ getAdapterName() {
-        return this.adapterName;
-    }
-    /**
-   * 初始化客户端
-   */ async initialize() {
-        // 加载默认适配器
-        await this.loadAdapter();
-        // 执行插件初始化钩子
-        const context = createRequestContext({
-            url: ''
-        }, {});
-        await this.pluginManager.executeHook(PluginLifecycleStage.INIT, context);
-    }
-    /**
-   * 加载适配器
-   */ async loadAdapter() {
-        if (this.adapter) {
-            return;
-        }
-        const adapterConfig = this.config.defaultAdapter;
-        if (typeof adapterConfig === 'string') {
-            // 检查适配器环境是否匹配
-            validateAdapterEnvironment(adapterConfig);
-            // 从注册表加载
-            this.adapter = await adapterRegistry.get(adapterConfig);
-            this.adapterName = adapterConfig;
-            // 再次验证（适配器可能返回不同的名称）
-            if (this.adapter.name !== adapterConfig) {
-                validateAdapterEnvironment(this.adapter.name);
-            }
-        } else if (typeof adapterConfig === 'function') {
-            // 使用工厂函数加载
-            this.adapter = await adapterConfig();
-            this.adapterName = this.adapter.name;
-            // 验证适配器环境
-            validateAdapterEnvironment(this.adapter.name);
-        } else {
-            // 自动检测环境（自动检测的适配器不需要验证，因为已经根据环境选择了）
-            const detectedAdapter = await this.detectAdapter();
-            this.adapter = detectedAdapter.adapter;
-            this.adapterName = detectedAdapter.name;
-        }
-    }
-    /**
-   * 自动检测适配器
-   */ async detectAdapter() {
-        // 检测运行环境
-        const isBrowser = typeof window !== 'undefined';
-        const isNode = typeof process !== 'undefined' && process.versions?.node;
-        if (isBrowser) {
-            // 浏览器环境：尝试加载 ky 适配器
-            try {
-                const { kyAdapter } = await import("../adapter/kyAdapter");
-                const adapter = await kyAdapter();
-                return {
-                    adapter,
-                    name: 'ky'
-                };
-            } catch  {
-                // 如果 ky 不可用，使用 fetch 适配器
-                const { fetchAdapter } = await import("../adapter/fetchAdapter");
-                const adapter = await fetchAdapter();
-                return {
-                    adapter,
-                    name: 'fetch'
-                };
-            }
-        } else if (isNode) {
-            // Node.js 环境：尝试加载 axios 适配器
-            try {
-                const { axiosAdapter } = await import("../adapter/axiosAdapter");
-                const adapter = await axiosAdapter();
-                return {
-                    adapter,
-                    name: 'axios'
-                };
-            } catch  {
-                // 如果 axios 不可用，使用 undici 适配器
-                try {
-                    const { undiciAdapter } = await import("../adapter/undiciAdapter");
-                    const adapter = await undiciAdapter();
-                    return {
-                        adapter,
-                        name: 'undici'
-                    };
-                } catch  {
-                    throw new Error('无法找到可用的适配器，请手动指定适配器');
-                }
-            }
-        }
-        throw new Error('无法检测运行环境');
-    }
-    /**
-   * 设置适配器
-   * 
-   * @param adapter - 适配器实例或名称
-   */ async setAdapter(adapter) {
-        if (typeof adapter === 'string') {
-            // 检查适配器环境是否匹配
-            validateAdapterEnvironment(adapter);
-            this.adapter = await adapterRegistry.get(adapter);
-            this.adapterName = adapter;
-            // 再次验证（适配器可能返回不同的名称）
-            if (this.adapter.name !== adapter) {
-                validateAdapterEnvironment(this.adapter.name);
-            }
-        } else {
-            // 验证适配器环境
-            validateAdapterEnvironment(adapter.name);
-            this.adapter = adapter;
-            this.adapterName = adapter.name;
-        }
-    }
-    /**
-   * 注册插件
-   * 
-   * @param plugin - 请求插件
-   */ use(plugin) {
-        this.pluginManager.register(plugin);
-    }
-    /**
-   * 注销插件
-   * 
-   * @param name - 插件名称
-   */ unuse(name) {
-        this.pluginManager.unregister(name);
-    }
-    /**
-   * 执行请求
-   * 
-   * @template TResponse - 响应数据类型
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async request(options) {
-        // 确保适配器已加载
-        if (!this.adapter) {
-            await this.loadAdapter();
-        }
-        if (!this.adapter) {
-            throw new Error('适配器未初始化');
-        }
-        // 合并配置
-        const mergedOptions = this.mergeOptions(options);
-        // 检查队列状态，如果队列已暂停，将请求放入队列
-        const queueManager = getRequestQueueManager();
-        if (queueManager.isPaused()) {
-            return queueManager.enqueue(mergedOptions, ()=>this.executeRequest(mergedOptions));
-        }
-        // 正常执行请求
-        return this.executeRequest(mergedOptions);
-    }
-    /**
-   * 执行实际的请求逻辑
-   * 
-   * @template TResponse - 响应数据类型
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async executeRequest(options) {
-        // 创建请求上下文
-        const context = createRequestContext(options, {});
-        try {
-            // 执行请求前钩子
-            const beforeResult = await this.pluginManager.executeHook(PluginLifecycleStage.BEFORE_REQUEST, context);
-            // 如果插件返回了修改后的请求配置，使用它
-            if (beforeResult && typeof beforeResult === 'object' && 'url' in beforeResult) {
-                context.request = beforeResult;
-            }
-            // 检查是否已取消（可能是缓存命中）
-            if (context.cancelled) {
-                // 如果有缓存的响应，直接返回
-                if (context.response) {
-                    return context.response;
-                }
-                throw this.createError('请求已取消', RequestErrorType.ABORT_ERROR, RequestErrorCode.REQUEST_ABORTED, {
-                    request: context.request
-                });
-            }
-            // 执行请求
-            let response;
-            try {
-                if (!this.adapter) {
-                    throw new Error('适配器未初始化');
-                }
-                response = await this.adapter.request(context.request);
-            } catch (error) {
-                // 适配器错误转换为框架错误
-                throw this.normalizeError(error, context.request);
-            }
-            // 更新上下文
-            completeRequestContext(context, response);
-            // 执行请求后钩子
-            const afterResult = await this.pluginManager.executeHook(PluginLifecycleStage.AFTER_REQUEST, context);
-            // 如果插件返回了修改后的响应，使用它
-            if (afterResult && typeof afterResult === 'object' && 'data' in afterResult) {
-                response = afterResult;
-            }
-            return response;
-        } catch (error) {
-            // 更新上下文
-            const requestError = error instanceof RequestError ? error : this.normalizeError(error, context.request);
-            failRequestContext(context, requestError);
-            // 执行错误处理钩子
-            const errorHandled = await this.pluginManager.executeHook(PluginLifecycleStage.ON_ERROR, context);
-            // 如果错误未被处理，继续抛出
-            if (errorHandled !== true) {
-                throw requestError;
-            }
-            // 如果错误已被处理，返回一个默认响应（由插件决定）
-            if (context.response) {
-                return context.response;
-            }
-            throw requestError;
-        } finally{
-            // 执行最终钩子
-            await this.pluginManager.executeHook(PluginLifecycleStage.FINALLY, context);
-        }
-    }
-    /**
-   * GET 请求
-   * 
-   * @template TResponse - 响应数据类型
-   * @param url - 请求 URL
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async get(url, options) {
-        return this.request({
-            ...options,
-            url,
-            method: 'GET'
-        });
-    }
-    /**
-   * POST 请求
-   * 
-   * @template TResponse - 响应数据类型
-   * @param url - 请求 URL
-   * @param body - 请求体
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async post(url, body, options) {
-        return this.request({
-            ...options,
-            url,
-            method: 'POST',
-            body
-        });
-    }
-    /**
-   * PUT 请求
-   * 
-   * @template TResponse - 响应数据类型
-   * @param url - 请求 URL
-   * @param body - 请求体
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async put(url, body, options) {
-        return this.request({
-            ...options,
-            url,
-            method: 'PUT',
-            body
-        });
-    }
-    /**
-   * PATCH 请求
-   * 
-   * @template TResponse - 响应数据类型
-   * @param url - 请求 URL
-   * @param body - 请求体
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async patch(url, body, options) {
-        return this.request({
-            ...options,
-            url,
-            method: 'PATCH',
-            body
-        });
-    }
-    /**
-   * DELETE 请求
-   * 
-   * @template TResponse - 响应数据类型
-   * @param url - 请求 URL
-   * @param options - 请求配置选项
-   * @returns Promise 解析为响应对象
-   */ async delete(url, options) {
-        return this.request({
-            ...options,
-            url,
-            method: 'DELETE'
-        });
-    }
-    /**
-   * 合并请求配置
-   * 
-   * @param options - 请求配置选项
-   * @returns 合并后的配置
-   */ mergeOptions(options) {
-        const baseURL = this.config.baseURL || '';
-        const url = baseURL ? `${baseURL}${options.url}` : options.url;
-        return {
-            ...options,
-            url,
-            headers: {
-                ...this.config.defaultHeaders,
-                ...options.headers
-            },
-            timeout: options.timeout ?? this.config.defaultTimeout
-        };
-    }
-    /**
-   * 创建请求错误
-   */ createError(message, type, code, options) {
-        return new RequestError(message, type, code, options);
-    }
-    /**
-   * 标准化错误
-   */ normalizeError(error, request) {
-        if (error instanceof RequestError) {
-            return error;
-        }
-        // 处理 AbortError
-        if (error instanceof Error && error.name === 'AbortError') {
-            return this.createError('请求已取消', RequestErrorType.ABORT_ERROR, RequestErrorCode.REQUEST_ABORTED, {
-                cause: error,
-                request
-            });
-        }
-        // 处理超时错误
-        if (error instanceof Error && (error.message.includes('timeout') || error.message.includes('Timeout'))) {
-            return this.createError('请求超时', RequestErrorType.TIMEOUT_ERROR, RequestErrorCode.REQUEST_TIMEOUT, {
-                cause: error,
-                request
-            });
-        }
-        // 处理网络错误
-        if (error instanceof Error && (error.message.includes('network') || error.message.includes('Network'))) {
-            return this.createError('网络连接失败', RequestErrorType.NETWORK_ERROR, RequestErrorCode.NETWORK_CONNECTION_FAILED, {
-                cause: error,
-                request
-            });
-        }
-        // 处理 HTTP 错误（需要适配器提供）
-        if (error && typeof error === 'object' && 'status' in error) {
-            const status = error.status;
-            const isServerError = status >= 500;
-            return this.createError(`HTTP ${status} 错误`, RequestErrorType.HTTP_ERROR, isServerError ? RequestErrorCode.SERVER_ERROR : RequestErrorCode.CLIENT_ERROR, {
-                status,
-                cause: error,
-                request
-            });
-        }
-        // 未知错误
-        return this.createError(error instanceof Error ? error.message : '未知错误', RequestErrorType.UNKNOWN_ERROR, RequestErrorCode.NETWORK_CONNECTION_FAILED, {
-            cause: error,
-            request
-        });
-    }
-    /**
-   * 销毁客户端
-   */ async destroy() {
-        if (this.adapter?.destroy) {
-            await this.adapter.destroy();
-        }
-        this.pluginManager.clear();
-        this.adapter = null;
-        this.adapterName = null;
-    }
-    constructor(config = {}){
-        _define_property(this, "config", void 0);
-        _define_property(this, "pluginManager", void 0);
-        _define_property(this, "adapter", null);
-        _define_property(this, "adapterName", null);
-        this.config = config;
-        this.pluginManager = new PluginManager();
-        // 注册插件
-        if (config.plugins) {
-            for (const plugin of config.plugins){
-                this.pluginManager.register(plugin);
-            }
-        }
-    }
-}
-
-//# sourceMappingURL=RequestClient.js.map