vafast 0.1.10 → 0.1.12

package/dist/utils/request-validator.js

@@ -0,0 +1,94 @@
+/**
+ * 请求解析和验证器
+ *
+ * 解析handler的req参数，使用Ultra验证器进行验证，
+ * 并类型安全地返回解析出来的值
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import { validateAllSchemasUltra, } from "./validators/schema-validators-ultra";
+import { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
+/**
+ * 解析Request对象，提取所有相关数据
+ * @param request Request对象
+ * @param params 路径参数（可选）
+ * @returns 解析后的请求数据
+ */
+export async function parseRequest(request, params) {
+    const requestData = {
+        body: undefined,
+        query: parseQuery(request),
+        params: params || {},
+        headers: parseHeaders(request),
+        cookies: parseCookies(request),
+    };
+    // 对于非GET请求，尝试解析请求体
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        requestData.body = await parseBody(request);
+    }
+    return requestData;
+}
+/**
+ * 验证请求数据
+ * @param config Schema配置
+ * @param requestData 请求数据
+ * @returns 验证结果
+ */
+export function validateRequest(config, requestData) {
+    try {
+        const validatedData = validateAllSchemasUltra(config, requestData);
+        return {
+            success: true,
+            data: validatedData,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            errors: [
+                {
+                    field: "unknown",
+                    message: error instanceof Error ? error.message : "验证失败",
+                },
+            ],
+        };
+    }
+}
+/**
+ * 完整的请求解析和验证流程
+ * @param request Request对象
+ * @param config Schema配置
+ * @param params 路径参数（可选）
+ * @returns 验证结果
+ */
+export async function parseAndValidateRequest(request, config, params) {
+    try {
+        // 1. 解析请求
+        const requestData = await parseRequest(request, params);
+        // 2. 验证数据
+        return validateRequest(config, requestData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            errors: [
+                {
+                    field: "unknown",
+                    message: error instanceof Error ? error.message : "请求解析失败",
+                },
+            ],
+        };
+    }
+}
+/**
+ * 创建类型安全的请求验证器工厂
+ * @param config Schema配置
+ * @returns 验证器函数
+ */
+export function createRequestValidator(config) {
+    return async (request, params) => {
+        return parseAndValidateRequest(request, config, params);
+    };
+}

package/dist/utils/response.d.ts

@@ -0,0 +1,12 @@
+/** 生成 JSON 响应 */
+export declare function json(data: unknown, status?: number, headers?: HeadersInit): Response;
+/** 生成重定向响应 */
+export declare function redirect(location: string, status?: 301 | 302): Response;
+/** 生成纯文本响应 */
+export declare function text(content: string, status?: number, headers?: HeadersInit): Response;
+/** 生成HTML响应 */
+export declare function html(content: string, status?: number, headers?: HeadersInit): Response;
+/** 生成空响应（204 No Content） */
+export declare function empty(status?: number, headers?: HeadersInit): Response;
+/** 生成流式响应 */
+export declare function stream(stream: ReadableStream, status?: number, headers?: HeadersInit): Response;

package/dist/utils/response.js

@@ -0,0 +1,69 @@
+// src/response.ts
+/** 生成 JSON 响应 */
+export function json(data, status = 200, headers = {}) {
+    // 优化：只在有自定义 headers 时才创建 Headers 对象
+    if (Object.keys(headers).length === 0) {
+        return new Response(JSON.stringify(data), {
+            status,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    // 有自定义 headers 时才创建 Headers 对象
+    const h = new Headers({
+        "Content-Type": "application/json",
+        ...headers,
+    });
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: h,
+    });
+}
+/** 生成重定向响应 */
+export function redirect(location, status = 302) {
+    return new Response(null, {
+        status,
+        headers: {
+            Location: location,
+        },
+    });
+}
+/** 生成纯文本响应 */
+export function text(content, status = 200, headers = {}) {
+    const h = new Headers({
+        "Content-Type": "text/plain; charset=utf-8",
+        ...headers,
+    });
+    return new Response(content, {
+        status,
+        headers: h,
+    });
+}
+/** 生成HTML响应 */
+export function html(content, status = 200, headers = {}) {
+    const h = new Headers({
+        "Content-Type": "text/html; charset=utf-8",
+        ...headers,
+    });
+    return new Response(content, {
+        status,
+        headers: h,
+    });
+}
+/** 生成空响应（204 No Content） */
+export function empty(status = 204, headers = {}) {
+    return new Response(null, {
+        status,
+        headers,
+    });
+}
+/** 生成流式响应 */
+export function stream(stream, status = 200, headers = {}) {
+    const h = new Headers({
+        "Content-Type": "application/octet-stream",
+        ...headers,
+    });
+    return new Response(stream, {
+        status,
+        headers: h,
+    });
+}

package/dist/utils/route-handler-factory.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 路由处理器工厂
+ *
+ * 负责创建和配置路由处理器，处理请求数据解析和验证
+ * 提供统一的错误处理和响应格式
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+import { type SchemaConfig } from "./validators/schema-validators-ultra";
+import type { Static } from "@sinclair/typebox";
+export interface TypedConfig extends SchemaConfig {
+    docs?: any;
+    timeout?: number;
+    maxBodySize?: string;
+    validationErrorHandler?: ValidationErrorHandler;
+    [key: string]: any;
+}
+export type ValidationErrorHandler = (error: Error, field: string, value: any, schema: any) => Response | Promise<Response>;
+export type TypedHandler<TBody = any, TQuery = any, TParams = any, THeaders = any, TCookies = any, TExtra extends object = {}> = (ctx: {
+    req: Request;
+    body: TBody;
+    query: TQuery;
+    params: TParams;
+    headers: THeaders;
+    cookies: TCookies;
+} & TExtra) => Response | Promise<Response> | any | Promise<any>;
+export declare function createRouteHandler<TConfig extends TypedConfig, TBody = TConfig extends {
+    body: any;
+} ? Static<TConfig["body"]> : any, TQuery = TConfig extends {
+    query: any;
+} ? Static<TConfig["query"]> : any, TParams = TConfig extends {
+    params: any;
+} ? Static<TConfig["params"]> : any, THeaders = TConfig extends {
+    headers: any;
+} ? Static<TConfig["headers"]> : any, TCookies = TConfig extends {
+    cookies: any;
+} ? Static<TConfig["cookies"]> : any, TExtra extends object = {}>(handler: TypedHandler<TBody, TQuery, TParams, THeaders, TCookies, TExtra>, config?: TConfig): (req: Request) => Promise<Response>;
+export declare function withExtra<TExtra extends object = {}>(): <TConfig extends TypedConfig>(config: TConfig, handler: TypedHandler<TConfig extends {
+    body: any;
+} ? Static<TConfig["body"]> : any, TConfig extends {
+    query: any;
+} ? Static<TConfig["query"]> : any, TConfig extends {
+    params: any;
+} ? Static<TConfig["params"]> : any, TConfig extends {
+    headers: any;
+} ? Static<TConfig["headers"]> : any, TConfig extends {
+    cookies: any;
+} ? Static<TConfig["cookies"]> : any, TExtra>) => (req: Request) => Promise<Response>;

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);
+    };
+}
+// 类型已经在上面定义并导出，无需重复导出