befly 3.9.38 → 3.9.40

package/tests/fields-validate.test.ts

@@ -5,95 +5,95 @@
 
 // 模拟测试函数（从 dbHelper 复制的逻辑）
 function validateAndClassifyFields(fields?: string[]): {
-    type: 'all' | 'include' | 'exclude';
+    type: "all" | "include" | "exclude";
     fields: string[];
 } {
     // 情况1：空数组或 undefined，表示查询所有
     if (!fields || fields.length === 0) {
-        return { type: 'all', fields: [] };
+        return { type: "all", fields: [] };
     }
 
     // 检测是否有星号（禁止）
-    if (fields.some((f) => f === '*')) {
-        throw new Error('fields 不支持 * 星号，请使用空数组 [] 或不传参数表示查询所有字段');
+    if (fields.some((f) => f === "*")) {
+        throw new Error("fields 不支持 * 星号，请使用空数组 [] 或不传参数表示查询所有字段");
     }
 
     // 检测是否有空字符串或无效值
-    if (fields.some((f) => !f || typeof f !== 'string' || f.trim() === '')) {
-        throw new Error('fields 不能包含空字符串或无效值');
+    if (fields.some((f) => !f || typeof f !== "string" || f.trim() === "")) {
+        throw new Error("fields 不能包含空字符串或无效值");
     }
 
     // 统计包含字段和排除字段
-    const includeFields = fields.filter((f) => !f.startsWith('!'));
-    const excludeFields = fields.filter((f) => f.startsWith('!'));
+    const includeFields = fields.filter((f) => !f.startsWith("!"));
+    const excludeFields = fields.filter((f) => f.startsWith("!"));
 
     // 情况2：全部是包含字段
     if (includeFields.length > 0 && excludeFields.length === 0) {
-        return { type: 'include', fields: includeFields };
+        return { type: "include", fields: includeFields };
     }
 
     // 情况3：全部是排除字段
     if (excludeFields.length > 0 && includeFields.length === 0) {
         // 去掉感叹号前缀
         const cleanExcludeFields = excludeFields.map((f) => f.substring(1));
-        return { type: 'exclude', fields: cleanExcludeFields };
+        return { type: "exclude", fields: cleanExcludeFields };
     }
 
     // 混用情况：报错
     throw new Error('fields 不能同时包含普通字段和排除字段（! 开头）。只能使用以下3种方式之一：\n1. 空数组 [] 或不传（查询所有）\n2. 全部指定字段 ["id", "name"]\n3. 全部排除字段 ["!password", "!token"]');
 }
 
-console.log('\n========== 测试 validateAndClassifyFields ==========\n');
+console.log("\n========== 测试 validateAndClassifyFields ==========\n");
 
 // 测试1：空数组
-console.log('【测试1】空数组');
+console.log("【测试1】空数组");
 const test1 = validateAndClassifyFields([]);
-console.log('结果:', test1);
-console.log('✅ 通过\n');
+console.log("结果:", test1);
+console.log("✅ 通过\n");
 
 // 测试2：undefined
-console.log('【测试2】undefined');
+console.log("【测试2】undefined");
 const test2 = validateAndClassifyFields(undefined);
-console.log('结果:', test2);
-console.log('✅ 通过\n');
+console.log("结果:", test2);
+console.log("✅ 通过\n");
 
 // 测试3：包含字段
-console.log('【测试3】包含字段');
-const test3 = validateAndClassifyFields(['id', 'name', 'email']);
-console.log('结果:', test3);
-console.log('✅ 通过\n');
+console.log("【测试3】包含字段");
+const test3 = validateAndClassifyFields(["id", "name", "email"]);
+console.log("结果:", test3);
+console.log("✅ 通过\n");
 
 // 测试4：排除字段
-console.log('【测试4】排除字段');
-const test4 = validateAndClassifyFields(['!password', '!salt']);
-console.log('结果:', test4);
-console.log('✅ 通过\n');
+console.log("【测试4】排除字段");
+const test4 = validateAndClassifyFields(["!password", "!salt"]);
+console.log("结果:", test4);
+console.log("✅ 通过\n");
 
 // 测试5：混用（应该报错）
-console.log('【测试5】混用（应该报错）');
+console.log("【测试5】混用（应该报错）");
 try {
-    validateAndClassifyFields(['id', '!password']);
-    console.log('❌ 没有抛出错误\n');
+    validateAndClassifyFields(["id", "!password"]);
+    console.log("❌ 没有抛出错误\n");
 } catch (error: any) {
-    console.log('✅ 成功捕获错误:', error.message, '\n');
+    console.log("✅ 成功捕获错误:", error.message, "\n");
 }
 
 // 测试6：星号（应该报错）
-console.log('【测试6】星号（应该报错）');
+console.log("【测试6】星号（应该报错）");
 try {
-    validateAndClassifyFields(['*']);
-    console.log('❌ 没有抛出错误\n');
+    validateAndClassifyFields(["*"]);
+    console.log("❌ 没有抛出错误\n");
 } catch (error: any) {
-    console.log('✅ 成功捕获错误:', error.message, '\n');
+    console.log("✅ 成功捕获错误:", error.message, "\n");
 }
 
 // 测试7：空字符串（应该报错）
-console.log('【测试7】空字符串（应该报错）');
+console.log("【测试7】空字符串（应该报错）");
 try {
-    validateAndClassifyFields(['id', '', 'name']);
-    console.log('❌ 没有抛出错误\n');
+    validateAndClassifyFields(["id", "", "name"]);
+    console.log("❌ 没有抛出错误\n");
 } catch (error: any) {
-    console.log('✅ 成功捕获错误:', error.message, '\n');
+    console.log("✅ 成功捕获错误:", error.message, "\n");
 }
 
-console.log('========== 所有测试完成 ==========\n');
+console.log("========== 所有测试完成 ==========\n");

package/tests/getClientIp.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+
+import { getClientIp } from "../utils/getClientIp";
+
+describe("utils - getClientIp", () => {
+    test("优先使用 x-forwarded-for 的第一个值", () => {
+        const req = new Request("http://localhost/api/test", {
+            method: "GET",
+            headers: {
+                "x-forwarded-for": " 8.8.8.8, 1.1.1.1 "
+            }
+        });
+
+        const ip = getClientIp(req);
+        expect(ip).toBe("8.8.8.8");
+    });
+
+    test("x-forwarded-for 为空时回退到 x-real-ip", () => {
+        const req = new Request("http://localhost/api/test", {
+            method: "GET",
+            headers: {
+                "x-forwarded-for": "   ",
+                "x-real-ip": "9.9.9.9"
+            }
+        });
+
+        const ip = getClientIp(req);
+        expect(ip).toBe("9.9.9.9");
+    });
+
+    test("无代理头时使用 server.requestIP(req) 兜底", () => {
+        const req = new Request("http://localhost/api/test", {
+            method: "GET"
+        });
+
+        const server = {
+            requestIP(_req: Request) {
+                return { address: "7.7.7.7" };
+            }
+        };
+
+        const ip = getClientIp(req, server);
+        expect(ip).toBe("7.7.7.7");
+    });
+
+    test("全都没有时返回 unknown", () => {
+        const req = new Request("http://localhost/api/test", {
+            method: "GET"
+        });
+
+        const ip = getClientIp(req);
+        expect(ip).toBe("unknown");
+    });
+});

package/tests/integration.test.ts

@@ -1,15 +1,17 @@
-import { describe, test, expect } from 'bun:test';
-import { XMLParser } from 'fast-xml-parser';
-import { Cipher } from '../lib/cipher';
-import { Jwt } from '../lib/jwt';
-import { Validator } from '../lib/validator';
-import { SqlBuilder } from '../lib/sqlBuilder';
-import { keysToCamel } from 'befly-shared/keysToCamel';
-import { keysToSnake } from 'befly-shared/keysToSnake';
-
-describe('Integration - 密码验证流程', () => {
-    test('用户注册：密码加密 + 验证', async () => {
-        const password = 'MySecurePass123';
+import { describe, test, expect } from "bun:test";
+
+import { XMLParser } from "fast-xml-parser";
+
+import { Cipher } from "../lib/cipher";
+import { Jwt } from "../lib/jwt";
+import { SqlBuilder } from "../lib/sqlBuilder";
+import { Validator } from "../lib/validator";
+import { keysToCamel } from "../utils/keysToCamel";
+import { keysToSnake } from "../utils/keysToSnake";
+
+describe("Integration - 密码验证流程", () => {
+    test("用户注册：密码加密 + 验证", async () => {
+        const password = "MySecurePass123";
 
         // 1. 密码加密
         const hashedPassword = await Cipher.hashPassword(password);
@@ -21,123 +23,123 @@ describe('Integration - 密码验证流程', () => {
         expect(isValid).toBe(true);
 
         // 3. 错误密码验证
-        const isInvalid = await Cipher.verifyPassword('WrongPassword', hashedPassword);
+        const isInvalid = await Cipher.verifyPassword("WrongPassword", hashedPassword);
         expect(isInvalid).toBe(false);
     });
 });
 
-describe('Integration - JWT + 权限验证', () => {
+describe("Integration - JWT + 权限验证", () => {
     const jwt = new Jwt({
-        secret: 'test-integration-secret',
-        algorithm: 'HS256',
-        expiresIn: '1h'
+        secret: "test-integration-secret",
+        algorithm: "HS256",
+        expiresIn: "1h"
     });
 
-    test('用户登录：JWT 签名 + 验证', () => {
+    test("用户登录：JWT 签名 + 验证", () => {
         // 1. 用户登录生成 token
         const payload = {
             userId: 123,
-            username: 'john',
-            roles: ['admin', 'user'],
-            permissions: ['read', 'write', 'delete']
+            username: "john",
+            roles: ["admin", "user"],
+            permissions: ["read", "write", "delete"]
         };
 
         const token = jwt.sign(payload);
         expect(token).toBeDefined();
-        expect(typeof token).toBe('string');
+        expect(typeof token).toBe("string");
 
         // 2. 验证 token
         const verified = jwt.verify(token);
         expect(verified.userId).toBe(123);
-        expect(verified.username).toBe('john');
-        expect(verified.roles).toContain('admin');
-        expect(verified.permissions).toContain('write');
+        expect(verified.username).toBe("john");
+        expect(verified.roles).toContain("admin");
+        expect(verified.permissions).toContain("write");
     });
 });
 
-describe('Integration - 数据验证 + SQL 构建', () => {
-    test('API 请求：验证数据 + 构建查询', () => {
+describe("Integration - 数据验证 + SQL 构建", () => {
+    test("API 请求：验证数据 + 构建查询", () => {
         // 1. 验证用户输入
         const userData = {
-            email: 'test@example.com',
+            email: "test@example.com",
             age: 25,
-            username: 'john'
+            username: "john"
         };
 
         const rules = {
-            email: { name: '邮箱', type: 'string', regexp: '@email' },
-            age: { name: '年龄', type: 'number', min: 0, max: 150 },
-            username: { name: '用户名', type: 'string', min: 2, max: 20 }
+            email: { name: "邮箱", type: "string", regexp: "@email" },
+            age: { name: "年龄", type: "number", min: 0, max: 150 },
+            username: { name: "用户名", type: "string", min: 2, max: 20 }
         };
 
-        const validationResult = Validator.validate(userData, rules, ['email', 'username']);
+        const validationResult = Validator.validate(userData, rules, ["email", "username"]);
         expect(validationResult.code).toBe(0);
 
         // 2. 验证通过后构建 SQL 查询
         const builder = new SqlBuilder();
-        const sqlResult = builder.select(['id', 'username', 'email']).from('users').where({ email: userData.email }).toSelectSql();
+        const sqlResult = builder.select(["id", "username", "email"]).from("users").where({ email: userData.email }).toSelectSql();
 
-        expect(sqlResult.sql).toContain('SELECT');
-        expect(sqlResult.sql).toContain('FROM `users`');
-        expect(sqlResult.sql).toContain('WHERE `email` = ?');
-        expect(sqlResult.params).toContain('test@example.com');
+        expect(sqlResult.sql).toContain("SELECT");
+        expect(sqlResult.sql).toContain("FROM `users`");
+        expect(sqlResult.sql).toContain("WHERE `email` = ?");
+        expect(sqlResult.params).toContain("test@example.com");
     });
 
-    test('数据插入：验证 + 字段转换 + SQL 构建', () => {
+    test("数据插入：验证 + 字段转换 + SQL 构建", () => {
         // 1. 验证数据
         const newUser = {
-            userName: 'jane',
-            userEmail: 'jane@example.com',
+            userName: "jane",
+            userEmail: "jane@example.com",
             userAge: 30
         };
 
         const rules = {
-            userName: { name: '用户名', type: 'string', min: 2, max: 20 },
-            userEmail: { name: '邮箱', type: 'string', regexp: '@email' },
-            userAge: { name: '年龄', type: 'number', min: 0, max: 150 }
+            userName: { name: "用户名", type: "string", min: 2, max: 20 },
+            userEmail: { name: "邮箱", type: "string", regexp: "@email" },
+            userAge: { name: "年龄", type: "number", min: 0, max: 150 }
         };
 
-        const validationResult = Validator.validate(newUser, rules, ['userName', 'userEmail']);
+        const validationResult = Validator.validate(newUser, rules, ["userName", "userEmail"]);
         expect(validationResult.code).toBe(0);
 
         // 2. 字段转换（驼峰转下划线）
         const dbData = keysToSnake(newUser);
-        expect(dbData.user_name).toBe('jane');
-        expect(dbData.user_email).toBe('jane@example.com');
+        expect(dbData.user_name).toBe("jane");
+        expect(dbData.user_email).toBe("jane@example.com");
         expect(dbData.user_age).toBe(30);
 
         // 3. 构建插入 SQL
         const builder = new SqlBuilder();
-        const sqlResult = builder.toInsertSql('users', dbData);
+        const sqlResult = builder.toInsertSql("users", dbData);
 
-        expect(sqlResult.sql).toContain('INSERT INTO `users`');
-        expect(sqlResult.params).toContain('jane');
-        expect(sqlResult.params).toContain('jane@example.com');
+        expect(sqlResult.sql).toContain("INSERT INTO `users`");
+        expect(sqlResult.params).toContain("jane");
+        expect(sqlResult.params).toContain("jane@example.com");
     });
 });
 
-describe('Integration - XML 解析 + 数据转换', () => {
-    test('XML API 响应：解析 + 字段转换', () => {
+describe("Integration - XML 解析 + 数据转换", () => {
+    test("XML API 响应：解析 + 字段转换", () => {
         const xmlParser = new XMLParser();
 
         // 1. 解析 XML 响应
-        const xmlData = '<response><user_id>123</user_id><user_name>John</user_name><is_active>true</is_active></response>';
+        const xmlData = "<response><user_id>123</user_id><user_name>John</user_name><is_active>true</is_active></response>";
         const parsed = xmlParser.parse(xmlData).response as any;
 
         expect(parsed.user_id).toBe(123);
-        expect(parsed.user_name).toBe('John');
+        expect(parsed.user_name).toBe("John");
         expect(parsed.is_active).toBe(true);
 
         // 2. 字段转换（下划线转驼峰）
         const camelData = keysToCamel(parsed);
         expect(camelData.userId).toBe(123);
-        expect(camelData.userName).toBe('John');
+        expect(camelData.userName).toBe("John");
         expect(camelData.isActive).toBe(true);
     });
 });
 
-describe('Integration - 加密 + JWT + 哈希', () => {
-    test('安全令牌生成：多层加密', () => {
+describe("Integration - 加密 + JWT + 哈希", () => {
+    test("安全令牌生成：多层加密", () => {
         // 1. 生成随机字符串作为 secret
         const secret = Cipher.randomString(32);
         expect(secret.length).toBe(32);
@@ -147,7 +149,7 @@ describe('Integration - 加密 + JWT + 哈希', () => {
         expect(hashedSecret.length).toBe(64);
 
         // 3. 使用 HMAC 签名
-        const data = 'user123:session456';
+        const data = "user123:session456";
         const signature = Cipher.hmacSha256(data, hashedSecret);
         expect(signature).toBeDefined();
 
@@ -161,14 +163,14 @@ describe('Integration - 加密 + JWT + 哈希', () => {
     });
 });
 
-describe('Integration - SQL 构建 + 字段转换', () => {
-    test('复杂查询：驼峰转下划线 + WHERE 条件 + 排序分页', () => {
+describe("Integration - SQL 构建 + 字段转换", () => {
+    test("复杂查询：驼峰转下划线 + WHERE 条件 + 排序分页", () => {
         const builder = new SqlBuilder();
 
         // 1. 原始查询条件（驼峰格式）
         const queryConditions = {
             userId: 123,
-            userStatus: 'active',
+            userStatus: "active",
             createdAt: { $gte: 1609459200000 }
         };
 
@@ -176,12 +178,12 @@ describe('Integration - SQL 构建 + 字段转换', () => {
         const dbConditions = keysToSnake(queryConditions);
 
         // 3. 构建复杂查询
-        const sqlResult = builder.select(['id', 'user_name', 'user_email', 'created_at']).from('users').where(dbConditions).orderBy(['created_at#DESC']).limit(20).offset(0).toSelectSql();
+        const sqlResult = builder.select(["id", "user_name", "user_email", "created_at"]).from("users").where(dbConditions).orderBy(["created_at#DESC"]).limit(20).offset(0).toSelectSql();
 
-        expect(sqlResult.sql).toContain('SELECT');
-        expect(sqlResult.sql).toContain('WHERE');
-        expect(sqlResult.sql).toContain('ORDER BY');
-        expect(sqlResult.sql).toContain('LIMIT 20');
+        expect(sqlResult.sql).toContain("SELECT");
+        expect(sqlResult.sql).toContain("WHERE");
+        expect(sqlResult.sql).toContain("ORDER BY");
+        expect(sqlResult.sql).toContain("LIMIT 20");
         expect(sqlResult.params.length).toBeGreaterThan(0);
     });
 });

package/tests/jwt.test.ts

@@ -1,60 +1,61 @@
-import { describe, test, expect } from 'bun:test';
-import { Jwt } from '../lib/jwt';
+import { describe, test, expect } from "bun:test";
+
+import { Jwt } from "../lib/jwt";
 
 const jwt = new Jwt({
-    secret: 'test-secret',
-    algorithm: 'HS256',
-    expiresIn: '7d'
+    secret: "test-secret",
+    algorithm: "HS256",
+    expiresIn: "7d"
 });
 
-describe('JWT - sign', () => {
-    test('签名创建 token', () => {
-        const token = jwt.sign({ userId: 1, name: 'test' });
-        expect(typeof token).toBe('string');
-        expect(token.split('.').length).toBe(3);
+describe("JWT - sign", () => {
+    test("签名创建 token", () => {
+        const token = jwt.sign({ userId: 1, name: "test" });
+        expect(typeof token).toBe("string");
+        expect(token.split(".").length).toBe(3);
     });
 
-    test('自定义密钥', () => {
-        const secret = 'custom-secret';
+    test("自定义密钥", () => {
+        const secret = "custom-secret";
         const token = jwt.sign({ userId: 1 }, { secret: secret });
         const decoded = jwt.verify(token, { secret: secret });
         expect(decoded.userId).toBe(1);
     });
 });
 
-describe('JWT - verify', () => {
-    test('验证有效 token', () => {
-        const token = jwt.sign({ userId: 123, email: 'test@test.com' });
+describe("JWT - verify", () => {
+    test("验证有效 token", () => {
+        const token = jwt.sign({ userId: 123, email: "test@test.com" });
         const decoded = jwt.verify(token);
         expect(decoded.userId).toBe(123);
-        expect(decoded.email).toBe('test@test.com');
+        expect(decoded.email).toBe("test@test.com");
     });
 
-    test('验证过期 token 抛出错误', () => {
-        const token = jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+    test("验证过期 token 抛出错误", () => {
+        const token = jwt.sign({ userId: 1 }, { expiresIn: "-1s" });
         expect(() => jwt.verify(token)).toThrow();
     });
 
-    test('忽略过期验证', () => {
-        const token = jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+    test("忽略过期验证", () => {
+        const token = jwt.sign({ userId: 1 }, { expiresIn: "-1s" });
         const decoded = jwt.verify(token, { ignoreExpiration: true });
         expect(decoded.userId).toBe(1);
     });
 
-    test('密钥不匹配验证失败', () => {
-        const token = jwt.sign({ userId: 1 }, { secret: 'secret1' });
-        expect(() => jwt.verify(token, { secret: 'secret2' })).toThrow();
+    test("密钥不匹配验证失败", () => {
+        const token = jwt.sign({ userId: 1 }, { secret: "secret1" });
+        expect(() => jwt.verify(token, { secret: "secret2" })).toThrow();
     });
 });
 
-describe('JWT - decode', () => {
-    test('解码不验证签名', () => {
+describe("JWT - decode", () => {
+    test("解码不验证签名", () => {
         const token = jwt.sign({ userId: 456 });
         const decoded = jwt.decode(token);
         expect(decoded.userId).toBe(456);
     });
 
-    test('解码完整信息', () => {
+    test("解码完整信息", () => {
         const token = jwt.sign({ userId: 1 });
         const decoded = jwt.decode(token, true);
         expect(decoded.header).toBeDefined();