befly 3.9.40 → 3.10.1

package/tests/sqlBuilder-advanced.test.ts

@@ -183,7 +183,7 @@ describe("SqlBuilder - 复杂 WHERE 条件", () => {
         const result = builder.select(["*"]).from("users").where({ $or: [] }).toSelectSql();
 
         // **问题**：空 $or 应该跳过还是报错？
-        console.log("$or 空数组生成的 SQL:", result.sql);
+        expect(typeof result.sql).toBe("string");
     });
 
     test("$and + $or 嵌套", () => {
@@ -234,7 +234,7 @@ describe("SqlBuilder - 复杂 WHERE 条件", () => {
             .toSelectSql();
 
         expect(result.sql).toBeDefined();
-        console.log("深层嵌套生成的 SQL:", result.sql);
+        expect(typeof result.sql).toBe("string");
     });
 });
 
@@ -272,9 +272,15 @@ describe("SqlBuilder - 字段名转义", () => {
         expect(result.sql).toContain("`profiles`.`bio`");
     });
 
-    test("函数调用不应转义", () => {
+    test("函数调用必须使用 selectRaw", () => {
         const builder = new SqlBuilder();
-        const result = builder.select(["COUNT(*)", "MAX(age)"]).from("users").toSelectSql();
+
+        expect(() => {
+            builder.select(["COUNT(*)", "MAX(age)"]).from("users").toSelectSql();
+        }).toThrow("selectRaw");
+
+        const builder2 = new SqlBuilder();
+        const result = builder2.selectRaw("COUNT(*)").selectRaw("MAX(age)").from("users").toSelectSql();
 
         expect(result.sql).toContain("COUNT(*)");
         expect(result.sql).toContain("MAX(age)");
@@ -283,7 +289,7 @@ describe("SqlBuilder - 字段名转义", () => {
 
     test("AS 别名应正确处理", () => {
         const builder = new SqlBuilder();
-        const result = builder.select(["name AS userName", "COUNT(*) AS total"]).from("users").toSelectSql();
+        const result = builder.select(["name AS userName"]).selectRaw("COUNT(*) AS total").from("users").toSelectSql();
 
         expect(result.sql).toContain("`name` AS userName");
         expect(result.sql).toContain("COUNT(*) AS total");
@@ -322,6 +328,13 @@ describe("SqlBuilder - 表名转义", () => {
         expect(result.sql).toContain("FROM `user_profiles`");
         expect(result.sql).not.toContain("``");
     });
+
+    test("已有反引号的表名带别名应正确处理", () => {
+        const builder = new SqlBuilder();
+        const result = builder.select(["*"]).from("`user_profiles` up").toSelectSql();
+
+        expect(result.sql).toContain("FROM `user_profiles` up");
+    });
 });
 
 describe("SqlBuilder - ORDER BY", () => {

package/tests/sqlBuilder.test.ts

@@ -132,6 +132,30 @@ describe("SqlBuilder - INSERT", () => {
         expect(result.sql).toContain("VALUES (?, ?)");
         expect(result.params).toEqual(["John", 25]);
     });
+
+    test("插入单条数据 - 参数为 undefined 应抛错", () => {
+        const builder = new SqlBuilder();
+        expect(() => {
+            builder.toInsertSql("users", { name: undefined as any, age: 25 });
+        }).toThrow("undefined");
+    });
+
+    test("批量插入 - 行字段不一致应抛错", () => {
+        const builder = new SqlBuilder();
+        expect(() => {
+            builder.toInsertSql("users", [{ name: "John", age: 25 }, { name: "Jane" }] as any);
+        }).toThrow("字段必须一致");
+    });
+
+    test("批量插入 - 缺字段或 undefined 应抛错", () => {
+        const builder = new SqlBuilder();
+        expect(() => {
+            builder.toInsertSql("users", [
+                { name: "John", age: 25 },
+                { name: "Jane", age: undefined as any }
+            ] as any);
+        }).toThrow("undefined");
+    });
 });
 
 describe("SqlBuilder - UPDATE", () => {

package/tests/sync-init-guard.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import { syncApi } from "../sync/syncApi.js";
+import { syncDev } from "../sync/syncDev.js";
+import { syncMenu } from "../sync/syncMenu.js";
+
+describe("sync - init guard", () => {
+    test("syncApi: ctx.db 缺失时应给出明确错误", async () => {
+        const ctx = {} as any;
+
+        let error: any = null;
+        try {
+            await syncApi(ctx, [] as any);
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncApi: ctx.db 未初始化（Db 插件未加载或注入失败）");
+    });
+
+    test("syncApi: ctx.cache 缺失时应给出明确错误", async () => {
+        const ctx = { db: {} } as any;
+
+        let error: any = null;
+        try {
+            await syncApi(ctx, [] as any);
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncApi: ctx.cache 未初始化（cache 插件未加载或注入失败）");
+    });
+
+    test("syncDev: ctx.db 缺失时应给出明确错误", async () => {
+        const ctx = {} as any;
+
+        let error: any = null;
+        try {
+            await syncDev(ctx, { devEmail: "dev@qq.com", devPassword: "dev-password" });
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncDev: ctx.db 未初始化（Db 插件未加载或注入失败）");
+    });
+
+    test("syncDev: ctx.cache 缺失时应给出明确错误", async () => {
+        const ctx = { db: {} } as any;
+
+        let error: any = null;
+        try {
+            await syncDev(ctx, { devEmail: "dev@qq.com", devPassword: "dev-password" });
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncDev: ctx.cache 未初始化（cache 插件未加载或注入失败）");
+    });
+
+    test("syncMenu: ctx.db 缺失时应给出明确错误", async () => {
+        const ctx = {} as any;
+
+        let error: any = null;
+        try {
+            await syncMenu(ctx, [] as any);
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncMenu: ctx.db 未初始化（Db 插件未加载或注入失败）");
+    });
+
+    test("syncMenu: ctx.cache 缺失时应给出明确错误", async () => {
+        const ctx = { db: {} } as any;
+
+        let error: any = null;
+        try {
+            await syncMenu(ctx, [] as any);
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncMenu: ctx.cache 未初始化（cache 插件未加载或注入失败）");
+    });
+
+    test("syncMenu: ctx.config 缺失时应给出明确错误", async () => {
+        const ctx = { db: {}, cache: {} } as any;
+
+        let error: any = null;
+        try {
+            await syncMenu(ctx, [] as any);
+        } catch (err: any) {
+            error = err;
+        }
+
+        expect(typeof error?.message).toBe("string");
+        expect(error.message).toBe("syncMenu: ctx.config 未初始化（config 插件未加载或注入失败）");
+    });
+});

package/tests/syncApi-insBatch-fields-consistent.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+
+import { syncApi } from "../sync/syncApi.js";
+
+describe("syncApi - insBatch rows consistency", () => {
+    test("当部分 api 缺少 addonName 时，insBatch 仍应传入稳定字段（addonName 为空字符串）", async () => {
+        const calls: any = {
+            insBatch: [] as any[],
+            cacheApis: 0,
+            rebuildRoleApiPermissions: 0
+        };
+
+        const ctx: any = {
+            db: {
+                tableExists: async () => true,
+                getAll: async () => {
+                    return { lists: [], total: 0 };
+                },
+                insBatch: async (_table: string, dataList: any[]) => {
+                    calls.insBatch.push({ table: _table, dataList: dataList });
+                    return [1, 2];
+                },
+                updBatch: async () => 0,
+                delForceBatch: async () => 0
+            },
+            cache: {
+                cacheApis: async () => {
+                    calls.cacheApis += 1;
+                },
+                rebuildRoleApiPermissions: async () => {
+                    calls.rebuildRoleApiPermissions += 1;
+                }
+            }
+        };
+
+        // 根因修复后：scanFiles 会确保 API 记录总是携带 addonName（app/core 为 ""）。
+        // 因此这里模拟真实扫描结果：第二条的 addonName 应该是空字符串而非 undefined。
+        const apis: any[] = [
+            { type: "api", name: "A", routePath: "/api/addon/admin/a", addonName: "admin" },
+            { name: "B", routePath: "/api/app/b", addonName: "" }
+        ];
+
+        await syncApi(ctx, apis as any);
+
+        expect(calls.insBatch.length).toBe(1);
+        expect(calls.insBatch[0].table).toBe("addon_admin_api");
+
+        const rows = calls.insBatch[0].dataList;
+        expect(rows.length).toBe(2);
+
+        expect(Object.keys(rows[0]).sort()).toEqual(Object.keys(rows[1]).sort());
+
+        expect(typeof rows[0].addonName).toBe("string");
+        expect(typeof rows[1].addonName).toBe("string");
+        expect(rows[1].addonName).toBe("");
+
+        // 缓存同步职责已收敛到 syncCache（启动流程单点调用）
+        expect(calls.cacheApis).toBe(0);
+        expect(calls.rebuildRoleApiPermissions).toBe(0);
+    });
+});

package/tests/syncApi-obsolete-records.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+
+import { syncApi } from "../sync/syncApi.js";
+
+describe("syncApi - delete obsolete records", () => {
+    test("应删除不在配置中的接口记录", async () => {
+        const existingRecords = [
+            { id: 1, routePath: "/api/app/testSyncKeep", name: "Keep", addonName: "", state: 0 },
+            { id: 2, routePath: "/api/app/testSyncRemove", name: "Remove", addonName: "", state: 0 }
+        ];
+
+        const existingByPath = new Map<string, any>();
+        for (const record of existingRecords) {
+            existingByPath.set(record.routePath, record);
+        }
+
+        const calls = {
+            delForceBatch: [] as any[],
+            getAllArgs: null as any
+        };
+
+        const dbHelper = {
+            tableExists: async () => true,
+            updBatch: async () => 0,
+            insBatch: async () => [],
+            getAll: async (options: any) => {
+                calls.getAllArgs = options;
+                return { lists: existingRecords };
+            },
+            delForceBatch: async (_table: any, ids: any[]) => {
+                calls.delForceBatch.push(ids);
+                return ids.length;
+            }
+        } as any;
+
+        const ctx = {
+            db: dbHelper,
+            addons: [],
+            cache: {
+                cacheApis: async () => {},
+                rebuildRoleApiPermissions: async () => {}
+            }
+        } as any;
+
+        const apiItems = [
+            {
+                source: "app",
+                sourceName: "项目",
+                filePath: "DUMMY",
+                relativePath: "testSyncKeep",
+                fileName: "testSyncKeep",
+                moduleName: "app_testSyncKeep",
+                name: "Keep",
+                routePath: "/api/app/testSyncKeep",
+                addonName: "",
+                fileBaseName: "testSyncKeep.ts",
+                fileDir: "DUMMY",
+                content: { name: "Keep", handler: async () => {} }
+            }
+        ] as any;
+
+        await syncApi(ctx, apiItems);
+
+        expect(calls.getAllArgs?.fields).toEqual(["id", "routePath", "name", "addonName", "state"]);
+
+        expect(calls.delForceBatch).toHaveLength(1);
+        expect(calls.delForceBatch[0]).toEqual([2]);
+    });
+});

package/tests/syncApi-type-compat.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+
+import { syncApi } from "../sync/syncApi.js";
+
+describe("syncApi - type compatibility", () => {
+    test("缺少 type 时应视为 api；非 api type 应被跳过", async () => {
+        const existingRecords = [
+            { id: 1, routePath: "/api/app/keep", name: "Keep", addonName: "", state: 0 },
+            { id: 2, routePath: "/api/app/skip", name: "Skip", addonName: "", state: 0 }
+        ];
+
+        const calls = {
+            delForceBatch: [] as any[],
+            getAllArgs: null as any
+        };
+
+        const dbHelper = {
+            tableExists: async () => true,
+            updBatch: async () => 0,
+            insBatch: async () => [],
+            getAll: async (options: any) => {
+                calls.getAllArgs = options;
+                return { lists: existingRecords };
+            },
+            delForceBatch: async (_table: any, ids: any[]) => {
+                calls.delForceBatch.push(ids);
+                return ids.length;
+            }
+        } as any;
+
+        const ctx = {
+            db: dbHelper,
+            addons: [],
+            cache: {
+                cacheApis: async () => {},
+                rebuildRoleApiPermissions: async () => {}
+            }
+        } as any;
+
+        const apiItems = [
+            // 不带 type：应按 api 处理，保留 keep
+            {
+                source: "app",
+                sourceName: "项目",
+                filePath: "DUMMY",
+                relativePath: "keep",
+                fileName: "keep",
+                moduleName: "app_keep",
+                name: "Keep",
+                routePath: "/api/app/keep",
+                addonName: "",
+                fileBaseName: "keep.ts",
+                fileDir: "DUMMY",
+                content: { name: "Keep", handler: async () => {} }
+            },
+            // 带非 api type：应被跳过，因此 DB 中的 skip 会被当作“配置不存在”而删除
+            {
+                type: "menu",
+                name: "Skip",
+                routePath: "/api/app/skip",
+                addonName: ""
+            }
+        ] as any;
+
+        await syncApi(ctx, apiItems);
+
+        expect(calls.getAllArgs?.fields).toEqual(["id", "routePath", "name", "addonName", "state"]);
+
+        expect(calls.delForceBatch).toHaveLength(1);
+        expect(calls.delForceBatch[0]).toEqual([2]);
+    });
+});

package/tests/syncDev-permissions.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "bun:test";
+
+import { syncDev } from "../sync/syncDev.js";
+
+describe("syncDev - dev role permissions", () => {
+    test("dev 角色应拥有所有菜单和接口（state>=0）", async () => {
+        const calls = {
+            getAll: [],
+            insData: [],
+            updData: [],
+            rebuildRoleApiPermissionsCount: 0
+        };
+
+        let nextId = 100;
+
+        const ctx = {
+            db: {
+                tableExists: async (table) => {
+                    return table === "addon_admin_admin" || table === "addon_admin_role" || table === "addon_admin_menu" || table === "addon_admin_api";
+                },
+                getAll: async (options) => {
+                    calls.getAll.push(options);
+
+                    if (options?.table === "addon_admin_menu") {
+                        return {
+                            lists: [
+                                { path: "/dashboard", state: 0 },
+                                { path: "/permission/role", state: 0 }
+                            ]
+                        };
+                    }
+                    if (options?.table === "addon_admin_api") {
+                        return {
+                            lists: [
+                                { routePath: "/api/health", state: 0 },
+                                { routePath: "/api/addon/addonAdmin/auth/login", state: 0 }
+                            ]
+                        };
+                    }
+
+                    return { lists: [] };
+                },
+                getOne: async (_options) => {
+                    // 让所有角色/管理员都走插入逻辑，便于断言插入数据
+                    return null;
+                },
+                insData: async (options) => {
+                    calls.insData.push(options);
+                    nextId += 1;
+                    return nextId;
+                },
+                updData: async (options) => {
+                    calls.updData.push(options);
+                    return 1;
+                }
+            },
+            cache: {
+                rebuildRoleApiPermissions: async () => {
+                    calls.rebuildRoleApiPermissionsCount += 1;
+                }
+            }
+        };
+
+        await syncDev(ctx, { devEmail: "dev@qq.com", devPassword: "dev-password" });
+
+        // 断言读取菜单/接口时按 state>=0 查询
+        const menuGetAll = calls.getAll.find((c) => c?.table === "addon_admin_menu");
+        expect(menuGetAll?.where?.state$gte).toBe(0);
+
+        const apiGetAll = calls.getAll.find((c) => c?.table === "addon_admin_api");
+        expect(apiGetAll?.where?.state$gte).toBe(0);
+
+        // 断言 dev 角色写入时包含“所有路径”（按查询结果写入；统一为 pathname，不包含 method）
+        const devRoleInsert = calls.insData.find((c) => c?.table === "addon_admin_role" && c?.data?.code === "dev");
+        expect(devRoleInsert).toBeTruthy();
+        expect(devRoleInsert.data.menus).toEqual(["/dashboard", "/permission/role"]);
+        expect(devRoleInsert.data.apis).toEqual(["/api/health", "/api/addon/addonAdmin/auth/login"]);
+
+        expect(calls.rebuildRoleApiPermissionsCount).toBe(0);
+    });
+});

package/tests/syncMenu-disableMenus-hard-delete.test.ts

@@ -0,0 +1,88 @@
+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";
+import { syncMenu } from "../sync/syncMenu.js";
+
+describe("syncMenu - disableMenus hard delete", () => {
+    test("命中 disableMenus 的菜单应被强制删除（不分 state）", async () => {
+        const originalCwd = process.cwd();
+        const projectDir = join(originalCwd, "temp", `syncMenu-disableMenus-hard-delete-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+        const menusJsonPath = join(projectDir, "menus.json");
+
+        // /addon/admin/403 为禁用项，即使 state=-1 也应该被硬删除
+        const existingMenus = [
+            { id: 1, path: "/addon/admin/403", parentPath: "", name: "403", sort: 1, state: -1 },
+            { id: 2, path: "/keep", parentPath: "", name: "Keep", sort: 2, state: 0 }
+        ];
+
+        const calls = {
+            delForceBatch: [] as Array<{ table: string; ids: number[] }>
+        };
+
+        const dbHelper = {
+            tableExists: async () => true,
+            trans: async (callback: any) => {
+                return await callback(dbHelper);
+            },
+            getAll: async (options: any) => {
+                // syncMenu 会调用一次“全量不带 where”，一次 state>=0 的逻辑已在内存过滤
+                if (options?.table === "addon_admin_menu") {
+                    return { lists: existingMenus };
+                }
+                return { lists: [] };
+            },
+            updBatch: async () => 0,
+            insBatch: async () => [],
+            delForceBatch: async (table: string, ids: number[]) => {
+                calls.delForceBatch.push({ table: table, ids: ids });
+                return ids.length;
+            }
+        } as any;
+
+        const ctx = {
+            db: dbHelper,
+            addons: [],
+            config: {
+                disableMenus: ["**/403"]
+            },
+            cache: {
+                cacheMenus: async () => {}
+            }
+        } as any;
+
+        try {
+            mkdirSync(projectDir, { recursive: true });
+            process.chdir(projectDir);
+
+            // 配置中仅保留 /keep
+            writeFileSync(
+                menusJsonPath,
+                JSON.stringify(
+                    [
+                        {
+                            name: "Keep",
+                            path: "/keep",
+                            sort: 2
+                        }
+                    ],
+                    null,
+                    4
+                ),
+                { encoding: "utf8" }
+            );
+
+            const menus = await checkMenu(ctx.addons, { disableMenus: ctx.config.disableMenus });
+            await syncMenu(ctx, menus);
+        } finally {
+            process.chdir(originalCwd);
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+
+        expect(calls.delForceBatch).toHaveLength(1);
+        expect(calls.delForceBatch[0].table).toBe("addon_admin_menu");
+        // 应包含禁用菜单 id=1；/keep 不应被删
+        expect(calls.delForceBatch[0].ids).toEqual([1]);
+    });
+});