vafast 0.1.11 → 0.1.12

package/dist/utils/route-handler-factory.js

@@ -0,0 +1,181 @@
+/**
+ * 路由处理器工厂
+ *
+ * 负责创建和配置路由处理器，处理请求数据解析和验证
+ * 提供统一的错误处理和响应格式
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import { parseQuery, parseHeaders, parseCookies, parseBody } from "./parsers";
+import { goAwait } from "./go-await";
+import { json } from "./response";
+import { validateAllSchemasUltra, precompileSchemasUltra, } from "./validators/schema-validators-ultra";
+// 默认验证错误处理器
+const defaultValidationErrorHandler = (error, field, value, schema) => {
+    return json({
+        success: false,
+        error: "Validation Error",
+        message: error instanceof Error ? error.message : "验证失败",
+        field,
+        receivedValue: value,
+        timestamp: new Date().toISOString(),
+    }, 400);
+};
+// 预定义的常用响应头，避免重复创建
+const TEXT_HEADERS = { "Content-Type": "text/plain; charset=utf-8" };
+const JSON_HEADERS = { "Content-Type": "application/json" };
+const EMPTY_RESPONSE_204 = new Response(null, { status: 204 });
+// 超高性能的 Response 自动转换函数 - 生产环境推荐使用
+function autoResponseUltra(result) {
+    // 快速路径：已经是 Response 对象
+    if (result instanceof Response) {
+        return result;
+    }
+    // 快速路径：null/undefined - 复用预创建的对象
+    if (result === null || result === undefined) {
+        return EMPTY_RESPONSE_204;
+    }
+    // 使用 switch 语句优化类型检查
+    switch (typeof result) {
+        case "string":
+            // 优化：复用预定义的头部对象
+            return new Response(result, { headers: TEXT_HEADERS });
+        case "number":
+        case "boolean":
+            // 优化：使用更高效的字符串转换，复用头部
+            return new Response(result.toString(), { headers: TEXT_HEADERS });
+        case "object":
+            // 检查是否是 { data, status, headers } 格式
+            if ("data" in result) {
+                const { data, status = 200, headers = {} } = result;
+                // 无内容
+                if (data === null || data === undefined) {
+                    return new Response("", {
+                        status: status === 200 ? 204 : status,
+                        headers,
+                    });
+                }
+                // 纯文本类型
+                if (typeof data === "string" ||
+                    typeof data === "number" ||
+                    typeof data === "boolean") {
+                    // 优化：减少对象展开操作，直接构建最终对象
+                    const finalHeaders = {
+                        "Content-Type": "text/plain; charset=utf-8",
+                        ...headers,
+                    };
+                    return new Response(data.toString(), {
+                        status,
+                        headers: finalHeaders,
+                    });
+                }
+                // JSON 类型 - 复用 json 函数
+                return json(data, status, headers);
+            }
+            // 普通对象/数组，复用 json 函数
+            return json(result);
+        default:
+            // 其他类型（如 symbol, function 等）
+            return EMPTY_RESPONSE_204;
+    }
+}
+// 创建路由处理器的通用函数
+export function createRouteHandler(handler, config = {}) {
+    // 检查哪些验证器是必需的
+    const hasBodySchema = config.body !== undefined;
+    const hasQuerySchema = config.query !== undefined;
+    const hasParamsSchema = config.params !== undefined;
+    const hasHeadersSchema = config.headers !== undefined;
+    const hasCookiesSchema = config.cookies !== undefined;
+    // 只在有验证器时预编译Schema
+    if (hasBodySchema ||
+        hasQuerySchema ||
+        hasParamsSchema ||
+        hasHeadersSchema ||
+        hasCookiesSchema) {
+        precompileSchemasUltra(config);
+    }
+    // 获取验证错误处理器
+    const errorHandler = config.validationErrorHandler || defaultValidationErrorHandler;
+    return async (req) => {
+        try {
+            let queryObj = {};
+            let headers = {};
+            let cookies = {};
+            let body = undefined;
+            let params = {};
+            // 默认总是解析所有数据，只有在有验证器时才进行验证
+            queryObj = parseQuery(req);
+            headers = parseHeaders(req);
+            cookies = parseCookies(req);
+            // 总是解析 body
+            const [, parsedBody] = await goAwait(parseBody(req));
+            body = parsedBody;
+            // 总是尝试获取路径参数
+            params = (req.pathParams ||
+                req.params ||
+                {});
+            // 只在有验证器时执行验证
+            if (hasBodySchema ||
+                hasQuerySchema ||
+                hasParamsSchema ||
+                hasHeadersSchema ||
+                hasCookiesSchema) {
+                const data = { body, query: queryObj, params, headers, cookies };
+                validateAllSchemasUltra(config, data);
+            }
+            // 合并中间件注入的本地上下文
+            const extras = (req.__locals ?? {});
+            // 调用处理器，传递上下文
+            const result = await handler({
+                req,
+                body,
+                query: queryObj,
+                params,
+                headers,
+                cookies,
+                ...extras,
+            });
+            return autoResponseUltra(result);
+        }
+        catch (error) {
+            // 使用用户自定义的验证错误处理器
+            if (error instanceof Error && error.message.includes("验证失败")) {
+                // 尝试提取字段信息
+                const field = extractFieldFromError(error);
+                const value = extractValueFromError(error);
+                const schema = extractSchemaFromError(error);
+                return await errorHandler(error, field, value, schema);
+            }
+            // 其他错误使用默认处理
+            return json({
+                success: false,
+                error: "Internal Error",
+                message: error instanceof Error ? error.message : "未知错误",
+            }, 500);
+        }
+    };
+}
+// 从错误中提取字段信息的辅助函数
+function extractFieldFromError(error) {
+    // 尝试从错误消息中提取字段名
+    const fieldMatch = error.message.match(/字段\s*(\w+)/);
+    return fieldMatch ? fieldMatch[1] : "unknown";
+}
+// 从错误中提取值的辅助函数
+function extractValueFromError(error) {
+    // 这里可以根据实际错误类型提取值
+    return undefined;
+}
+// 从错误中提取Schema的辅助函数
+function extractSchemaFromError(error) {
+    // 这里可以根据实际错误类型提取Schema
+    return undefined;
+}
+export function withExtra() {
+    return function withExtraHandler(config, handler) {
+        return createRouteHandler(handler, config);
+    };
+}

package/dist/utils/validators/schema-validator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Schema配置验证器
+ *
+ * 使用validateSchema函数对SchemaConfig结构的数据进行验证
+ * 提供统一的验证接口和错误处理
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import type { TSchema } from "@sinclair/typebox";
+import { type ValidationResult } from "./validators";
+export interface SchemaConfig {
+    body?: TSchema;
+    query?: TSchema;
+    params?: TSchema;
+    headers?: TSchema;
+    cookies?: TSchema;
+}
+export interface RequestData {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    headers?: unknown;
+    cookies?: unknown;
+}
+export interface SchemaValidationResult {
+    success: boolean;
+    data?: {
+        body?: unknown;
+        query?: unknown;
+        params?: unknown;
+        headers?: unknown;
+        cookies?: unknown;
+    };
+    errors?: Array<{
+        field: keyof SchemaConfig;
+        error: ValidationResult<unknown>;
+    }>;
+}
+/**
+ * 使用SchemaConfig验证完整的请求数据
+ * @param config Schema配置
+ * @param data 请求数据
+ * @returns 验证结果
+ */
+export declare function validateSchemaConfig(config: SchemaConfig, data: RequestData): SchemaValidationResult;
+/**
+ * 异步验证SchemaConfig（支持异步验证器）
+ * @param config Schema配置
+ * @param data 请求数据
+ * @returns Promise<验证结果>
+ */
+export declare function validateSchemaConfigAsync(config: SchemaConfig, data: RequestData): Promise<SchemaValidationResult>;
+/**
+ * 创建验证器工厂函数
+ * @param config Schema配置
+ * @returns 验证器函数
+ */
+export declare function createSchemaValidator(config: SchemaConfig): (data: RequestData) => SchemaValidationResult;
+/**
+ * 创建异步验证器工厂函数
+ * @param config Schema配置
+ * @returns 异步验证器函数
+ */
+export declare function createAsyncSchemaValidator(config: SchemaConfig): (data: RequestData) => Promise<SchemaValidationResult>;

package/dist/utils/validators/schema-validator.js

@@ -0,0 +1,222 @@
+/**
+ * Schema配置验证器
+ *
+ * 使用validateSchema函数对SchemaConfig结构的数据进行验证
+ * 提供统一的验证接口和错误处理
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import { validateSchema } from "./validators";
+/**
+ * 验证单个Schema配置项
+ * @param schema Schema定义
+ * @param data 要验证的数据
+ * @param fieldName 字段名称（用于错误标识）
+ * @returns 验证结果
+ */
+function validateSingleSchema(schema, data, fieldName) {
+    return validateSchema(schema, data);
+}
+/**
+ * 使用SchemaConfig验证完整的请求数据
+ * @param config Schema配置
+ * @param data 请求数据
+ * @returns 验证结果
+ */
+export function validateSchemaConfig(config, data) {
+    const errors = [];
+    const validatedData = {};
+    // 验证body
+    if (config.body && data.body !== undefined) {
+        const result = validateSingleSchema(config.body, data.body, "body");
+        if (result.success) {
+            validatedData.body = result.data;
+        }
+        else {
+            errors.push({ field: "body", error: result });
+        }
+    }
+    else if (data.body !== undefined) {
+        validatedData.body = data.body;
+    }
+    // 验证query
+    if (config.query && data.query !== undefined) {
+        const result = validateSingleSchema(config.query, data.query, "query");
+        if (result.success) {
+            validatedData.query = result.data;
+        }
+        else {
+            errors.push({ field: "query", error: result });
+        }
+    }
+    else if (data.query !== undefined) {
+        validatedData.query = data.query;
+    }
+    // 验证params
+    if (config.params && data.params !== undefined) {
+        const result = validateSingleSchema(config.params, data.params, "params");
+        if (result.success) {
+            validatedData.params = result.data;
+        }
+        else {
+            errors.push({ field: "params", error: result });
+        }
+    }
+    else if (data.params !== undefined) {
+        validatedData.params = data.params;
+    }
+    // 验证headers
+    if (config.headers && data.headers !== undefined) {
+        const result = validateSingleSchema(config.headers, data.headers, "headers");
+        if (result.success) {
+            validatedData.headers = result.data;
+        }
+        else {
+            errors.push({ field: "headers", error: result });
+        }
+    }
+    else if (data.headers !== undefined) {
+        validatedData.headers = data.headers;
+    }
+    // 验证cookies
+    if (config.cookies && data.cookies !== undefined) {
+        const result = validateSingleSchema(config.cookies, data.cookies, "cookies");
+        if (result.success) {
+            validatedData.cookies = result.data;
+        }
+        else {
+            errors.push({ field: "cookies", error: result });
+        }
+    }
+    else if (data.cookies !== undefined) {
+        validatedData.cookies = data.cookies;
+    }
+    // 添加所有未配置但存在的数据字段
+    if (data.body !== undefined && !config.body) {
+        validatedData.body = data.body;
+    }
+    if (data.query !== undefined && !config.query) {
+        validatedData.query = data.query;
+    }
+    if (data.params !== undefined && !config.params) {
+        validatedData.params = data.params;
+    }
+    if (data.headers !== undefined && !config.headers) {
+        validatedData.headers = data.headers;
+    }
+    if (data.cookies !== undefined && !config.cookies) {
+        validatedData.cookies = data.cookies;
+    }
+    // 如果有错误，返回失败结果
+    if (errors.length > 0) {
+        return {
+            success: false,
+            errors,
+        };
+    }
+    // 验证成功，返回验证后的数据
+    return {
+        success: true,
+        data: validatedData,
+    };
+}
+/**
+ * 异步验证SchemaConfig（支持异步验证器）
+ * @param config Schema配置
+ * @param data 请求数据
+ * @returns Promise<验证结果>
+ */
+export async function validateSchemaConfigAsync(config, data) {
+    const errors = [];
+    const validatedData = {};
+    // 并行验证所有Schema以提高性能
+    const validationPromises = [];
+    // 收集所有需要验证的字段
+    if (config.body && data.body !== undefined) {
+        validationPromises.push(Promise.resolve({
+            field: "body",
+            result: validateSingleSchema(config.body, data.body, "body"),
+        }));
+    }
+    if (config.query && data.query !== undefined) {
+        validationPromises.push(Promise.resolve({
+            field: "query",
+            result: validateSingleSchema(config.query, data.query, "query"),
+        }));
+    }
+    if (config.params && data.params !== undefined) {
+        validationPromises.push(Promise.resolve({
+            field: "params",
+            result: validateSingleSchema(config.params, data.params, "params"),
+        }));
+    }
+    if (config.headers && data.headers !== undefined) {
+        validationPromises.push(Promise.resolve({
+            field: "headers",
+            result: validateSingleSchema(config.headers, data.headers, "headers"),
+        }));
+    }
+    if (config.cookies && data.cookies !== undefined) {
+        validationPromises.push(Promise.resolve({
+            field: "cookies",
+            result: validateSingleSchema(config.cookies, data.cookies, "cookies"),
+        }));
+    }
+    // 等待所有验证完成
+    const results = await Promise.all(validationPromises);
+    // 处理验证结果
+    for (const { field, result } of results) {
+        if (result.success) {
+            validatedData[field] = result.data;
+        }
+        else {
+            errors.push({ field, error: result });
+        }
+    }
+    // 添加未验证但存在的数据
+    if (data.body !== undefined && !config.body)
+        validatedData.body = data.body;
+    if (data.query !== undefined && !config.query)
+        validatedData.query = data.query;
+    if (data.params !== undefined && !config.params)
+        validatedData.params = data.params;
+    if (data.headers !== undefined && !config.headers)
+        validatedData.headers = data.headers;
+    if (data.cookies !== undefined && !config.cookies)
+        validatedData.cookies = data.cookies;
+    // 如果有错误，返回失败结果
+    if (errors.length > 0) {
+        return {
+            success: false,
+            errors,
+        };
+    }
+    // 验证成功，返回验证后的数据
+    return {
+        success: true,
+        data: validatedData,
+    };
+}
+/**
+ * 创建验证器工厂函数
+ * @param config Schema配置
+ * @returns 验证器函数
+ */
+export function createSchemaValidator(config) {
+    return (data) => {
+        return validateSchemaConfig(config, data);
+    };
+}
+/**
+ * 创建异步验证器工厂函数
+ * @param config Schema配置
+ * @returns 异步验证器函数
+ */
+export function createAsyncSchemaValidator(config) {
+    return (data) => {
+        return validateSchemaConfigAsync(config, data);
+    };
+}
+// 类型已经在上面定义并导出，无需重复导出

package/dist/utils/validators/schema-validators-ultra.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 超优化版Schema验证器 v5.0.0
+ *
+ * 使用经过验证的优化技术，确保极致性能
+ * - 内联函数调用
+ * - 预编译缓存优化
+ * - 内存池优化
+ * - 位运算优化
+ * - 类型特化优化
+ * - 循环展开优化
+ * - 位掩码优化
+ * - 字符串池优化
+ * - 内联缓存优化
+ * - 内存对齐优化
+ *
+ * @author Framework Team
+ * @version 5.0.0
+ * @license MIT
+ */
+import type { TSchema } from "@sinclair/typebox";
+export interface SchemaConfig {
+    body?: TSchema;
+    query?: TSchema;
+    params?: TSchema;
+    headers?: TSchema;
+    cookies?: TSchema;
+}
+export declare function validateSchemaUltra(schema: TSchema | undefined, data: any, context: string): any;
+export declare function validateAllSchemasUltra(config: SchemaConfig, data: {
+    body: any;
+    query: any;
+    params: any;
+    headers: any;
+    cookies: any;
+}): any;
+export declare function precompileSchemasUltra(config: SchemaConfig): void;
+export declare function createTypedValidatorUltra<T>(schema: TSchema): (data: T) => T;
+export declare function validateBatchUltra<T>(schema: TSchema, dataArray: T[]): T[];
+export declare function getCacheStats(): {
+    totalSchemas: number;
+    totalHits: number;
+    hitRate: string;
+    cacheSize: number;
+    errorPoolUsage: string;
+    stringPoolSize: number;
+    memoryEfficiency: string;
+};
+export declare function smartClearUltraCache(keepTop?: number): void;
+export declare function clearUltraCache(): void;
+export declare function withPerformanceMonitoring<T extends (...args: any[]) => any>(fn: T, name: string): T;
+export { validateAllSchemasUltra as validateAllSchemas, createTypedValidatorUltra as createTypedValidator, validateBatchUltra as validateBatch, clearUltraCache as clearCache, smartClearUltraCache as smartClearCache, };