befly 3.9.40 → 3.10.1

package/tests/checkMenu.test.ts

@@ -0,0 +1,346 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { checkMenu } from "../checks/checkMenu.js";
+
+describe("checkMenu", () => {
+    test("重复 path 应阻断菜单同步", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-dup-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(
+                menusJsonPath,
+                JSON.stringify(
+                    [
+                        { name: "A", path: "/a", sort: 1 },
+                        { name: "B", path: "/a", sort: 2 }
+                    ],
+                    null,
+                    4
+                ),
+                { encoding: "utf8" }
+            );
+
+            let thrown: any = null;
+            try {
+                await checkMenu([]);
+            } catch (error: any) {
+                thrown = error;
+            }
+
+            expect(thrown).toBeTruthy();
+            expect(thrown.message).toBe("菜单结构检查失败");
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("缺失父级 path 应阻断菜单同步", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-parent-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(menusJsonPath, JSON.stringify([{ name: "B", path: "/a/b", sort: 1 }], null, 4), { encoding: "utf8" });
+
+            // 菜单层级应以配置树（children）为准，而非按 URL path 分段强制推导父级。
+            // 因此单个菜单（即使 path 含多段）也允许作为根级菜单存在。
+            const menus = await checkMenu([]);
+            expect(Array.isArray(menus)).toBe(true);
+            expect(menus).toHaveLength(1);
+            expect(menus[0]?.path).toBe("/a/b");
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("disableMenus（精确）应过滤指定菜单", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-disableMenus-exact-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(
+                menusJsonPath,
+                JSON.stringify(
+                    [
+                        {
+                            name: "A",
+                            path: "/a",
+                            sort: 1,
+                            children: [
+                                {
+                                    name: "B",
+                                    path: "/a/b",
+                                    sort: 2
+                                }
+                            ]
+                        },
+                        {
+                            name: "C",
+                            path: "/c",
+                            sort: 3
+                        }
+                    ],
+                    null,
+                    4
+                ),
+                { encoding: "utf8" }
+            );
+
+            const menus = await checkMenu([], { disableMenus: ["/a/b"] });
+            expect(menus).toHaveLength(2);
+            expect(menus[0]?.path).toBe("/a");
+            expect(menus[1]?.path).toBe("/c");
+            expect(Array.isArray((menus[0] as any)?.children)).toBe(false);
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("disableMenus（glob）应按 Bun.Glob 语义过滤匹配的菜单", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-disableMenus-glob-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(
+                menusJsonPath,
+                JSON.stringify(
+                    [
+                        { name: "A", path: "/a", sort: 1 },
+                        { name: "A-1", path: "/a/1", sort: 2 },
+                        { name: "B", path: "/b", sort: 3 }
+                    ],
+                    null,
+                    4
+                ),
+                { encoding: "utf8" }
+            );
+
+            // 注意：此处完全遵循 Bun.Glob 的 match 语义。
+            // 通常 "*" 不跨路径分隔符，因此 "/a/*" 仅匹配 "/a/1"，不会匹配 "/a"。
+            const menus = await checkMenu([], { disableMenus: ["/a/*"] });
+            const paths = menus.map((m) => m.path);
+            expect(paths).toContain("/a");
+            expect(paths).toContain("/b");
+            expect(paths).not.toContain("/a/1");
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("disableMenus 规则不合法应阻断启动", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-disableMenus-invalid-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(menusJsonPath, JSON.stringify([{ name: "A", path: "/a", sort: 1 }], null, 4), { encoding: "utf8" });
+
+            // 1) disableMenus 必须是数组
+            {
+                let thrown: any = null;
+                try {
+                    await checkMenu([], { disableMenus: "not-array" as any });
+                } catch (error: any) {
+                    thrown = error;
+                }
+                expect(thrown).toBeTruthy();
+                expect(String(thrown.message).includes("disableMenus")).toBe(true);
+            }
+
+            // 2) 数组元素必须是 string
+            {
+                let thrown: any = null;
+                try {
+                    await checkMenu([], { disableMenus: [123 as any] });
+                } catch (error: any) {
+                    thrown = error;
+                }
+                expect(thrown).toBeTruthy();
+                expect(String(thrown.message).includes("disableMenus")).toBe(true);
+            }
+
+            // 3) 不允许空字符串
+            {
+                let thrown: any = null;
+                try {
+                    await checkMenu([], { disableMenus: ["  "] });
+                } catch (error: any) {
+                    thrown = error;
+                }
+                expect(thrown).toBeTruthy();
+                expect(String(thrown.message).includes("disableMenus")).toBe(true);
+            }
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("默认应屏蔽 /404 /403 /500 以及所有以 /login 结尾的菜单路由", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-default-disable-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(
+                menusJsonPath,
+                JSON.stringify(
+                    [
+                        { name: "Login", path: "/login", sort: 1 },
+                        { name: "AddonLogin", path: "/addon/admin/login", sort: 2 },
+                        { name: "404", path: "/404", sort: 3 },
+                        { name: "403", path: "/403", sort: 4 },
+                        { name: "500", path: "/500", sort: 5 },
+                        { name: "A", path: "/a", sort: 6 }
+                    ],
+                    null,
+                    4
+                ),
+                { encoding: "utf8" }
+            );
+
+            const menus = await checkMenu([], { disableMenus: ["**/404", "**/403", "**/500", "**/login"] });
+            expect(Array.isArray(menus)).toBe(true);
+            expect(menus).toHaveLength(1);
+            expect(menus[0]?.path).toBe("/a");
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("合法 menus.json 应通过检查", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-ok-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(menusJsonPath, JSON.stringify([{ name: "A", path: "/a", sort: 1, children: [{ name: "B", path: "/a/b", sort: 2 }] }], null, 4), { encoding: "utf8" });
+
+            const menus = await checkMenu([]);
+            expect(Array.isArray(menus)).toBe(true);
+            expect(menus.length).toBe(1);
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("超过三级菜单应阻断同步", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-depth-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(
+                menusJsonPath,
+                JSON.stringify(
+                    [
+                        {
+                            name: "A",
+                            path: "/a",
+                            sort: 1,
+                            children: [
+                                {
+                                    name: "B",
+                                    path: "/a/b",
+                                    sort: 2,
+                                    children: [
+                                        {
+                                            name: "C",
+                                            path: "/a/b/c",
+                                            sort: 3,
+                                            children: [
+                                                {
+                                                    name: "D",
+                                                    path: "/a/b/c/d",
+                                                    sort: 4
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ],
+                    null,
+                    4
+                ),
+                { encoding: "utf8" }
+            );
+
+            let thrown: any = null;
+            try {
+                await checkMenu([]);
+            } catch (error: any) {
+                thrown = error;
+            }
+
+            expect(thrown).toBeTruthy();
+            expect(thrown.message).toBe("菜单结构检查失败");
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+
+    test("sort 最小值应为 1（sort=0 应阻断启动）", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `checkMenu-sort-min-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            writeFileSync(menusJsonPath, JSON.stringify([{ name: "A", path: "/a", sort: 0 }], null, 4), { encoding: "utf8" });
+
+            let thrown: any = null;
+            try {
+                await checkMenu([]);
+            } catch (error: any) {
+                thrown = error;
+            }
+
+            expect(thrown).toBeTruthy();
+            expect(thrown.message).toBe("菜单结构检查失败");
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+});

package/tests/checkTable-smoke.test.ts

@@ -0,0 +1,157 @@
+import type { ScanFileResult } from "../utils/scanFiles.js";
+
+import { describe, expect, test } from "bun:test";
+
+import { checkTable } from "../checks/checkTable.js";
+import { Logger } from "../lib/logger.js";
+
+describe("checkTable - smoke", () => {
+    test("应忽略非 table 项；合法表定义不应抛错", async () => {
+        const items: ScanFileResult[] = [
+            {
+                type: "api",
+                source: "app",
+                sourceName: "项目",
+                filePath: "DUMMY",
+                relativePath: "DUMMY",
+                fileName: "dummy",
+                moduleName: "app_dummy",
+                addonName: "",
+                content: {}
+            } as any,
+            {
+                type: "table",
+                source: "app",
+                sourceName: "项目",
+                filePath: "DUMMY",
+                relativePath: "testCustomers",
+                fileName: "testCustomers",
+                moduleName: "app_testCustomers",
+                addonName: "",
+                content: {
+                    customerName: { name: "客户名", type: "string", max: 32 }
+                }
+            } as any
+        ];
+
+        await checkTable(items);
+        expect(true).toBe(true);
+    });
+
+    test("unique 和 index 同时为 true 时应阻断启动（抛错）", async () => {
+        const items: ScanFileResult[] = [
+            {
+                type: "table",
+                source: "app",
+                sourceName: "项目",
+                filePath: "DUMMY",
+                relativePath: "testMenu",
+                fileName: "testMenu",
+                moduleName: "app_testMenu",
+                addonName: "",
+                content: {
+                    path: { name: "路径", type: "string", max: 128, unique: true, index: true }
+                }
+            } as any
+        ];
+
+        let thrownError: any = null;
+        try {
+            await checkTable(items);
+        } catch (error: any) {
+            thrownError = error;
+        }
+
+        expect(Boolean(thrownError)).toBe(true);
+        expect(String(thrownError?.message || "")).toContain("表结构检查失败");
+    });
+
+    test("sourceName 缺失时：日志不应出现 undefined表（允许前缀为空）", async () => {
+        const calls: Array<{ level: string; args: unknown[] }> = [];
+        const mockLogger = {
+            info(...args: unknown[]) {
+                calls.push({ level: "info", args: args });
+            },
+            warn(...args: unknown[]) {
+                calls.push({ level: "warn", args: args });
+            },
+            error(...args: unknown[]) {
+                calls.push({ level: "error", args: args });
+            },
+            debug(...args: unknown[]) {
+                calls.push({ level: "debug", args: args });
+            }
+        } as any;
+
+        Logger.setMock(mockLogger);
+
+        try {
+            await checkTable([
+                {
+                    type: "table",
+                    source: "app",
+                    filePath: "DUMMY",
+                    relativePath: "TestCustomers",
+                    fileName: "TestCustomers",
+                    moduleName: "app_TestCustomers",
+                    addonName: "",
+                    content: {}
+                } as any
+            ]);
+        } catch {
+            // 触发 hasError 后会抛错：这里只验证日志前缀
+        } finally {
+            Logger.setMock(null);
+        }
+
+        const warnMessages = calls.filter((item) => item.level === "warn").map((item) => String(item.args[0]));
+
+        expect(warnMessages.some((msg) => msg.includes("表 TestCustomers"))).toBe(true);
+        expect(warnMessages.some((msg) => msg.includes("undefined表"))).toBe(false);
+    });
+
+    test("sourceName 非字符串时：日志不应出现 undefined表（允许前缀为空）", async () => {
+        const calls: Array<{ level: string; args: unknown[] }> = [];
+        const mockLogger = {
+            info(...args: unknown[]) {
+                calls.push({ level: "info", args: args });
+            },
+            warn(...args: unknown[]) {
+                calls.push({ level: "warn", args: args });
+            },
+            error(...args: unknown[]) {
+                calls.push({ level: "error", args: args });
+            },
+            debug(...args: unknown[]) {
+                calls.push({ level: "debug", args: args });
+            }
+        } as any;
+
+        Logger.setMock(mockLogger);
+
+        try {
+            await checkTable([
+                {
+                    type: "table",
+                    source: "app",
+                    sourceName: 123,
+                    filePath: "DUMMY",
+                    relativePath: "TestCustomers",
+                    fileName: "TestCustomers",
+                    moduleName: "app_TestCustomers",
+                    addonName: "",
+                    content: {}
+                } as any
+            ]);
+        } catch {
+            // 触发 hasError 后会抛错：这里只验证日志前缀
+        } finally {
+            Logger.setMock(null);
+        }
+
+        const warnMessages = calls.filter((item) => item.level === "warn").map((item) => String(item.args[0]));
+
+        expect(warnMessages.some((msg) => msg.includes("表 TestCustomers"))).toBe(true);
+        expect(warnMessages.some((msg) => msg.includes("undefined表"))).toBe(false);
+    });
+});

package/tests/dbDialect-cache.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "bun:test";
+
+import { getDialectByName } from "../lib/dbDialect.js";
+
+describe("dbDialect - getDialectByName cache", () => {
+    it("should return stable singleton instances", () => {
+        const mysql1 = getDialectByName("mysql");
+        const mysql2 = getDialectByName("mysql");
+        expect(mysql1).toBe(mysql2);
+
+        const pg1 = getDialectByName("postgresql");
+        const pg2 = getDialectByName("postgresql");
+        expect(pg1).toBe(pg2);
+
+        const sqlite1 = getDialectByName("sqlite");
+        const sqlite2 = getDialectByName("sqlite");
+        expect(sqlite1).toBe(sqlite2);
+
+        expect(mysql1).not.toBe(pg1);
+        expect(mysql1).not.toBe(sqlite1);
+        expect(pg1).not.toBe(sqlite1);
+    });
+});

package/tests/dbDialect.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "bun:test";
+
+import { MySqlDialect, PostgresDialect, SqliteDialect } from "../lib/dbDialect.js";
+
+describe("DbDialect - quoteIdent", () => {
+    it("MySqlDialect: 使用反引号", () => {
+        const dialect = new MySqlDialect();
+        expect(dialect.quoteIdent("users")).toBe("`users`");
+        expect(dialect.quoteIdent("created_at")).toBe("`created_at`");
+    });
+
+    it("PostgresDialect: 使用双引号", () => {
+        const dialect = new PostgresDialect();
+        expect(dialect.quoteIdent("users")).toBe('"users"');
+        expect(dialect.quoteIdent("created_at")).toBe('"created_at"');
+    });
+
+    it("SqliteDialect: 使用双引号", () => {
+        const dialect = new SqliteDialect();
+        expect(dialect.quoteIdent("users")).toBe('"users"');
+        expect(dialect.quoteIdent("created_at")).toBe('"created_at"');
+    });
+});
+
+describe("DbDialect - getTableColumnsQuery/tableExistsQuery", () => {
+    it("PostgresDialect: columns 查询应带参数", () => {
+        const dialect = new PostgresDialect();
+        const query = dialect.getTableColumnsQuery("users");
+        expect(query.sql).toContain("information_schema.columns");
+        expect(query.params).toEqual(["users"]);
+    });
+
+    it('SqliteDialect: columns 查询应为 PRAGMA table_info("table")', () => {
+        const dialect = new SqliteDialect();
+        const query = dialect.getTableColumnsQuery("users");
+        expect(query.sql).toBe('PRAGMA table_info("users")');
+        expect(query.params).toEqual([]);
+    });
+
+    it("SqliteDialect: tableExistsQuery 应查 sqlite_master", () => {
+        const dialect = new SqliteDialect();
+        const query = dialect.tableExistsQuery("users");
+        expect(query.sql).toContain("sqlite_master");
+        expect(query.params).toEqual(["users"]);
+    });
+});

package/tests/dbHelper-advanced.test.ts

@@ -666,7 +666,7 @@ describe("DbHelper - 代码逻辑问题分析", () => {
         // **建议修复**：
         // 添加查询超时机制
 
-        const mockExecuteWithTimeout = async (sql: string, params: any[], timeout: number = 30000) => {
+        const mockExecuteWithTimeout = async (sql: string, params: unknown[], timeout: number = 30000) => {
             const timeoutPromise = new Promise((_, reject) => {
                 setTimeout(() => reject(new Error("查询超时")), timeout);
             });

package/tests/dbHelper-all-array-types.test.ts

@@ -252,14 +252,14 @@ describe("所有数组类型的序列化/反序列化支持", () => {
             id: 1,
             name: "管理员",
             code: "admin",
-            menus: [1, 2, 3, 10, 11, 12, 20, 21], // array_number_string
-            apis: [100, 101, 102, 200, 201, 202] // array_number_string
+            menus: ["/dashboard", "/permission/role"], // array_text
+            apis: ["/api/login", "/api/user/list"] // array_text
         };
 
         // 模拟写入数据库
         const serialized = serializeArrayFields(roleData);
-        expect(serialized.menus).toBe("[1,2,3,10,11,12,20,21]");
-        expect(serialized.apis).toBe("[100,101,102,200,201,202]");
+        expect(serialized.menus).toBe('["/dashboard","/permission/role"]');
+        expect(serialized.apis).toBe('["/api/login","/api/user/list"]');
 
         // 模拟从数据库查询
         const deserialized = deserializeArrayFields(serialized);
@@ -267,8 +267,8 @@ describe("所有数组类型的序列化/反序列化支持", () => {
         expect(deserialized.apis).toEqual(roleData.apis);
 
         // 验证可以直接使用数组方法
-        expect(deserialized.menus.includes(1)).toBe(true);
-        expect(deserialized.apis.length).toBe(6);
+        expect(deserialized.menus.includes("/dashboard")).toBe(true);
+        expect(deserialized.apis.length).toBe(2);
     });
 
     test("实际场景: 文章标签和分类", () => {
@@ -292,25 +292,25 @@ describe("所有数组类型的序列化/反序列化支持", () => {
 
     test("完整流程: 批量插入场景", () => {
         const roles = [
-            { name: "管理员", menus: [1, 2, 3], apis: [10, 20] },
-            { name: "编辑", menus: [2, 3], apis: [20] },
-            { name: "访客", menus: [3], apis: [] }
+            { name: "管理员", menus: ["/dashboard", "/permission/role"], apis: ["/api/login", "/api/user/list"] },
+            { name: "编辑", menus: ["/dashboard"], apis: ["/api/user/list"] },
+            { name: "访客", menus: ["/dashboard"], apis: [] }
         ];
 
         // 模拟批量序列化
         const serializedRoles = roles.map((role) => serializeArrayFields(role));
 
-        expect(serializedRoles[0].menus).toBe("[1,2,3]");
-        expect(serializedRoles[1].menus).toBe("[2,3]");
-        expect(serializedRoles[2].menus).toBe("[3]");
+        expect(serializedRoles[0].menus).toBe('["/dashboard","/permission/role"]');
+        expect(serializedRoles[1].menus).toBe('["/dashboard"]');
+        expect(serializedRoles[2].menus).toBe('["/dashboard"]');
         expect(serializedRoles[2].apis).toBe("[]");
 
         // 模拟批量反序列化
         const deserializedRoles = serializedRoles.map((role) => deserializeArrayFields(role));
 
-        expect(deserializedRoles[0].menus).toEqual([1, 2, 3]);
-        expect(deserializedRoles[1].menus).toEqual([2, 3]);
-        expect(deserializedRoles[2].menus).toEqual([3]);
+        expect(deserializedRoles[0].menus).toEqual(["/dashboard", "/permission/role"]);
+        expect(deserializedRoles[1].menus).toEqual(["/dashboard"]);
+        expect(deserializedRoles[2].menus).toEqual(["/dashboard"]);
         expect(deserializedRoles[2].apis).toEqual([]);
     });
 });