befly 3.10.0 → 3.10.2

package/tests/fields-redis-cache.test.ts

@@ -1,127 +0,0 @@
-/**
- * 验证 Redis 缓存的字段查询功能
- */
-
-import { CacheKeys } from "../lib/cacheKeys.js";
-
-const TABLE_COLUMNS_CACHE_TTL_SECONDS = 3600;
-
-console.log("\n========== Redis 缓存验证 ==========\n");
-
-// 模拟 Redis 缓存逻辑
-class MockRedis {
-    private cache: Map<string, { value: any; expire: number }> = new Map();
-
-    async getObject<T>(key: string): Promise<T | null> {
-        const cached = this.cache.get(key);
-        if (cached && cached.expire > Date.now()) {
-            console.log(`✅ Redis 缓存命中: ${key}`);
-            return cached.value as T;
-        }
-        console.log(`❌ Redis 缓存未命中: ${key}`);
-        return null;
-    }
-
-    async setObject(key: string, value: any, ttl: number): Promise<void> {
-        this.cache.set(key, {
-            value: value,
-            expire: Date.now() + ttl * 1000
-        });
-        console.log(`📝 写入 Redis 缓存: ${key} (TTL: ${ttl}s)`);
-    }
-}
-
-// 模拟数据库查询
-async function queryDatabase(table: string): Promise<string[]> {
-    console.log(`🔍 查询数据库表结构: ${table}`);
-    // 模拟数据库延迟
-    await new Promise((resolve) => setTimeout(resolve, 3));
-    return ["id", "name", "email", "password", "salt", "created_at"];
-}
-
-// 模拟 getTableColumns 方法
-async function getTableColumns(redis: MockRedis, table: string): Promise<string[]> {
-    // 1. 先查 Redis 缓存
-    const cacheKey = CacheKeys.tableColumns(table);
-    let columns = await redis.getObject<string[]>(cacheKey);
-
-    if (columns && columns.length > 0) {
-        return columns;
-    }
-
-    // 2. 缓存未命中，查询数据库
-    columns = await queryDatabase(table);
-
-    // 3. 写入 Redis 缓存
-    await redis.setObject(cacheKey, columns, TABLE_COLUMNS_CACHE_TTL_SECONDS);
-
-    return columns;
-}
-
-async function test() {
-    const redis = new MockRedis();
-
-    console.log("【场景1】单进程多次查询\n");
-
-    // 第1次查询（缓存未命中）
-    console.log("--- 第1次查询 user 表 ---");
-    const start1 = Date.now();
-    const columns1 = await getTableColumns(redis, "user");
-    const time1 = Date.now() - start1;
-    console.log(`结果: ${columns1.join(", ")}`);
-    console.log(`耗时: ${time1}ms\n`);
-
-    // 第2次查询（缓存命中）
-    console.log("--- 第2次查询 user 表 ---");
-    const start2 = Date.now();
-    const columns2 = await getTableColumns(redis, "user");
-    const time2 = Date.now() - start2;
-    console.log(`结果: ${columns2.join(", ")}`);
-    console.log(`耗时: ${time2}ms\n`);
-
-    // 第3次查询（缓存命中）
-    console.log("--- 第3次查询 user 表 ---");
-    const start3 = Date.now();
-    const columns3 = await getTableColumns(redis, "user");
-    const time3 = Date.now() - start3;
-    console.log(`结果: ${columns3.join(", ")}`);
-    console.log(`耗时: ${time3}ms\n`);
-
-    console.log("【场景2】模拟 PM2 cluster（多进程共享 Redis）\n");
-
-    // 模拟 Worker 1 查询
-    console.log("--- Worker 1 查询 article 表 ---");
-    const worker1Start = Date.now();
-    const worker1Columns = await getTableColumns(redis, "article");
-    const worker1Time = Date.now() - worker1Start;
-    console.log(`结果: ${worker1Columns.join(", ")}`);
-    console.log(`耗时: ${worker1Time}ms\n`);
-
-    // 模拟 Worker 2 查询（共享 Redis 缓存）
-    console.log("--- Worker 2 查询 article 表 ---");
-    const worker2Start = Date.now();
-    const worker2Columns = await getTableColumns(redis, "article");
-    const worker2Time = Date.now() - worker2Start;
-    console.log(`结果: ${worker2Columns.join(", ")}`);
-    console.log(`耗时: ${worker2Time}ms`);
-    console.log(`✅ Worker 2 直接使用 Worker 1 的缓存，无需再查数据库\n`);
-
-    // 模拟 Worker 3 查询（共享 Redis 缓存）
-    console.log("--- Worker 3 查询 article 表 ---");
-    const worker3Start = Date.now();
-    const worker3Columns = await getTableColumns(redis, "article");
-    const worker3Time = Date.now() - worker3Start;
-    console.log(`结果: ${worker3Columns.join(", ")}`);
-    console.log(`耗时: ${worker3Time}ms`);
-    console.log(`✅ Worker 3 直接使用 Worker 1 的缓存，无需再查数据库\n`);
-
-    console.log("========== 验证完成 ==========\n");
-
-    console.log("📊 性能总结:");
-    console.log(`- 首次查询（数据库）: ${time1}ms`);
-    console.log(`- 后续查询（Redis）: ${time2}ms`);
-    console.log(`- 性能提升: ${(time1 / time2).toFixed(1)}x`);
-    console.log(`- PM2 cluster: ✅ 所有 worker 共享同一份 Redis 缓存`);
-}
-
-test();

package/tests/fields-validate.test.ts

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

package/tests/fixtures/scanFilesAddon/node_modules/@befly-addon/demo/apis/sub/b.ts

@@ -1,3 +0,0 @@
-export default {
-    name: "B"
-};

package/tests/fixtures/scanFilesApis/a.ts

@@ -1,3 +0,0 @@
-export default {
-    name: "A"
-};

package/tests/fixtures/scanFilesApis/sub/b.ts

@@ -1,3 +0,0 @@
-export default {
-    name: "B"
-};

package/tests/getClientIp.test.ts

@@ -1,54 +0,0 @@
-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,189 +0,0 @@
-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);
-        expect(hashedPassword).toBeDefined();
-        expect(hashedPassword.length).toBeGreaterThan(0);
-
-        // 2. 密码验证
-        const isValid = await Cipher.verifyPassword(password, hashedPassword);
-        expect(isValid).toBe(true);
-
-        // 3. 错误密码验证
-        const isInvalid = await Cipher.verifyPassword("WrongPassword", hashedPassword);
-        expect(isInvalid).toBe(false);
-    });
-});
-
-describe("Integration - JWT + 权限验证", () => {
-    const jwt = new Jwt({
-        secret: "test-integration-secret",
-        algorithm: "HS256",
-        expiresIn: "1h"
-    });
-
-    test("用户登录：JWT 签名 + 验证", () => {
-        // 1. 用户登录生成 token
-        const payload = {
-            userId: 123,
-            username: "john",
-            roles: ["admin", "user"],
-            permissions: ["read", "write", "delete"]
-        };
-
-        const token = jwt.sign(payload);
-        expect(token).toBeDefined();
-        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");
-    });
-});
-
-describe("Integration - 数据验证 + SQL 构建", () => {
-    test("API 请求：验证数据 + 构建查询", () => {
-        // 1. 验证用户输入
-        const userData = {
-            email: "test@example.com",
-            age: 25,
-            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 }
-        };
-
-        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();
-
-        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 构建", () => {
-        // 1. 验证数据
-        const newUser = {
-            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 }
-        };
-
-        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_age).toBe(30);
-
-        // 3. 构建插入 SQL
-        const builder = new SqlBuilder();
-        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");
-    });
-});
-
-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 parsed = xmlParser.parse(xmlData).response as any;
-
-        expect(parsed.user_id).toBe(123);
-        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.isActive).toBe(true);
-    });
-});
-
-describe("Integration - 加密 + JWT + 哈希", () => {
-    test("安全令牌生成：多层加密", () => {
-        // 1. 生成随机字符串作为 secret
-        const secret = Cipher.randomString(32);
-        expect(secret.length).toBe(32);
-
-        // 2. 对 secret 进行 SHA256 哈希
-        const hashedSecret = Cipher.sha256(secret);
-        expect(hashedSecret.length).toBe(64);
-
-        // 3. 使用 HMAC 签名
-        const data = "user123:session456";
-        const signature = Cipher.hmacSha256(data, hashedSecret);
-        expect(signature).toBeDefined();
-
-        // 4. Base64 编码
-        const encoded = Cipher.base64Encode(signature);
-        expect(encoded).toBeDefined();
-
-        // 5. Base64 解码验证
-        const decoded = Cipher.base64Decode(encoded);
-        expect(decoded).toBe(signature);
-    });
-});
-
-describe("Integration - SQL 构建 + 字段转换", () => {
-    test("复杂查询：驼峰转下划线 + WHERE 条件 + 排序分页", () => {
-        const builder = new SqlBuilder();
-
-        // 1. 原始查询条件（驼峰格式）
-        const queryConditions = {
-            userId: 123,
-            userStatus: "active",
-            createdAt: { $gte: 1609459200000 }
-        };
-
-        // 2. 转换为下划线格式
-        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();
-
-        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,65 +0,0 @@
-import { describe, test, expect } from "bun:test";
-
-import { Jwt } from "../lib/jwt";
-
-const jwt = new Jwt({
-    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);
-    });
-
-    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" });
-        const decoded = jwt.verify(token);
-        expect(decoded.userId).toBe(123);
-        expect(decoded.email).toBe("test@test.com");
-    });
-
-    test("验证过期 token 抛出错误", () => {
-        const token = jwt.sign({ userId: 1 }, { expiresIn: "-1s" });
-        expect(() => jwt.verify(token)).toThrow();
-    });
-
-    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();
-    });
-});
-
-describe("JWT - decode", () => {
-    test("解码不验证签名", () => {
-        const token = jwt.sign({ userId: 456 });
-        const decoded = jwt.decode(token);
-        expect(decoded.userId).toBe(456);
-    });
-
-    test("解码完整信息", () => {
-        const token = jwt.sign({ userId: 1 });
-        const decoded = jwt.decode(token, true);
-        expect(decoded.header).toBeDefined();
-        expect(decoded.payload).toBeDefined();
-        expect(decoded.signature).toBeDefined();
-    });
-});

package/tests/loadPlugins-order-smoke.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { loadPlugins } from "../loader/loadPlugins.js";
-
-describe("loadPlugins - order smoke", () => {
-    test("deps 应确保 redis 在 db/cache 之前初始化", async () => {
-        const executed: string[] = [];
-        const ctx: any = {};
-
-        const plugins: any[] = [
-            {
-                moduleName: "db",
-                deps: ["logger", "redis"],
-                handler: async (befly: any) => {
-                    executed.push("db");
-
-                    if (!befly.redis) {
-                        throw new Error("db handler called before redis");
-                    }
-
-                    return { ok: true };
-                }
-            },
-            {
-                moduleName: "cache",
-                deps: ["logger", "redis", "db"],
-                handler: async (befly: any) => {
-                    executed.push("cache");
-
-                    if (!befly.redis) {
-                        throw new Error("cache handler called before redis");
-                    }
-
-                    if (!befly.db) {
-                        throw new Error("cache handler called before db");
-                    }
-
-                    return { ok: true };
-                }
-            },
-            {
-                moduleName: "redis",
-                deps: ["logger"],
-                handler: async (_befly: any) => {
-                    executed.push("redis");
-                    return { ok: true };
-                }
-            },
-            {
-                moduleName: "logger",
-                deps: [],
-                handler: async (_befly: any) => {
-                    executed.push("logger");
-                    return { ok: true };
-                }
-            }
-        ];
-
-        await loadPlugins(plugins as any, ctx as any, []);
-
-        const loggerIndex = executed.indexOf("logger");
-        const redisIndex = executed.indexOf("redis");
-        const dbIndex = executed.indexOf("db");
-        const cacheIndex = executed.indexOf("cache");
-
-        expect(loggerIndex).toBeGreaterThanOrEqual(0);
-        expect(redisIndex).toBeGreaterThanOrEqual(0);
-        expect(dbIndex).toBeGreaterThanOrEqual(0);
-        expect(cacheIndex).toBeGreaterThanOrEqual(0);
-
-        expect(loggerIndex).toBeLessThan(redisIndex);
-        expect(redisIndex).toBeLessThan(dbIndex);
-        expect(dbIndex).toBeLessThan(cacheIndex);
-    });
-});