vafast 0.3.7 → 0.3.10

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

@@ -2,67 +2,75 @@ import { TSchema, Static } from '@sinclair/typebox';
 export { Static, TSchema, Type } from '@sinclair/typebox';
 
 /**
- * 高性能 Schema 验证器
+ * Schema 验证器 - 简洁版
  *
- * 使用 TypeBox TypeCompiler 进行 JIT 编译
- * 编译后的验证器会被缓存，避免重复编译开销
+ * 特点：
+ * - WeakMap 缓存避免内存泄漏
+ * - TypeCompiler JIT 编译，性能最佳
+ * - 支持 FormatRegistry（需确保同一实例）
  *
- * @version 2.0.0 - 添加预编译缓存
+ * @version 7.0.0
  */
 
+/** Schema 配置接口 */
+interface SchemaConfig {
+    body?: TSchema;
+    query?: TSchema;
+    params?: TSchema;
+    headers?: TSchema;
+    cookies?: TSchema;
+}
 /** 验证错误接口 */
 interface ValidationError {
     path: string;
     message: string;
     code: string;
     value?: unknown;
-    schema?: unknown;
 }
-/** 验证失败结果接口 */
-interface ValidationFailure {
-    success: false;
-    errors: ValidationError[];
-}
-/** 验证成功结果接口 */
-interface ValidationSuccess<T> {
+/** 验证结果 */
+type ValidationResult<T = unknown> = {
     success: true;
     data: T;
-}
-/** 验证结果联合类型 */
-type ValidationResult<T = unknown> = ValidationSuccess<T> | ValidationFailure;
-/**
- * 预编译 Schema（在启动时调用，避免首次请求的编译开销）
- * @param schemas 要预编译的 Schema 数组
- */
-declare function precompileSchemas(schemas: TSchema[]): void;
+} | {
+    success: false;
+    errors: ValidationError[];
+};
 /**
- * 使用TypeBox Schema验证数据（带缓存优化）
- * @param schema TypeBox Schema
- * @param data 要验证的数据
- * @returns 验证结果，包含类型安全的数据或详细错误信息
+ * 验证单个 Schema（返回结果对象）
  */
 declare function validateSchema<T extends TSchema>(schema: T, data: unknown): ValidationResult<Static<T>>;
 /**
- * 创建类型特化的验证器（最高性能）
- * 适用于频繁验证同一 Schema 的场景
- * @param schema TypeBox Schema
- * @returns 类型安全的验证函数
+ * 验证 Schema（抛出异常版本，用于框架内部）
  */
-declare function createValidator<T extends TSchema>(schema: T): (data: unknown) => ValidationResult<Static<T>>;
+declare function validateSchemaOrThrow<T extends TSchema>(schema: T, data: unknown, context: string): Static<T>;
 /**
- * 快速验证（只返回布尔值，不收集错误）
- * 适用于只需要知道验证结果的场景
- * @param schema TypeBox Schema
- * @param data 要验证的数据
- * @returns 验证是否通过
+ * 快速验证（只返回布尔值）
  */
 declare function validateFast<T extends TSchema>(schema: T, data: unknown): data is Static<T>;
 /**
- * 获取缓存统计信息（用于调试）
+ * 批量验证所有 Schema（用于请求验证）
+ */
+declare function validateAllSchemas(config: SchemaConfig, data: {
+    body: unknown;
+    query: unknown;
+    params: unknown;
+    headers: unknown;
+    cookies: unknown;
+}): typeof data;
+/**
+ * 预编译 Schema（启动时调用，避免首次请求开销）
+ */
+declare function precompileSchemas(config: SchemaConfig): void;
+/**
+ * 创建类型特化的验证器（高频使用场景）
+ */
+declare function createValidator<T extends TSchema>(schema: T): (data: unknown) => ValidationResult<Static<T>>;
+/**
+ * 获取缓存统计（调试用）
  */
 declare function getValidatorCacheStats(): {
     cacheType: string;
     note: string;
 };
 
-export { type ValidationError, type ValidationFailure, type ValidationResult, type ValidationSuccess, createValidator, getValidatorCacheStats, precompileSchemas, validateFast, validateSchema };
+export { type SchemaConfig, type ValidationError, type ValidationResult, createValidator, getValidatorCacheStats, precompileSchemas, validateAllSchemas, validateFast, validateSchema, validateSchemaOrThrow };

package/dist/utils/validators/validators.js

@@ -10,76 +10,78 @@ function getCompiledValidator(schema) {
   }
   return compiler;
 }
-function precompileSchemas(schemas) {
-  for (const schema of schemas) {
-    getCompiledValidator(schema);
-  }
-}
 function validateSchema(schema, data) {
   try {
     const compiler = getCompiledValidator(schema);
     if (compiler.Check(data)) {
-      return {
-        success: true,
-        data
-      };
+      return { success: true, data };
     }
     const errors = [];
-    const errorIterator = compiler.Errors(data);
-    for (const error of errorIterator) {
+    for (const error of compiler.Errors(data)) {
       errors.push({
         path: error.path,
         message: error.message,
         code: "VALIDATION_FAILED",
-        value: error.value,
-        schema: error.schema
+        value: error.value
       });
     }
-    return {
-      success: false,
-      errors
-    };
+    return { success: false, errors };
   } catch (error) {
     return {
       success: false,
       errors: [
         {
           path: "",
-          message: error instanceof Error ? error.message : "Unknown validation error",
-          code: "VALIDATION_EXCEPTION",
-          value: data
+          message: error instanceof Error ? error.message : "\u9A8C\u8BC1\u5F02\u5E38",
+          code: "VALIDATION_EXCEPTION"
         }
       ]
     };
   }
 }
-function createValidator(schema) {
+function validateSchemaOrThrow(schema, data, context) {
   const compiler = getCompiledValidator(schema);
-  return (data) => {
-    if (compiler.Check(data)) {
-      return { success: true, 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 };
-  };
+  if (!compiler.Check(data)) {
+    throw new Error(`${context}\u9A8C\u8BC1\u5931\u8D25`);
+  }
+  return data;
 }
 function validateFast(schema, data) {
   const compiler = getCompiledValidator(schema);
   return compiler.Check(data);
 }
+function validateAllSchemas(config, data) {
+  if (config.body) {
+    validateSchemaOrThrow(config.body, data.body, "\u8BF7\u6C42\u4F53");
+  }
+  if (config.query) {
+    validateSchemaOrThrow(config.query, data.query, "Query\u53C2\u6570");
+  }
+  if (config.params) {
+    validateSchemaOrThrow(config.params, data.params, "\u8DEF\u5F84\u53C2\u6570");
+  }
+  if (config.headers) {
+    validateSchemaOrThrow(config.headers, data.headers, "\u8BF7\u6C42\u5934");
+  }
+  if (config.cookies) {
+    validateSchemaOrThrow(config.cookies, data.cookies, "Cookie");
+  }
+  return data;
+}
+function precompileSchemas(config) {
+  if (config.body) getCompiledValidator(config.body);
+  if (config.query) getCompiledValidator(config.query);
+  if (config.params) getCompiledValidator(config.params);
+  if (config.headers) getCompiledValidator(config.headers);
+  if (config.cookies) getCompiledValidator(config.cookies);
+}
+function createValidator(schema) {
+  return (data) => validateSchema(schema, data);
+}
 function getValidatorCacheStats() {
   return {
     cacheType: "WeakMap",
-    note: "WeakMap \u4E0D\u652F\u6301 size \u5C5E\u6027\uFF0C\u7F13\u5B58\u4F1A\u968F Schema \u5BF9\u8C61\u81EA\u52A8\u6E05\u7406"
+    note: "WeakMap \u7F13\u5B58\u4F1A\u968F Schema \u5BF9\u8C61\u81EA\u52A8\u6E05\u7406\uFF0C\u65E0\u5185\u5B58\u6CC4\u6F0F\u98CE\u9669"
   };
 }
 export {
@@ -87,7 +89,9 @@ export {
   createValidator,
   getValidatorCacheStats,
   precompileSchemas,
+  validateAllSchemas,
   validateFast,
-  validateSchema
+  validateSchema,
+  validateSchemaOrThrow
 };
 //# sourceMappingURL=validators.js.map

package/dist/utils/validators/validators.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/validators/validators.ts"],"sourcesContent":["// src/utils/validators.ts\n/**\n * 高性能 Schema 验证器\n *\n * 使用 TypeBox TypeCompiler 进行 JIT 编译\n * 编译后的验证器会被缓存，避免重复编译开销\n *\n * @version 2.0.0 - 添加预编译缓存\n */\n\nimport { Type } from \"@sinclair/typebox\";\nimport type { Static, TSchema } from \"@sinclair/typebox\";\nimport { TypeCompiler, type TypeCheck } from \"@sinclair/typebox/compiler\";\n\n/** 验证错误接口 */\nexport interface ValidationError {\n  path: string;\n  message: string;\n  code: string;\n  value?: unknown;\n  schema?: unknown;\n}\n\n/** 验证失败结果接口 */\nexport interface ValidationFailure {\n  success: false;\n  errors: ValidationError[];\n}\n\n/** 验证成功结果接口 */\nexport interface ValidationSuccess<T> {\n  success: true;\n  data: T;\n}\n\n/** 验证结果联合类型 */\nexport type ValidationResult<T = unknown> =\n  | ValidationSuccess<T>\n  | ValidationFailure;\n\n/**\n * 编译器缓存\n * 使用 WeakMap 避免内存泄漏（Schema 对象被垃圾回收时，缓存也会自动清理）\n */\nconst compilerCache = new WeakMap<TSchema, TypeCheck<TSchema>>();\n\n/**\n * 获取或创建编译后的验证器\n * @param schema TypeBox Schema\n * @returns 编译后的验证器\n */\nfunction getCompiledValidator<T extends TSchema>(schema: T): TypeCheck<T> {\n  let compiler = compilerCache.get(schema);\n  if (!compiler) {\n    compiler = TypeCompiler.Compile(schema);\n    compilerCache.set(schema, compiler);\n  }\n  return compiler as TypeCheck<T>;\n}\n\n/**\n * 预编译 Schema（在启动时调用，避免首次请求的编译开销）\n * @param schemas 要预编译的 Schema 数组\n */\nexport function precompileSchemas(schemas: TSchema[]): void {\n  for (const schema of schemas) {\n    getCompiledValidator(schema);\n  }\n}\n\n/**\n * 使用TypeBox Schema验证数据（带缓存优化）\n * @param schema TypeBox Schema\n * @param data 要验证的数据\n * @returns 验证结果，包含类型安全的数据或详细错误信息\n */\nexport function validateSchema<T extends TSchema>(\n  schema: T,\n  data: unknown,\n): ValidationResult<Static<T>> {\n  try {\n    // 从缓存获取或编译验证器\n    const compiler = getCompiledValidator(schema);\n\n    if (compiler.Check(data)) {\n      return {\n        success: true,\n        data: data as Static<T>,\n      };\n    }\n\n    // 验证失败时，使用Errors函数生成详细的错误信息\n    const errors: ValidationError[] = [];\n    const errorIterator = compiler.Errors(data);\n\n    // 收集所有错误（可以根据需要限制数量）\n    for (const error of errorIterator) {\n      errors.push({\n        path: error.path,\n        message: error.message,\n        code: \"VALIDATION_FAILED\",\n        value: error.value,\n        schema: error.schema,\n      });\n    }\n\n    return {\n      success: false,\n      errors,\n    };\n  } catch (error) {\n    // 处理验证过程中的异常\n    return {\n      success: false,\n      errors: [\n        {\n          path: \"\",\n          message:\n            error instanceof Error ? error.message : \"Unknown validation error\",\n          code: \"VALIDATION_EXCEPTION\",\n          value: data,\n        },\n      ],\n    };\n  }\n}\n\n/**\n * 创建类型特化的验证器（最高性能）\n * 适用于频繁验证同一 Schema 的场景\n * @param schema TypeBox Schema\n * @returns 类型安全的验证函数\n */\nexport function createValidator<T extends TSchema>(\n  schema: T,\n): (data: unknown) => ValidationResult<Static<T>> {\n  const compiler = getCompiledValidator(schema);\n\n  return (data: unknown): ValidationResult<Static<T>> => {\n    if (compiler.Check(data)) {\n      return { success: true, data: data as Static<T> };\n    }\n\n    const errors: ValidationError[] = [];\n    for (const error of compiler.Errors(data)) {\n      errors.push({\n        path: error.path,\n        message: error.message,\n        code: \"VALIDATION_FAILED\",\n        value: error.value,\n        schema: error.schema,\n      });\n    }\n    return { success: false, errors };\n  };\n}\n\n/**\n * 快速验证（只返回布尔值，不收集错误）\n * 适用于只需要知道验证结果的场景\n * @param schema TypeBox Schema\n * @param data 要验证的数据\n * @returns 验证是否通过\n */\nexport function validateFast<T extends TSchema>(\n  schema: T,\n  data: unknown,\n): data is Static<T> {\n  const compiler = getCompiledValidator(schema);\n  return compiler.Check(data);\n}\n\n/**\n * 获取缓存统计信息（用于调试）\n */\nexport function getValidatorCacheStats(): { cacheType: string; note: string } {\n  return {\n    cacheType: \"WeakMap\",\n    note: \"WeakMap 不支持 size 属性，缓存会随 Schema 对象自动清理\",\n  };\n}\n\n// 导出常用的TypeBox类型，方便使用\nexport { Type, Static, TSchema };\n"],"mappings":";AAUA,SAAS,YAAY;AAErB,SAAS,oBAAoC;AAgC7C,IAAM,gBAAgB,oBAAI,QAAqC;AAO/D,SAAS,qBAAwC,QAAyB;AACxE,MAAI,WAAW,cAAc,IAAI,MAAM;AACvC,MAAI,CAAC,UAAU;AACb,eAAW,aAAa,QAAQ,MAAM;AACtC,kBAAc,IAAI,QAAQ,QAAQ;AAAA,EACpC;AACA,SAAO;AACT;AAMO,SAAS,kBAAkB,SAA0B;AAC1D,aAAW,UAAU,SAAS;AAC5B,yBAAqB,MAAM;AAAA,EAC7B;AACF;AAQO,SAAS,eACd,QACA,MAC6B;AAC7B,MAAI;AAEF,UAAM,WAAW,qBAAqB,MAAM;AAE5C,QAAI,SAAS,MAAM,IAAI,GAAG;AACxB,aAAO;AAAA,QACL,SAAS;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAGA,UAAM,SAA4B,CAAC;AACnC,UAAM,gBAAgB,SAAS,OAAO,IAAI;AAG1C,eAAW,SAAS,eAAe;AACjC,aAAO,KAAK;AAAA,QACV,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,QACf,MAAM;AAAA,QACN,OAAO,MAAM;AAAA,QACb,QAAQ,MAAM;AAAA,MAChB,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,MACL,SAAS;AAAA,MACT;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AAEd,WAAO;AAAA,MACL,SAAS;AAAA,MACT,QAAQ;AAAA,QACN;AAAA,UACE,MAAM;AAAA,UACN,SACE,iBAAiB,QAAQ,MAAM,UAAU;AAAA,UAC3C,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,gBACd,QACgD;AAChD,QAAM,WAAW,qBAAqB,MAAM;AAE5C,SAAO,CAAC,SAA+C;AACrD,QAAI,SAAS,MAAM,IAAI,GAAG;AACxB,aAAO,EAAE,SAAS,MAAM,KAAwB;AAAA,IAClD;AAEA,UAAM,SAA4B,CAAC;AACnC,eAAW,SAAS,SAAS,OAAO,IAAI,GAAG;AACzC,aAAO,KAAK;AAAA,QACV,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,QACf,MAAM;AAAA,QACN,OAAO,MAAM;AAAA,QACb,QAAQ,MAAM;AAAA,MAChB,CAAC;AAAA,IACH;AACA,WAAO,EAAE,SAAS,OAAO,OAAO;AAAA,EAClC;AACF;AASO,SAAS,aACd,QACA,MACmB;AACnB,QAAM,WAAW,qBAAqB,MAAM;AAC5C,SAAO,SAAS,MAAM,IAAI;AAC5B;AAKO,SAAS,yBAA8D;AAC5E,SAAO;AAAA,IACL,WAAW;AAAA,IACX,MAAM;AAAA,EACR;AACF;","names":[]}
+{"version":3,"sources":["../../../src/utils/validators/validators.ts"],"sourcesContent":["/**\n * Schema 验证器 - 简洁版\n *\n * 特点：\n * - WeakMap 缓存避免内存泄漏\n * - TypeCompiler JIT 编译，性能最佳\n * - 支持 FormatRegistry（需确保同一实例）\n *\n * @version 7.0.0\n */\n\nimport { Type } from \"@sinclair/typebox\";\nimport type { Static, TSchema } from \"@sinclair/typebox\";\nimport { TypeCompiler, type TypeCheck } from \"@sinclair/typebox/compiler\";\nimport { Value } from \"@sinclair/typebox/value\";\n\n// ============== 类型定义 ==============\n\n/** Schema 配置接口 */\nexport interface SchemaConfig {\n  body?: TSchema;\n  query?: TSchema;\n  params?: TSchema;\n  headers?: TSchema;\n  cookies?: TSchema;\n}\n\n/** 验证错误接口 */\nexport interface ValidationError {\n  path: string;\n  message: string;\n  code: string;\n  value?: unknown;\n}\n\n/** 验证结果 */\nexport type ValidationResult<T = unknown> =\n  | { success: true; data: T }\n  | { success: false; errors: ValidationError[] };\n\n// ============== 缓存 ==============\n\n/** 编译器缓存 - WeakMap 避免内存泄漏 */\nconst compilerCache = new WeakMap<TSchema, TypeCheck<TSchema>>();\n\n// ============== 核心函数 ==============\n\n/**\n * 获取或创建编译后的验证器\n */\nfunction getCompiledValidator<T extends TSchema>(schema: T): TypeCheck<T> {\n  let compiler = compilerCache.get(schema);\n  if (!compiler) {\n    compiler = TypeCompiler.Compile(schema);\n    compilerCache.set(schema, compiler);\n  }\n  return compiler as TypeCheck<T>;\n}\n\n/**\n * 验证单个 Schema（返回结果对象）\n */\nexport function validateSchema<T extends TSchema>(\n  schema: T,\n  data: unknown,\n): ValidationResult<Static<T>> {\n  try {\n    const compiler = getCompiledValidator(schema);\n\n    if (compiler.Check(data)) {\n      return { success: true, data: data as Static<T> };\n    }\n\n    // 收集错误\n    const errors: ValidationError[] = [];\n    for (const error of compiler.Errors(data)) {\n      errors.push({\n        path: error.path,\n        message: error.message,\n        code: \"VALIDATION_FAILED\",\n        value: error.value,\n      });\n    }\n    return { success: false, errors };\n  } catch (error) {\n    return {\n      success: false,\n      errors: [\n        {\n          path: \"\",\n          message: error instanceof Error ? error.message : \"验证异常\",\n          code: \"VALIDATION_EXCEPTION\",\n        },\n      ],\n    };\n  }\n}\n\n/**\n * 验证 Schema（抛出异常版本，用于框架内部）\n */\nexport function validateSchemaOrThrow<T extends TSchema>(\n  schema: T,\n  data: unknown,\n  context: string,\n): Static<T> {\n  const compiler = getCompiledValidator(schema);\n\n  if (!compiler.Check(data)) {\n    throw new Error(`${context}验证失败`);\n  }\n\n  return data as Static<T>;\n}\n\n/**\n * 快速验证（只返回布尔值）\n */\nexport function validateFast<T extends TSchema>(\n  schema: T,\n  data: unknown,\n): data is Static<T> {\n  const compiler = getCompiledValidator(schema);\n  return compiler.Check(data);\n}\n\n/**\n * 批量验证所有 Schema（用于请求验证）\n */\nexport function validateAllSchemas(\n  config: SchemaConfig,\n  data: {\n    body: unknown;\n    query: unknown;\n    params: unknown;\n    headers: unknown;\n    cookies: unknown;\n  },\n): typeof data {\n  if (config.body) {\n    validateSchemaOrThrow(config.body, data.body, \"请求体\");\n  }\n  if (config.query) {\n    validateSchemaOrThrow(config.query, data.query, \"Query参数\");\n  }\n  if (config.params) {\n    validateSchemaOrThrow(config.params, data.params, \"路径参数\");\n  }\n  if (config.headers) {\n    validateSchemaOrThrow(config.headers, data.headers, \"请求头\");\n  }\n  if (config.cookies) {\n    validateSchemaOrThrow(config.cookies, data.cookies, \"Cookie\");\n  }\n  return data;\n}\n\n/**\n * 预编译 Schema（启动时调用，避免首次请求开销）\n */\nexport function precompileSchemas(config: SchemaConfig): void {\n  if (config.body) getCompiledValidator(config.body);\n  if (config.query) getCompiledValidator(config.query);\n  if (config.params) getCompiledValidator(config.params);\n  if (config.headers) getCompiledValidator(config.headers);\n  if (config.cookies) getCompiledValidator(config.cookies);\n}\n\n/**\n * 创建类型特化的验证器（高频使用场景）\n */\nexport function createValidator<T extends TSchema>(\n  schema: T,\n): (data: unknown) => ValidationResult<Static<T>> {\n  return (data: unknown) => validateSchema(schema, data);\n}\n\n/**\n * 获取缓存统计（调试用）\n */\nexport function getValidatorCacheStats(): { cacheType: string; note: string } {\n  return {\n    cacheType: \"WeakMap\",\n    note: \"WeakMap 缓存会随 Schema 对象自动清理，无内存泄漏风险\",\n  };\n}\n\n// 导出 TypeBox 类型\nexport { Type, Static, TSchema };\n"],"mappings":";AAWA,SAAS,YAAY;AAErB,SAAS,oBAAoC;AA8B7C,IAAM,gBAAgB,oBAAI,QAAqC;AAO/D,SAAS,qBAAwC,QAAyB;AACxE,MAAI,WAAW,cAAc,IAAI,MAAM;AACvC,MAAI,CAAC,UAAU;AACb,eAAW,aAAa,QAAQ,MAAM;AACtC,kBAAc,IAAI,QAAQ,QAAQ;AAAA,EACpC;AACA,SAAO;AACT;AAKO,SAAS,eACd,QACA,MAC6B;AAC7B,MAAI;AACF,UAAM,WAAW,qBAAqB,MAAM;AAE5C,QAAI,SAAS,MAAM,IAAI,GAAG;AACxB,aAAO,EAAE,SAAS,MAAM,KAAwB;AAAA,IAClD;AAGA,UAAM,SAA4B,CAAC;AACnC,eAAW,SAAS,SAAS,OAAO,IAAI,GAAG;AACzC,aAAO,KAAK;AAAA,QACV,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,QACf,MAAM;AAAA,QACN,OAAO,MAAM;AAAA,MACf,CAAC;AAAA,IACH;AACA,WAAO,EAAE,SAAS,OAAO,OAAO;AAAA,EAClC,SAAS,OAAO;AACd,WAAO;AAAA,MACL,SAAS;AAAA,MACT,QAAQ;AAAA,QACN;AAAA,UACE,MAAM;AAAA,UACN,SAAS,iBAAiB,QAAQ,MAAM,UAAU;AAAA,UAClD,MAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAKO,SAAS,sBACd,QACA,MACA,SACW;AACX,QAAM,WAAW,qBAAqB,MAAM;AAE5C,MAAI,CAAC,SAAS,MAAM,IAAI,GAAG;AACzB,UAAM,IAAI,MAAM,GAAG,OAAO,0BAAM;AAAA,EAClC;AAEA,SAAO;AACT;AAKO,SAAS,aACd,QACA,MACmB;AACnB,QAAM,WAAW,qBAAqB,MAAM;AAC5C,SAAO,SAAS,MAAM,IAAI;AAC5B;AAKO,SAAS,mBACd,QACA,MAOa;AACb,MAAI,OAAO,MAAM;AACf,0BAAsB,OAAO,MAAM,KAAK,MAAM,oBAAK;AAAA,EACrD;AACA,MAAI,OAAO,OAAO;AAChB,0BAAsB,OAAO,OAAO,KAAK,OAAO,mBAAS;AAAA,EAC3D;AACA,MAAI,OAAO,QAAQ;AACjB,0BAAsB,OAAO,QAAQ,KAAK,QAAQ,0BAAM;AAAA,EAC1D;AACA,MAAI,OAAO,SAAS;AAClB,0BAAsB,OAAO,SAAS,KAAK,SAAS,oBAAK;AAAA,EAC3D;AACA,MAAI,OAAO,SAAS;AAClB,0BAAsB,OAAO,SAAS,KAAK,SAAS,QAAQ;AAAA,EAC9D;AACA,SAAO;AACT;AAKO,SAAS,kBAAkB,QAA4B;AAC5D,MAAI,OAAO,KAAM,sBAAqB,OAAO,IAAI;AACjD,MAAI,OAAO,MAAO,sBAAqB,OAAO,KAAK;AACnD,MAAI,OAAO,OAAQ,sBAAqB,OAAO,MAAM;AACrD,MAAI,OAAO,QAAS,sBAAqB,OAAO,OAAO;AACvD,MAAI,OAAO,QAAS,sBAAqB,OAAO,OAAO;AACzD;AAKO,SAAS,gBACd,QACgD;AAChD,SAAO,CAAC,SAAkB,eAAe,QAAQ,IAAI;AACvD;AAKO,SAAS,yBAA8D;AAC5E,SAAO;AAAA,IACL,WAAW;AAAA,IACX,MAAM;AAAA,EACR;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vafast",
-  "version": "0.3.7",
+  "version": "0.3.10",
   "description": "极简结构化Web框架，支持 Bun 和 Node.js。Go风格，函数优先。",
   "type": "module",
   "repository": {
@@ -13,49 +13,31 @@
   },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js",
-      "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./mod": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js",
-      "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./node-server": {
+      "types": "./dist/node-server/index.d.ts",
       "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",
   "main": "./dist/index.js",
   "scripts": {
-    "clean": "rimraf dist",
     "build": "tsup",
-    "dev": "bun --watch example/index.ts",
-    "start": "bun run dist/index.js",
+    "dev": "npx tsx watch example/index.ts",
     "test": "vitest run",
-    "test:run": "vitest run",
-    "test:watch": "vitest",
-    "test:unit": "vitest run tests/unit/",
-    "test:integration": "vitest run tests/integration/",
-    "test:coverage": "vitest run --coverage",
-    "test:ui": "vitest --ui",
-    "test:types": "tsc --noEmit",
-    "benchmark": "bun run benchmarks/micro/router.bench.ts",
-    "lint": "eslint src tests benchmarks",
-    "lint:fix": "eslint src tests benchmarks --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\" \"benchmarks/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\" \"benchmarks/**/*.ts\"",
-    "type-check": "tsc --noEmit",
-    "prepublishOnly": "npm run build && npm run test",
-    "release:patch": "npm version patch && npm run build && npm run test && npm publish --access=public && git push && git push --tags",
-    "release:minor": "npm version minor && npm run build && npm run test && npm publish --access=public && git push && git push --tags",
-    "release:major": "npm version major && npm run build && npm run test && npm publish --access=public && git push && git push --tags"
+    "release": "npm run build && npm run test && npx bumpp && npm publish --access=public"
   },
   "keywords": [
     "bun",

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

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

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

@@ -1,241 +0,0 @@
-// src/utils/validators/validators.ts
-import { Type } from "@sinclair/typebox";
-import { TypeCompiler } from "@sinclair/typebox/compiler";
-var compilerCache = /* @__PURE__ */ new WeakMap();
-function getCompiledValidator(schema) {
-  let compiler = compilerCache.get(schema);
-  if (!compiler) {
-    compiler = TypeCompiler.Compile(schema);
-    compilerCache.set(schema, compiler);
-  }
-  return compiler;
-}
-function validateSchema(schema, data) {
-  try {
-    const compiler = getCompiledValidator(schema);
-    if (compiler.Check(data)) {
-      return {
-        success: true,
-        data
-      };
-    }
-    const errors = [];
-    const errorIterator = compiler.Errors(data);
-    for (const error of errorIterator) {
-      errors.push({
-        path: error.path,
-        message: error.message,
-        code: "VALIDATION_FAILED",
-        value: error.value,
-        schema: error.schema
-      });
-    }
-    return {
-      success: false,
-      errors
-    };
-  } catch (error) {
-    return {
-      success: false,
-      errors: [
-        {
-          path: "",
-          message: error instanceof Error ? error.message : "Unknown validation error",
-          code: "VALIDATION_EXCEPTION",
-          value: data
-        }
-      ]
-    };
-  }
-}
-
-// src/utils/validators/schema-validator.ts
-function validateSingleSchema(schema, data, fieldName) {
-  return validateSchema(schema, data);
-}
-function validateSchemaConfig(config, data) {
-  const errors = [];
-  const validatedData = {};
-  if (config.body && data.body !== void 0) {
-    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 !== void 0) {
-    validatedData.body = data.body;
-  }
-  if (config.query && data.query !== void 0) {
-    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 !== void 0) {
-    validatedData.query = data.query;
-  }
-  if (config.params && data.params !== void 0) {
-    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 !== void 0) {
-    validatedData.params = data.params;
-  }
-  if (config.headers && data.headers !== void 0) {
-    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 !== void 0) {
-    validatedData.headers = data.headers;
-  }
-  if (config.cookies && data.cookies !== void 0) {
-    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 !== void 0) {
-    validatedData.cookies = data.cookies;
-  }
-  if (data.body !== void 0 && !config.body) {
-    validatedData.body = data.body;
-  }
-  if (data.query !== void 0 && !config.query) {
-    validatedData.query = data.query;
-  }
-  if (data.params !== void 0 && !config.params) {
-    validatedData.params = data.params;
-  }
-  if (data.headers !== void 0 && !config.headers) {
-    validatedData.headers = data.headers;
-  }
-  if (data.cookies !== void 0 && !config.cookies) {
-    validatedData.cookies = data.cookies;
-  }
-  if (errors.length > 0) {
-    return {
-      success: false,
-      errors
-    };
-  }
-  return {
-    success: true,
-    data: validatedData
-  };
-}
-async function validateSchemaConfigAsync(config, data) {
-  const errors = [];
-  const validatedData = {};
-  const validationPromises = [];
-  if (config.body && data.body !== void 0) {
-    validationPromises.push(
-      Promise.resolve({
-        field: "body",
-        result: validateSingleSchema(config.body, data.body, "body")
-      })
-    );
-  }
-  if (config.query && data.query !== void 0) {
-    validationPromises.push(
-      Promise.resolve({
-        field: "query",
-        result: validateSingleSchema(config.query, data.query, "query")
-      })
-    );
-  }
-  if (config.params && data.params !== void 0) {
-    validationPromises.push(
-      Promise.resolve({
-        field: "params",
-        result: validateSingleSchema(config.params, data.params, "params")
-      })
-    );
-  }
-  if (config.headers && data.headers !== void 0) {
-    validationPromises.push(
-      Promise.resolve({
-        field: "headers",
-        result: validateSingleSchema(config.headers, data.headers, "headers")
-      })
-    );
-  }
-  if (config.cookies && data.cookies !== void 0) {
-    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 !== void 0 && !config.body) validatedData.body = data.body;
-  if (data.query !== void 0 && !config.query)
-    validatedData.query = data.query;
-  if (data.params !== void 0 && !config.params)
-    validatedData.params = data.params;
-  if (data.headers !== void 0 && !config.headers)
-    validatedData.headers = data.headers;
-  if (data.cookies !== void 0 && !config.cookies)
-    validatedData.cookies = data.cookies;
-  if (errors.length > 0) {
-    return {
-      success: false,
-      errors
-    };
-  }
-  return {
-    success: true,
-    data: validatedData
-  };
-}
-function createSchemaValidator(config) {
-  return (data) => {
-    return validateSchemaConfig(config, data);
-  };
-}
-function createAsyncSchemaValidator(config) {
-  return (data) => {
-    return validateSchemaConfigAsync(config, data);
-  };
-}
-export {
-  createAsyncSchemaValidator,
-  createSchemaValidator,
-  validateSchemaConfig,
-  validateSchemaConfigAsync
-};
-/**
- * Schema配置验证器
- *
- * 使用validateSchema函数对SchemaConfig结构的数据进行验证
- * 提供统一的验证接口和错误处理
- *
- * @author Framework Team
- * @version 1.0.0
- * @license MIT
- */
-//# sourceMappingURL=schema-validator.js.map