befly 3.10.1 → 3.10.2

package/tests/sqlBuilder.test.ts

@@ -1,209 +0,0 @@
-import { describe, test, expect } from "bun:test";
-
-import { SqlBuilder } from "../lib/sqlBuilder";
-
-describe("SqlBuilder - SELECT 查询", () => {
-    test("简单查询", () => {
-        const builder = new SqlBuilder();
-        const result = builder.select(["id", "name"]).from("users").toSelectSql();
-        expect(result.sql).toContain("SELECT `id`, `name` FROM `users`");
-        expect(result.params).toEqual([]);
-    });
-
-    test("查询所有字段", () => {
-        const builder = new SqlBuilder();
-        const result = builder.select(["*"]).from("users").toSelectSql();
-        expect(result.sql).toContain("SELECT * FROM `users`");
-    });
-
-    test("带 WHERE 条件", () => {
-        const builder = new SqlBuilder();
-        const result = builder.select(["*"]).from("users").where({ id: 1 }).toSelectSql();
-        expect(result.sql).toContain("WHERE `id` = ?");
-        expect(result.params).toEqual([1]);
-    });
-
-    test("多个 WHERE 条件", () => {
-        const builder = new SqlBuilder();
-        const result = builder.select(["*"]).from("users").where({ id: 1, status: "active" }).toSelectSql();
-        expect(result.sql).toContain("WHERE");
-        expect(result.sql).toContain("AND");
-        expect(result.params).toEqual([1, "active"]);
-    });
-
-    test("ORDER BY", () => {
-        const builder = new SqlBuilder();
-        const result = builder.select(["*"]).from("users").orderBy(["created_at#DESC"]).toSelectSql();
-        expect(result.sql).toContain("ORDER BY `created_at` DESC");
-    });
-
-    test("LIMIT 和 OFFSET", () => {
-        const builder = new SqlBuilder();
-        const result = builder.select(["*"]).from("users").limit(10).offset(20).toSelectSql();
-        expect(result.sql).toContain("LIMIT 10 OFFSET 20");
-    });
-});
-
-describe("SqlBuilder - WHERE 操作符", () => {
-    test("$ne 不等于", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ status: { $ne: "deleted" } })
-            .toSelectSql();
-        expect(result.sql).toContain("`status` != ?");
-        expect(result.params).toEqual(["deleted"]);
-    });
-
-    test("$in 包含", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ id: { $in: [1, 2, 3] } })
-            .toSelectSql();
-        expect(result.sql).toContain("`id` IN (?,?,?)");
-        expect(result.params).toEqual([1, 2, 3]);
-    });
-
-    test("$gt 大于", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ age: { $gt: 18 } })
-            .toSelectSql();
-        expect(result.sql).toContain("`age` > ?");
-        expect(result.params).toEqual([18]);
-    });
-
-    test("$gte 大于等于", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ age: { $gte: 18 } })
-            .toSelectSql();
-        expect(result.sql).toContain("`age` >= ?");
-        expect(result.params).toEqual([18]);
-    });
-
-    test("$lt 小于", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ age: { $lt: 60 } })
-            .toSelectSql();
-        expect(result.sql).toContain("`age` < ?");
-        expect(result.params).toEqual([60]);
-    });
-
-    test("$lte 小于等于", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ age: { $lte: 60 } })
-            .toSelectSql();
-        expect(result.sql).toContain("`age` <= ?");
-        expect(result.params).toEqual([60]);
-    });
-
-    test("$like 模糊匹配", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["*"])
-            .from("users")
-            .where({ name: { $like: "%john%" } })
-            .toSelectSql();
-        expect(result.sql).toContain("`name` LIKE ?");
-        expect(result.params).toEqual(["%john%"]);
-    });
-});
-
-describe("SqlBuilder - INSERT", () => {
-    test("插入单条数据", () => {
-        const builder = new SqlBuilder();
-        const result = builder.toInsertSql("users", { name: "John", age: 25 });
-        expect(result.sql).toContain("INSERT INTO `users`");
-        expect(result.sql).toContain("(`name`, `age`)");
-        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", () => {
-    test("更新数据", () => {
-        const builder = new SqlBuilder();
-        const result = builder.where({ id: 1 }).toUpdateSql("users", { name: "Jane" });
-        expect(result.sql).toContain("UPDATE `users`");
-        expect(result.sql).toContain("SET `name` = ?");
-        expect(result.sql).toContain("WHERE `id` = ?");
-        expect(result.params).toEqual(["Jane", 1]);
-    });
-});
-
-describe("SqlBuilder - DELETE", () => {
-    test("删除数据", () => {
-        const builder = new SqlBuilder();
-        const result = builder.where({ id: 1 }).toDeleteSql("users");
-        expect(result.sql).toContain("DELETE FROM `users`");
-        expect(result.sql).toContain("WHERE `id` = ?");
-        expect(result.params).toEqual([1]);
-    });
-});
-
-describe("SqlBuilder - 链式调用", () => {
-    test("复杂查询", () => {
-        const builder = new SqlBuilder();
-        const result = builder
-            .select(["id", "name", "email"])
-            .from("users")
-            .where({ status: "active", age: { $gte: 18 } })
-            .orderBy(["created_at#DESC"])
-            .limit(10)
-            .toSelectSql();
-
-        expect(result.sql).toContain("SELECT");
-        expect(result.sql).toContain("FROM `users`");
-        expect(result.sql).toContain("WHERE");
-        expect(result.sql).toContain("ORDER BY");
-        expect(result.sql).toContain("LIMIT 10");
-        expect(result.params.length).toBeGreaterThan(0);
-    });
-
-    test("reset 重置", () => {
-        const builder = new SqlBuilder();
-        builder.select(["*"]).from("users").where({ id: 1 });
-        builder.reset();
-        const result = builder.select(["*"]).from("posts").toSelectSql();
-        expect(result.sql).toContain("FROM `posts`");
-        expect(result.sql).not.toContain("users");
-    });
-});

package/tests/sync-connection.test.ts

@@ -1,183 +0,0 @@
-/**
- * sync 模块连接管理集成测试
- * 验证数据库连接的正确关闭
- */
-import { describe, test, expect, afterEach } from "bun:test";
-
-import { Connect } from "../lib/connect.js";
-
-describe("sync 模块连接管理", () => {
-    afterEach(() => {
-        // 每个测试后重置连接状态
-        Connect.__reset();
-    });
-
-    describe("Connect.isConnected", () => {
-        test("初始状态应该都是未连接", () => {
-            const status = Connect.isConnected();
-            expect(status.sql).toBe(false);
-            expect(status.redis).toBe(false);
-        });
-    });
-
-    describe("Connect.disconnect", () => {
-        test("disconnect 应该能安全地关闭未连接的状态", async () => {
-            // 即使没有连接，disconnect 也不应该抛出错误
-            await expect(Connect.disconnect()).resolves.toBeUndefined();
-        });
-
-        test("disconnectSql 应该能安全地关闭未连接的状态", async () => {
-            await expect(Connect.disconnectSql()).resolves.toBeUndefined();
-        });
-
-        test("disconnectRedis 应该能安全地关闭未连接的状态", async () => {
-            await expect(Connect.disconnectRedis()).resolves.toBeUndefined();
-        });
-    });
-
-    describe("Connect.getSql", () => {
-        test("未连接时应该抛出错误", () => {
-            expect(() => Connect.getSql()).toThrow("SQL 客户端未连接");
-        });
-    });
-
-    describe("Connect.getRedis", () => {
-        test("未连接时应该抛出错误", () => {
-            expect(() => Connect.getRedis()).toThrow("Redis 客户端未连接");
-        });
-    });
-
-    describe("Mock 连接测试", () => {
-        test("__setMockSql 应该设置 mock SQL 客户端", () => {
-            const mockSql = { close: async () => {} } as any;
-            Connect.__setMockSql(mockSql);
-
-            const status = Connect.isConnected();
-            expect(status.sql).toBe(true);
-            expect(status.redis).toBe(false);
-        });
-
-        test("__setMockRedis 应该设置 mock Redis 客户端", () => {
-            const mockRedis = { close: () => {} } as any;
-            Connect.__setMockRedis(mockRedis);
-
-            const status = Connect.isConnected();
-            expect(status.sql).toBe(false);
-            expect(status.redis).toBe(true);
-        });
-
-        test("__reset 应该重置所有连接", () => {
-            const mockSql = { close: async () => {} } as any;
-            const mockRedis = { close: () => {} } as any;
-            Connect.__setMockSql(mockSql);
-            Connect.__setMockRedis(mockRedis);
-
-            expect(Connect.isConnected().sql).toBe(true);
-            expect(Connect.isConnected().redis).toBe(true);
-
-            Connect.__reset();
-
-            expect(Connect.isConnected().sql).toBe(false);
-            expect(Connect.isConnected().redis).toBe(false);
-        });
-
-        test("disconnect 应该正确关闭 mock 连接", async () => {
-            let sqlClosed = false;
-            let redisClosed = false;
-
-            const mockSql = {
-                close: async () => {
-                    sqlClosed = true;
-                }
-            } as any;
-            const mockRedis = {
-                close: () => {
-                    redisClosed = true;
-                }
-            } as any;
-
-            Connect.__setMockSql(mockSql);
-            Connect.__setMockRedis(mockRedis);
-
-            await Connect.disconnect();
-
-            expect(sqlClosed).toBe(true);
-            expect(redisClosed).toBe(true);
-            expect(Connect.isConnected().sql).toBe(false);
-            expect(Connect.isConnected().redis).toBe(false);
-        });
-    });
-
-    describe("连接异常处理", () => {
-        test("disconnectSql 应该处理关闭时的错误", async () => {
-            const mockSql = {
-                close: async () => {
-                    throw new Error("Close error");
-                }
-            } as any;
-
-            Connect.__setMockSql(mockSql);
-
-            // 不应该抛出错误，只是记录日志
-            await expect(Connect.disconnectSql()).resolves.toBeUndefined();
-            expect(Connect.isConnected().sql).toBe(false);
-        });
-
-        test("disconnectRedis 应该处理关闭时的错误", async () => {
-            const mockRedis = {
-                close: () => {
-                    throw new Error("Close error");
-                }
-            } as any;
-
-            Connect.__setMockRedis(mockRedis);
-
-            // 不应该抛出错误，只是记录日志
-            await expect(Connect.disconnectRedis()).resolves.toBeUndefined();
-            expect(Connect.isConnected().redis).toBe(false);
-        });
-    });
-
-    describe("Connect.getStatus", () => {
-        test("未连接时返回正确的状态", () => {
-            const status = Connect.getStatus();
-
-            expect(status.sql.connected).toBe(false);
-            expect(status.sql.connectedAt).toBeNull();
-            expect(status.sql.uptime).toBeNull();
-            expect(status.sql.poolMax).toBe(1);
-
-            expect(status.redis.connected).toBe(false);
-            expect(status.redis.connectedAt).toBeNull();
-            expect(status.redis.uptime).toBeNull();
-        });
-
-        test("Mock 连接后返回正确的状态", () => {
-            const mockSql = { close: async () => {} } as any;
-            const mockRedis = { close: () => {} } as any;
-
-            Connect.__setMockSql(mockSql);
-            Connect.__setMockRedis(mockRedis);
-
-            const status = Connect.getStatus();
-
-            // Mock 不会设置连接时间，但连接状态应该为 true
-            expect(status.sql.connected).toBe(true);
-            expect(status.redis.connected).toBe(true);
-        });
-
-        test("__reset 应该重置所有状态包括连接时间", () => {
-            const mockSql = { close: async () => {} } as any;
-            Connect.__setMockSql(mockSql);
-
-            expect(Connect.getStatus().sql.connected).toBe(true);
-
-            Connect.__reset();
-
-            const status = Connect.getStatus();
-            expect(status.sql.connected).toBe(false);
-            expect(status.sql.connectedAt).toBeNull();
-            expect(status.sql.poolMax).toBe(1);
-        });
-    });
-});

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

@@ -1,105 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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]);
-    });
-});