kb-server 0.0.11 → 0.0.13

package/README.md

@@ -1,44 +1,452 @@
 # KB Server
 
-快速创建一个 `Node` 服务 - 基于 `Express`
+基于 `Express` 的快速 Node.js 服务框架，提供简洁的 API 开发体验、标准错误码、SSE 支持、统一鉴权和完善的日志系统。
 
-快速创建 `API`、标准错误码、`Server`、支持统一鉴权函数（API 级别）、自定义中间件、日志、支持 `SSE`
+## 特性
+
+- 🚀 快速创建 REST API
+- 🎯 基于类的参数校验（使用 class-validator）
+- 🔒 统一鉴权函数（API 级别）
+- 📡 原生支持 SSE (Server-Sent Events)
+- 📋 标准错误码系统
+- 🔌 支持自定义 Express 中间件
+- 📊 内置日志系统（基于 pino）
+- 🌍 统一的响应格式
+
+## 安装
+
+```bash
+npm install kb-server
+```
+
+要求 Node.js >= 18.0.0
+
+## 快速开始
+
+### 基础用法
 
 ```typescript
 import { createServer } from "kb-server";
 import * as apis from "./apis";
 
-// 写法一
+// 写法一：直接创建并启动
 const server = createServer({ apis });
 server.listen(3000);
 
-// 写法二
+// 写法二：异步初始化后启动
 (async () => {
-  // 其他的异步操作，例如：初始化数据库
+  // 其他异步操作，例如：初始化数据库
   return createServer({ apis });
 })().then((app) => app.listen(3000));
 ```
 
-## SSE 支持
+### 创建 API
+
+使用 `implementAPI` 创建带有类型安全的 API：
+
+```typescript
+import { implementAPI } from "kb-server";
+import { IsString, IsNotEmpty } from "class-validator";
+
+// 定义请求参数类
+class CreateUserParams {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsString()
+  @IsNotEmpty()
+  email: string;
+}
+
+// 定义 API 函数类型
+type CreateUserFn = (params: CreateUserParams) => Promise<{ id: string }>;
+
+// 实现 API
+export const createUser = implementAPI<CreateUserFn>(
+  {} as CreateUserFn,
+  CreateUserParams,
+  async (params, ctx) => {
+    // ctx.RequestId - 请求 ID
+    // ctx.AuthInfo - 鉴权信息（如果配置了 authFn）
+    console.log(`Request ID: ${ctx.RequestId}`);
+
+    // 业务逻辑
+    const user = await database.createUser(params);
+
+    return { id: user.id };
+  }
+);
+
+// 导出所有 API
+export default {
+  CreateUser: createUser,
+};
+```
+
+### 配置服务器
 
 ```typescript
 import { createServer } from "kb-server";
+import cors from "cors";
 import * as apis from "./apis";
 import * as sse from "./sse";
 
+const server = createServer(
+  {
+    apis,                    // API 列表
+    authFn,                  // 鉴权函数（可选）
+    log: true,               // 是否开启请求日志
+    middlewares: [cors()],   // 自定义中间件列表
+    sse: {                   // SSE 配置（可选）
+      handlers: sse,         // SSE 处理函数
+      route: "/sse",        // SSE 路由（默认: /sse）
+      timeout: 30000,        // 超时时间（毫秒，默认: 30000）
+    },
+  },
+  {
+    limit: "10mb",           // 请求体大小限制（默认: 10mb）
+  }
+);
 
-(async () => {
-  // 其他的异步操作，例如：初始化数据库
-  return createServer({
-    apis,
-    sse: {
-      handlers: sse, // ...SSE处理函数
+server.listen(3000);
+```
+
+## SSE 支持
+
+创建 SSE API 实现实时数据推送：
+
+```typescript
+import { implementSseAPI } from "kb-server";
+import { IsString } from "class-validator";
+
+// 定义请求参数
+class StreamChatParams {
+  @IsString()
+  prompt: string;
+}
+
+// 定义 SSE 函数类型
+type StreamChatFn = (params: StreamChatParams) => Promise<void>;
+
+// 实现 SSE API
+export const streamChat = implementSseAPI<StreamChatFn>(
+  {} as StreamChatFn,
+  StreamChatParams,
+  async (params, sse, ctx) => {
+    // sse.push(data) - 推送数据到客户端
+    // sse.close() - 主动关闭连接
+    // sse.abortController - 中止控制器
+
+    try {
+      // 模拟流式推送
+      for (let i = 0; i < 10; i++) {
+        sse.push({
+          chunk: `消息片段 ${i + 1}`,
+          progress: (i + 1) * 10,
+        });
+
+        // 模拟延迟
+        await new Promise(resolve => setTimeout(resolve, 500));
+      }
+
+      // 完成后关闭连接
+      sse.close();
+    } catch (error) {
+      // 可以使用 abortController 中止操作
+      if (!sse.abortController.signal.aborted) {
+        throw error;
+      }
+    }
+  }
+);
+
+// 导出 SSE API
+export default {
+  StreamChat: streamChat,
+};
+```
+
+## 统一鉴权
+
+在 API 级别实现统一的鉴权逻辑：
+
+```typescript
+import { createServer } from "kb-server";
+
+const authFn = async (action: string, req: express.Request) => {
+  // 从请求中获取 token
+  const token = req.headers.authorization?.replace('Bearer ', '');
+
+  if (!token) {
+    return false; // 返回 false 表示无权限
+  }
+
+  // 验证 token
+  const userInfo = await verifyToken(token);
+  if (!userInfo) {
+    return false;
+  }
+
+  // 返回对象会将信息注入到 ctx.AuthInfo
+  return {
+    userId: userInfo.id,
+    role: userInfo.role,
+  };
+};
+
+const server = createServer({
+  apis,
+  authFn,
+});
+
+// 在 API 中使用鉴权信息
+const myAPI = implementAPI<SomeFn>(
+  {} as SomeFn,
+  ParamsClass,
+  async (params, ctx) => {
+    const { userId, role } = ctx.AuthInfo || {};
+    console.log(`当前用户: ${userId}, 角色: ${role}`);
+
+    // 业务逻辑...
+  }
+);
+```
+
+## 自定义错误码
+
+使用 `createErrors` 创建业务特定的错误码：
+
+```typescript
+import { createErrors } from "kb-server";
+
+// 创建自定义错误码
+const CustomErrors = createErrors({
+  // 一级错误码（可选）
+  // InvalidParameter: {
+  //   // 扩展默认错误码
+  // },
+  BusinessError: {
+    // 新增业务错误码
+    InsufficientBalance: "余额不足",
+    OrderExpired: "订单已过期",
+    ProductOutOfStock: "商品库存不足",
+  },
+});
+
+// 使用自定义错误
+const someAPI = implementAPI<SomeFn>(
+  {} as SomeFn,
+  ParamsClass,
+  async (params, ctx) => {
+    const balance = await getBalance(ctx.AuthInfo?.userId);
+    if (balance < 100) {
+      throw new CustomErrors.BusinessError.InsufficientBalance();
+    }
+
+    // 业务逻辑...
+  }
+);
+```
+
+## 请求与响应格式
+
+### 请求格式
+
+所有 POST 请求体应包含以下结构：
+
+```json
+{
+  "Action": "API名称",
+  "其他参数": "..."
+}
+```
+
+### 成功响应
+
+```json
+{
+  "Response": {
+    "Data": {
+      // 返回的数据
     },
-    authFn: (action, req) => {
-      // ...统一鉴权函数
+    "RequestId": "uuid-v4"
+  }
+}
+```
+
+### 错误响应
+
+```json
+{
+  "Response": {
+    "Error": {
+      "Code": "InvalidParameter.ValidationError",
+      "Message": "参数校验失败"
     },
-    middlewares: [], // ...中间键列表
-    log: true, // ...框架日志
-  });
-})().then((app) => app.listen(3000));
+    "RequestId": "uuid-v4"
+  }
+}
 ```
+
+## 内置错误码
+
+| 一级错误码 | 二级错误码 | 说明 |
+|-----------|-----------|------|
+| InvalidParameter | EmptyParameter | 请求参数不能为空 |
+| InvalidParameter | EmptyAPIRequest | 未指定 API 的请求 |
+| InvalidParameter | ValidationError | 参数校验失败 |
+| InvalidParameter | RouteError | 路由错误 |
+| ResourceNotFound | APINotFound | 不存在的 API |
+| ResourceNotFound | AuthFunctionNotFound | 鉴权函数不存在 |
+| FailOperation | NoPermission | 无权操作 |
+| FailOperation | NotLogin | 未登录 |
+| InternalError | UnknownError | 未知错误 |
+| InternalError | ServiceError | 内部服务错误 |
+| InternalError | DatabaseError | DB 异常 |
+
+## 日志系统
+
+框架内置基于 pino 的日志系统，支持结构化日志：
+
+```typescript
+import { logger } from "kb-server";
+
+// 使用日志
+logger.info({ userId: 123, action: "login" }, "用户登录");
+logger.warn({ ip: "192.168.1.1" }, "异常访问");
+logger.error({ error: err }, "系统错误");
+```
+
+环境变量：
+- `LOG_LEVEL` - 日志级别（默认: info）
+- `NODE_ENV` - 环境模式（非 production 时使用 pino-pretty 格式化输出）
+
+## 完整示例
+
+```typescript
+import { createServer, implementAPI, createErrors } from "kb-server";
+import { IsString, IsEmail } from "class-validator";
+import cors from "cors";
+
+// 自定义错误码
+const AppErrors = createErrors({
+  UserError: {
+    DuplicateEmail: "邮箱已被注册",
+  },
+});
+
+// 参数类
+class RegisterParams {
+  @IsString()
+  @IsNotEmpty()
+  username: string;
+
+  @IsString()
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @IsNotEmpty()
+  password: string;
+}
+
+// 定义 API 类型
+type RegisterFn = (params: RegisterParams) => Promise<{ id: string }>;
+
+// 实现 API
+export const register = implementAPI<RegisterFn>(
+  {} as RegisterFn,
+  RegisterParams,
+  async (params, ctx) => {
+    // 检查邮箱是否已注册
+    const exists = await checkEmailExists(params.email);
+    if (exists) {
+      throw new AppErrors.UserError.DuplicateEmail();
+    }
+
+    // 创建用户
+    const user = await createUser(params);
+
+    return { id: user.id };
+  }
+);
+
+// 导出 API
+const apis = {
+  User_Register: register,
+};
+
+// 鉴权函数
+const authFn = async (action, req) => {
+  // 公开接口不需要鉴权
+  if (action.startsWith("User_")) {
+    return true;
+  }
+
+  // 其他接口需要鉴权
+  const token = req.headers.authorization?.replace('Bearer ', '');
+  return await verifyToken(token);
+};
+
+// 创建服务器
+const server = createServer({
+  apis,
+  authFn,
+  log: true,
+  middlewares: [cors()],
+});
+
+server.listen(3000, () => {
+  console.log('Server is running on http://localhost:3000');
+});
+```
+
+## API 参考
+
+### createServer
+
+创建 Express 服务器实例。
+
+```typescript
+function createServer(
+  params: ICreateServerParams,
+  options?: ICreateServerOptions
+): express.Application
+```
+
+**参数**:
+- `params.apis` - API 列表
+- `params.authFn` - 鉴权函数（可选）
+- `params.log` - 是否开启日志（默认: true）
+- `params.middlewares` - 自定义中间件列表（可选）
+- `params.sse` - SSE 配置（可选）
+- `options.limit` - 请求体大小限制（默认: "10mb"）
+
+### implementAPI
+
+实现带有类型检查的 API。
+
+```typescript
+function implementAPI<F, A = Record<string, any>>(
+  actionStub: F,
+  ParamsClass: Class<StubParam<F>>,
+  execution: APIExecution<StubParam<F>, ReturnType<F>, A>
+): API<StubParam<F>, ReturnType<F>>
+```
+
+### implementSseAPI
+
+实现 SSE API。
+
+```typescript
+function implementSseAPI<F, A = Record<string, any>>(
+  actionStub: F,
+  ParamsClass: Class<StubParam<F>>,
+  execution: SseExecution<StubParam<F>, ReturnType<F>, A>
+): API<StubParam<F>, ReturnType<F>>
+```
+
+## License
+
+ISC

package/dist/common/api-middleware.d.ts

@@ -26,7 +26,6 @@ export interface APIErrorResponse {
 export type AuthFunction = (action: string, req: express.Request) => Promise<Record<string, any> | boolean> | boolean | Record<string, any>;
 interface IPackAPIOptions {
     authFn?: AuthFunction;
-    log?: boolean;
 }
 /**
  * API包装函数

package/dist/common/api-middleware.js

@@ -4,13 +4,14 @@ exports.packAPI = void 0;
 const create_errors_1 = require("./create-errors");
 const uuid_1 = require("uuid");
 const logger_1 = require("../helper/logger");
+const sanitize_traceinfo_1 = require("./sanitize-traceinfo");
 /**
  * API包装函数
  * @param apis API列表
  * @returns
  */
 const packAPI = (apis, options) => {
-    const { authFn, log = true } = options || {};
+    const { authFn } = options || {};
     return async (req, res) => {
         // 生成API映射
         const apiMap = new Map(Object.entries(apis).map(([action, execution]) => [action, execution]));
@@ -24,19 +25,21 @@ const packAPI = (apis, options) => {
             RequestId: requestId,
         };
         // API 解析 - 将Action定义移到try块外部，以便在catch块中也能访问
-        const { Action, ...params } = req.body || {};
+        const { Action, TraceInfo, ...params } = req.body || {};
         try {
-            if (log) {
-                logger_1.logger.info({
-                    requestId,
-                    action: Action,
-                    params,
-                    path: req.path,
-                    method: req.method,
-                }, "请求入参");
-            }
+            // 安全处理TraceInfo
+            const safeTraceInfo = TraceInfo ? (0, sanitize_traceinfo_1.sanitizeTraceInfo)(TraceInfo) : undefined;
+            logger_1.logger.info({
+                requestId,
+                action: Action,
+                params,
+                path: req.path,
+                method: req.method,
+                traceInfo: safeTraceInfo,
+            }, "收到请求");
             // 接口未定义
             if (!Action) {
+                logger_1.logger.warn({ requestId, action: Action }, "接口未定义");
                 throw new create_errors_1.CommonErrors.InvalidParameter.EmptyAPIRequest();
             }
             // 处理鉴权函数
@@ -44,8 +47,10 @@ const packAPI = (apis, options) => {
                 if (typeof authFn !== "function") {
                     throw new create_errors_1.CommonErrors.ResourceNotFound.AuthFunctionNotFound();
                 }
+                logger_1.logger.info({ requestId, action: Action }, "开始执行框架权限检查");
                 const authResult = await authFn(Action, req);
                 if (!authResult) {
+                    logger_1.logger.warn({ requestId, action: Action }, "框架权限检查不通过");
                     throw new create_errors_1.CommonErrors.FailOperation.NoPermission();
                 }
                 if (typeof authResult !== "boolean") {
@@ -53,6 +58,7 @@ const packAPI = (apis, options) => {
                     ctx.AuthInfo = authResult || {};
                 }
             }
+            logger_1.logger.info({ requestId, action: Action, authInfo: ctx.AuthInfo }, "框架权限检查通过");
             // API 处理
             const execution = apiMap.get(Action);
             if (typeof execution !== "function") {
@@ -69,7 +75,7 @@ const packAPI = (apis, options) => {
             };
             // 完成响应
             took = Date.now() - start;
-            logger_1.logger.info({ requestId, action: Action, response, took }, "请求响应");
+            logger_1.logger.info({ requestId, action: Action, response, took }, "执行响应");
             return res.send(response);
         }
         catch (rawError) {

package/dist/common/create-server.d.ts

@@ -38,6 +38,7 @@ export interface ICreateServerParams {
     authFn?: AuthFunction;
     /**
      * 默认请求日志，true开启，false关闭
+     * @deprecated 请使用日志中间件代替（通过日志等级控制）下一版本将会废除
      */
     log?: boolean;
     /**

package/dist/common/create-server.js

@@ -43,7 +43,7 @@ function createServer(params, options) {
     // 注入SSE
     handlers && app.use((0, sse_middleware_1.packSSE)(handlers, { authFn, log, ...resetSSE }));
     // 注入API
-    app.use((0, api_middleware_1.packAPI)(apis, { authFn, log }));
+    app.use((0, api_middleware_1.packAPI)(apis, { authFn }));
     return app;
 }
 exports.createServer = createServer;

package/dist/common/sanitize-traceinfo.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 安全处理工具模块
+ * 用于对用户输入的数据进行安全清理，防止日志注入、敏感信息泄露等问题
+ */
+/**
+ * 安全处理配置选项
+ */
+export interface SanitizeOptions {
+    /** 最大嵌套深度，防止循环引用 */
+    maxDepth?: number;
+    /** 最大数组长度，防止数据过大 */
+    maxArrayLength?: number;
+    /** 最大对象属性数量 */
+    maxObjectKeys?: number;
+    /** 最大字符串长度 */
+    maxStringLength?: number;
+}
+/**
+ * 安全处理TraceInfo，防止安全漏洞
+ *
+ * @param traceInfo - 需要清理的数据
+ * @param options - 配置选项
+ * @returns 清理后的安全数据
+ *
+ * @example
+ * ```typescript
+ * const safeData = sanitizeTraceInfo({
+ *   username: 'test',
+ *   password: 'secret',
+ *   apiTrace: []
+ * });
+ * // 结果: { username: 'test', password: '[REDACTED]', apiTrace: [] }
+ * ```
+ */
+export declare function sanitizeTraceInfo(traceInfo: unknown, options?: SanitizeOptions): any;

package/dist/common/sanitize-traceinfo.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * 安全处理工具模块
+ * 用于对用户输入的数据进行安全清理，防止日志注入、敏感信息泄露等问题
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeTraceInfo = void 0;
+/**
+ * 需要脱敏的敏感字段列表
+ */
+const SENSITIVE_KEYS = [
+    'password',
+    'token',
+    'secret',
+    'key',
+    'auth',
+    'credential',
+    'cookie',
+];
+/**
+ * 默认配置
+ */
+const DEFAULT_OPTIONS = {
+    maxDepth: 5,
+    maxArrayLength: 100,
+    maxObjectKeys: 50,
+    maxStringLength: 1000,
+};
+/**
+ * 安全处理TraceInfo，防止安全漏洞
+ *
+ * @param traceInfo - 需要清理的数据
+ * @param options - 配置选项
+ * @returns 清理后的安全数据
+ *
+ * @example
+ * ```typescript
+ * const safeData = sanitizeTraceInfo({
+ *   username: 'test',
+ *   password: 'secret',
+ *   apiTrace: []
+ * });
+ * // 结果: { username: 'test', password: '[REDACTED]', apiTrace: [] }
+ * ```
+ */
+function sanitizeTraceInfo(traceInfo, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    return sanitizeValue(traceInfo, opts, 0);
+}
+exports.sanitizeTraceInfo = sanitizeTraceInfo;
+/**
+ * 递归清理数据
+ */
+function sanitizeValue(value, options, currentDepth) {
+    // 深度限制，防止循环引用导致的栈溢出
+    if (currentDepth > options.maxDepth) {
+        return '[MaxDepthReached]';
+    }
+    // 空值处理
+    if (value === null || value === undefined) {
+        return value;
+    }
+    // 原始类型直接处理字符串
+    if (typeof value !== 'object') {
+        return sanitizeString(value, options.maxStringLength);
+    }
+    // 数组处理
+    if (Array.isArray(value)) {
+        return value.map((item, index) => {
+            if (index >= options.maxArrayLength) {
+                return `[Array truncated, total length: ${value.length}]`;
+            }
+            return sanitizeValue(item, options, currentDepth + 1);
+        });
+    }
+    // 对象处理
+    const sanitized = {};
+    let keyCount = 0;
+    for (const key of Object.keys(value)) {
+        // 限制对象属性数量
+        if (keyCount >= options.maxObjectKeys) {
+            sanitized['__truncated__'] = `Object truncated, total keys: ${Object.keys(value).length}`;
+            break;
+        }
+        keyCount++;
+        const lowerKey = key.toLowerCase();
+        // 敏感字段脱敏
+        if (SENSITIVE_KEYS.some((sk) => lowerKey.includes(sk))) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else {
+            sanitized[key] = sanitizeValue(value[key], options, currentDepth + 1);
+        }
+    }
+    return sanitized;
+}
+/**
+ * 清理字符串值，防止日志注入
+ *
+ * @param value - 需要清理的值
+ * @param maxLength - 最大长度限制
+ * @returns 清理后的字符串
+ */
+function sanitizeString(value, maxLength) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    // 移除控制字符和转义特殊字符，防止日志注入
+    return value
+        .replace(/[\x00-\x1F\x7F]/g, '') // 移除控制字符
+        .replace(/\n/g, '\\n') // 转义换行
+        .replace(/\r/g, '\\r') // 转义回车
+        .replace(/\t/g, '\\t') // 转义制表符
+        .substring(0, maxLength); // 限制字符串长度
+}

package/dist/tests/sanitize-traceinfo.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TraceInfo安全处理测试
+ * 运行方式: npx tsx src/tests/sanitize-traceinfo.test.ts
+ */
+export {};

package/dist/tests/sanitize-traceinfo.test.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * TraceInfo安全处理测试
+ * 运行方式: npx tsx src/tests/sanitize-traceinfo.test.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const sanitize_traceinfo_1 = require("../common/sanitize-traceinfo");
+console.log("=== TraceInfo安全处理测试 ===\n");
+// 测试1: 敏感字段脱敏
+console.log("测试1: 敏感字段脱敏");
+const test1 = {
+    username: 'testuser',
+    password: 'secret123',
+    accessToken: 'token123',
+    normalField: 'normal value'
+};
+const result1 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test1);
+console.log("输入:", test1);
+console.log("输出:", result1);
+console.log("✓ password已脱敏:", result1.password === '[REDACTED]');
+console.log("✓ accessToken已脱敏:", result1.accessToken === '[REDACTED]');
+console.log("✓ normalField保留:", result1.normalField === 'normal value');
+console.log("\n---\n");
+// 测试2: 日志注入防护
+console.log("测试2: 日志注入防护（控制字符清理）");
+const test2 = {
+    name: 'test\x00name',
+    description: 'line1\nline2\rline3\ttab'
+};
+const result2 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test2);
+console.log("输入:", test2);
+console.log("输出:", result2);
+console.log("✓ 控制字符已移除:", !result2.name.includes('\x00'));
+console.log("✓ 换行符已转义:", result2.description.includes('\\n'));
+console.log("\n---\n");
+// 测试3: 大小限制
+console.log("测试3: 大小限制（数组和对象）");
+const test3 = {
+    items: Array.from({ length: 200 }, (_, i) => i),
+    largeObject: {}
+};
+for (let i = 0; i < 100; i++) {
+    test3.largeObject[`key${i}`] = i;
+}
+const result3 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test3);
+console.log("数组长度限制:", result3.items.length, "(原始200, 限制100)");
+console.log("对象属性数量:", Object.keys(result3).length, "(包含截断标记)");
+console.log("✓ 数组已截断:", result3.items.length === 100);
+console.log("✓ 对象已截断:", result3.largeObject.__truncated__ !== undefined);
+console.log("\n---\n");
+// 测试4: 深度限制
+console.log("测试4: 深度限制");
+const createDeepObject = (depth) => {
+    if (depth === 0)
+        return 'value';
+    return { level: createDeepObject(depth - 1) };
+};
+const test4 = createDeepObject(10);
+const result4 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test4);
+console.log("✓ 深度限制已生效:", JSON.stringify(result4).includes('[MaxDepthReached]'));
+console.log("\n---\n");
+// 测试5: 字符串长度限制
+console.log("测试5: 字符串长度限制");
+const test5 = { long: 'a'.repeat(2000) };
+const result5 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test5);
+console.log("✓ 长字符串已截断:", result5.long.length === 1000);
+console.log("\n---\n");
+// 测试6: 实际TraceInfo场景
+console.log("测试6: 实际TraceInfo场景");
+const test6 = {
+    sessionId: 'session_123456',
+    userId: 'user_789',
+    entryPage: '/home',
+    currentPage: '/profile',
+    apiTrace: [
+        { action: 'GetUser', pageFrom: '/home', duration: 150, status: 'success' },
+        { action: 'UpdateProfile', pageFrom: '/profile', duration: 200, status: 'success' }
+    ],
+    deviceInfo: {
+        ua: 'Mozilla/5.0...',
+        platform: 'Mac'
+    }
+};
+const result6 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test6);
+console.log("输入:", JSON.stringify(test6, null, 2));
+console.log("输出:", JSON.stringify(result6, null, 2));
+console.log("✓ 正常TraceInfo保留完整");
+console.log("\n---\n");
+// 测试7: 自定义配置
+console.log("测试7: 自定义配置");
+const test7 = {
+    password: 'secret',
+    data: Array.from({ length: 10 }, (_, i) => i)
+};
+const result7 = (0, sanitize_traceinfo_1.sanitizeTraceInfo)(test7, {
+    maxDepth: 3,
+    maxArrayLength: 5,
+    maxObjectKeys: 2,
+    maxStringLength: 100
+});
+console.log("自定义配置结果:", result7);
+console.log("✓ 自定义配置生效");
+console.log("\n---\n");
+console.log("✅ 所有测试完成！");

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "kb-server",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "A fast server for Node.JS,made by express.",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf ./dist && tsc",
-    "release": "npm run build && npm version patch && npm publish"
+    "release": "npm run build && npm version patch && npm publish",
+    "release:beta": "npm run build && npm version prerelease --preid=beta && npm publish --tag beta"
   },
   "keywords": [
     "2kb",