vafast 0.2.3 → 0.3.1

package/dist/utils/index.d.ts

@@ -2,7 +2,7 @@
  * 工具函数模块导出
  */
 export { createHandler, createHandlerWithExtra, simpleHandler, } from "./create-handler";
-export { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
+export { parseBody, parseQuery, parseQueryFast, parseHeaders, getHeader, parseCookies, parseCookiesFast, getCookie, } from "./parsers";
 export { json, text, html, redirect, empty, stream } from "./response";
 export { goAwait } from "./go-await";
 export { base64urlEncode, base64urlDecode } from "./base64url";
@@ -10,3 +10,4 @@ export { setLocals, getLocals } from "./handle";
 export { parseRequest, validateRequest, parseAndValidateRequest, createRequestValidator, } from "./request-validator";
 export { HtmlRenderer } from "./html-renderer";
 export { DependencyManager } from "./dependency-manager";
+export { validateSchema, createValidator, validateFast, precompileSchemas, getValidatorCacheStats, } from "./validators/validators";

package/dist/utils/index.js

@@ -4,7 +4,7 @@
 // 处理器工厂
 export { createHandler, createHandlerWithExtra, simpleHandler, } from "./create-handler";
 // 请求解析
-export { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
+export { parseBody, parseQuery, parseQueryFast, parseHeaders, getHeader, parseCookies, parseCookiesFast, getCookie, } from "./parsers";
 // 响应工具
 export { json, text, html, redirect, empty, stream } from "./response";
 // Go 风格错误处理
@@ -19,3 +19,5 @@ export { parseRequest, validateRequest, parseAndValidateRequest, createRequestVa
 export { HtmlRenderer } from "./html-renderer";
 // 依赖管理
 export { DependencyManager } from "./dependency-manager";
+// 验证器（JIT 编译）
+export { validateSchema, createValidator, validateFast, precompileSchemas, getValidatorCacheStats, } from "./validators/validators";

package/dist/utils/parsers.d.ts

@@ -29,8 +29,26 @@ export declare function parseFormData(req: Request): Promise<FormData>;
  */
 export declare function parseFile(req: Request): Promise<FileInfo>;
 /** 获取查询字符串，直接返回对象 */
-export declare function parseQuery(req: Request): Record<string, any>;
+export declare function parseQuery(req: Request): Record<string, unknown>;
+/**
+ * 快速解析简单查询字符串（不支持嵌套，但更快）
+ * 适用于简单的 key=value&key2=value2 场景
+ */
+export declare function parseQueryFast(req: Request): Record<string, string>;
 /** 解析请求头，返回对象 */
 export declare function parseHeaders(req: Request): Record<string, string>;
+/**
+ * 获取单个请求头（避免解析全部）
+ */
+export declare function getHeader(req: Request, name: string): string | null;
 /** 使用cookie库解析Cookie，保证可靠性 */
 export declare function parseCookies(req: Request): Record<string, string>;
+/**
+ * 快速解析 Cookie（简化版，不使用外部库）
+ * 适用于简单的 cookie 场景
+ */
+export declare function parseCookiesFast(req: Request): Record<string, string>;
+/**
+ * 获取单个 Cookie 值（避免解析全部）
+ */
+export declare function getCookie(req: Request, name: string): string | null;

package/dist/utils/parsers.js

@@ -87,21 +87,62 @@ export async function parseFile(req) {
     }
     return formData.files[fileKeys[0]];
 }
+/**
+ * 快速提取 query string（避免创建 URL 对象）
+ */
+function extractQueryString(url) {
+    const qIndex = url.indexOf("?");
+    if (qIndex === -1)
+        return "";
+    const hashIndex = url.indexOf("#", qIndex);
+    return hashIndex === -1
+        ? url.substring(qIndex + 1)
+        : url.substring(qIndex + 1, hashIndex);
+}
 /** 获取查询字符串，直接返回对象 */
 export function parseQuery(req) {
-    const url = new URL(req.url);
-    return qs.parse(url.search.slice(1)); // 去掉开头的 ?
+    const queryString = extractQueryString(req.url);
+    if (!queryString)
+        return {};
+    return qs.parse(queryString);
+}
+/**
+ * 快速解析简单查询字符串（不支持嵌套，但更快）
+ * 适用于简单的 key=value&key2=value2 场景
+ */
+export function parseQueryFast(req) {
+    const queryString = extractQueryString(req.url);
+    if (!queryString)
+        return {};
+    const result = Object.create(null);
+    const pairs = queryString.split("&");
+    for (const pair of pairs) {
+        const eqIndex = pair.indexOf("=");
+        if (eqIndex === -1) {
+            result[decodeURIComponent(pair)] = "";
+        }
+        else {
+            const key = decodeURIComponent(pair.substring(0, eqIndex));
+            const value = decodeURIComponent(pair.substring(eqIndex + 1));
+            result[key] = value;
+        }
+    }
+    return result;
 }
 /** 解析请求头，返回对象 */
 export function parseHeaders(req) {
-    const headers = {};
+    const headers = Object.create(null);
     req.headers.forEach((value, key) => {
-        if (value !== undefined && value !== null) {
-            headers[key] = value;
-        }
+        headers[key] = value;
     });
     return headers;
 }
+/**
+ * 获取单个请求头（避免解析全部）
+ */
+export function getHeader(req, name) {
+    return req.headers.get(name);
+}
 /** 使用cookie库解析Cookie，保证可靠性 */
 export function parseCookies(req) {
     const cookieHeader = req.headers.get("cookie");
@@ -118,9 +159,52 @@ export function parseCookies(req) {
         }
         return result;
     }
-    catch (error) {
-        console.error("Cookie解析失败:", error);
-        console.error("原始Cookie字符串:", cookieHeader);
+    catch {
         return {};
     }
 }
+/**
+ * 快速解析 Cookie（简化版，不使用外部库）
+ * 适用于简单的 cookie 场景
+ */
+export function parseCookiesFast(req) {
+    const cookieHeader = req.headers.get("cookie");
+    if (!cookieHeader)
+        return {};
+    const result = Object.create(null);
+    const pairs = cookieHeader.split(";");
+    for (const pair of pairs) {
+        const trimmed = pair.trim();
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex > 0) {
+            const key = trimmed.substring(0, eqIndex).trim();
+            const value = trimmed.substring(eqIndex + 1).trim();
+            // 移除引号
+            result[key] =
+                value.startsWith('"') && value.endsWith('"')
+                    ? value.slice(1, -1)
+                    : value;
+        }
+    }
+    return result;
+}
+/**
+ * 获取单个 Cookie 值（避免解析全部）
+ */
+export function getCookie(req, name) {
+    const cookieHeader = req.headers.get("cookie");
+    if (!cookieHeader)
+        return null;
+    const prefix = `${name}=`;
+    const pairs = cookieHeader.split(";");
+    for (const pair of pairs) {
+        const trimmed = pair.trim();
+        if (trimmed.startsWith(prefix)) {
+            const value = trimmed.substring(prefix.length).trim();
+            return value.startsWith('"') && value.endsWith('"')
+                ? value.slice(1, -1)
+                : value;
+        }
+    }
+    return null;
+}

package/dist/utils/response.js

@@ -1,9 +1,10 @@
 // src/response.ts
 /** 生成 JSON 响应 */
 export function json(data, status = 200, headers = {}) {
+    const body = JSON.stringify(data);
     // 优化：只在有自定义 headers 时才创建 Headers 对象
     if (Object.keys(headers).length === 0) {
-        return new Response(JSON.stringify(data), {
+        return new Response(body, {
             status,
             headers: { "Content-Type": "application/json" },
         });
@@ -13,7 +14,7 @@ export function json(data, status = 200, headers = {}) {
         "Content-Type": "application/json",
         ...headers,
     });
-    return new Response(JSON.stringify(data), {
+    return new Response(body, {
         status,
         headers: h,
     });
@@ -55,7 +56,7 @@ export function mapResponse(response) {
             if (response instanceof Promise) {
                 return response.then(mapResponse);
             }
-            // 其他情况尝试 JSON
+            // 其他情况使用 JSON 序列化
             return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
     }
 }

package/dist/utils/validators/validators.d.ts

@@ -1,3 +1,11 @@
+/**
+ * 高性能 Schema 验证器
+ *
+ * 使用 TypeBox TypeCompiler 进行 JIT 编译
+ * 编译后的验证器会被缓存，避免重复编译开销
+ *
+ * @version 2.0.0 - 添加预编译缓存
+ */
 import { Type } from "@sinclair/typebox";
 import type { Static, TSchema } from "@sinclair/typebox";
 /** 验证错误接口 */
@@ -21,10 +29,37 @@ export interface ValidationSuccess<T> {
 /** 验证结果联合类型 */
 export type ValidationResult<T = unknown> = ValidationSuccess<T> | ValidationFailure;
 /**
- * 使用TypeBox Schema验证数据
+ * 预编译 Schema（在启动时调用，避免首次请求的编译开销）
+ * @param schemas 要预编译的 Schema 数组
+ */
+export declare function precompileSchemas(schemas: TSchema[]): void;
+/**
+ * 使用TypeBox Schema验证数据（带缓存优化）
  * @param schema TypeBox Schema
  * @param data 要验证的数据
  * @returns 验证结果，包含类型安全的数据或详细错误信息
  */
 export declare function validateSchema<T extends TSchema>(schema: T, data: unknown): ValidationResult<Static<T>>;
+/**
+ * 创建类型特化的验证器（最高性能）
+ * 适用于频繁验证同一 Schema 的场景
+ * @param schema TypeBox Schema
+ * @returns 类型安全的验证函数
+ */
+export declare function createValidator<T extends TSchema>(schema: T): (data: unknown) => ValidationResult<Static<T>>;
+/**
+ * 快速验证（只返回布尔值，不收集错误）
+ * 适用于只需要知道验证结果的场景
+ * @param schema TypeBox Schema
+ * @param data 要验证的数据
+ * @returns 验证是否通过
+ */
+export declare function validateFast<T extends TSchema>(schema: T, data: unknown): data is Static<T>;
+/**
+ * 获取缓存统计信息（用于调试）
+ */
+export declare function getValidatorCacheStats(): {
+    cacheType: string;
+    note: string;
+};
 export { Type, Static, TSchema };

package/dist/utils/validators/validators.js

@@ -1,16 +1,51 @@
 // src/utils/validators.ts
+/**
+ * 高性能 Schema 验证器
+ *
+ * 使用 TypeBox TypeCompiler 进行 JIT 编译
+ * 编译后的验证器会被缓存，避免重复编译开销
+ *
+ * @version 2.0.0 - 添加预编译缓存
+ */
 import { Type } from "@sinclair/typebox";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 /**
- * 使用TypeBox Schema验证数据
+ * 编译器缓存
+ * 使用 WeakMap 避免内存泄漏（Schema 对象被垃圾回收时，缓存也会自动清理）
+ */
+const compilerCache = new WeakMap();
+/**
+ * 获取或创建编译后的验证器
+ * @param schema TypeBox Schema
+ * @returns 编译后的验证器
+ */
+function getCompiledValidator(schema) {
+    let compiler = compilerCache.get(schema);
+    if (!compiler) {
+        compiler = TypeCompiler.Compile(schema);
+        compilerCache.set(schema, compiler);
+    }
+    return compiler;
+}
+/**
+ * 预编译 Schema（在启动时调用，避免首次请求的编译开销）
+ * @param schemas 要预编译的 Schema 数组
+ */
+export function precompileSchemas(schemas) {
+    for (const schema of schemas) {
+        getCompiledValidator(schema);
+    }
+}
+/**
+ * 使用TypeBox Schema验证数据（带缓存优化）
  * @param schema TypeBox Schema
  * @param data 要验证的数据
  * @returns 验证结果，包含类型安全的数据或详细错误信息
  */
 export function validateSchema(schema, data) {
     try {
-        // 使用TypeBox的TypeCompiler进行验证
-        const compiler = TypeCompiler.Compile(schema);
+        // 从缓存获取或编译验证器
+        const compiler = getCompiledValidator(schema);
         if (compiler.Check(data)) {
             return {
                 success: true,
@@ -50,5 +85,50 @@ export function validateSchema(schema, data) {
         };
     }
 }
+/**
+ * 创建类型特化的验证器（最高性能）
+ * 适用于频繁验证同一 Schema 的场景
+ * @param schema TypeBox Schema
+ * @returns 类型安全的验证函数
+ */
+export function createValidator(schema) {
+    const compiler = getCompiledValidator(schema);
+    return (data) => {
+        if (compiler.Check(data)) {
+            return { success: true, data: data };
+        }
+        const errors = [];
+        for (const error of compiler.Errors(data)) {
+            errors.push({
+                path: error.path,
+                message: error.message,
+                code: "VALIDATION_FAILED",
+                value: error.value,
+                schema: error.schema,
+            });
+        }
+        return { success: false, errors };
+    };
+}
+/**
+ * 快速验证（只返回布尔值，不收集错误）
+ * 适用于只需要知道验证结果的场景
+ * @param schema TypeBox Schema
+ * @param data 要验证的数据
+ * @returns 验证是否通过
+ */
+export function validateFast(schema, data) {
+    const compiler = getCompiledValidator(schema);
+    return compiler.Check(data);
+}
+/**
+ * 获取缓存统计信息（用于调试）
+ */
+export function getValidatorCacheStats() {
+    return {
+        cacheType: "WeakMap",
+        note: "WeakMap 不支持 size 属性，缓存会随 Schema 对象自动清理",
+    };
+}
 // 导出常用的TypeBox类型，方便使用
 export { Type };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vafast",
-  "version": "0.2.3",
-  "description": "专为Bun构建的极简结构化Web框架。Go风格，函数优先。",
+  "version": "0.3.1",
+  "description": "极简结构化Web框架，支持 Bun 和 Node.js。Go风格，函数优先。",
   "type": "module",
   "repository": {
     "type": "git",
@@ -23,6 +23,12 @@
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./node-server": {
+      "import": "./dist/node-server/index.js",
+      "require": "./dist/node-server/index.js",
+      "types": "./dist/node-server/index.d.ts",
+      "default": "./dist/node-server/index.js"
     }
   },
   "types": "./dist/index.d.ts",
@@ -53,6 +59,7 @@
   },
   "keywords": [
     "bun",
+    "node",
     "framework",
     "minimal",
     "router",