befly 3.10.0 → 3.10.2

package/tests/dbHelper-columns.test.ts

@@ -1,234 +0,0 @@
-/**
- * DbHelper getTableColumns 方法单元测试
- * 测试表字段查询、Redis 缓存、SQL 语法修复等功能
- */
-
-import { test, expect, mock } from "bun:test";
-
-import { CacheKeys } from "../lib/cacheKeys.js";
-import { MySqlDialect } from "../lib/dbDialect.js";
-import { DbHelper } from "../lib/dbHelper.js";
-
-function createRedisMock(options?: { getObject?: any; setObject?: any; del?: any; genTimeID?: any }) {
-    const getObject = options?.getObject ? options.getObject : mock(async () => null);
-    const setObject = options?.setObject ? options.setObject : mock(async () => true);
-    const del = options?.del ? options.del : mock(async () => 1);
-    const genTimeID = options?.genTimeID ? options.genTimeID : mock(async () => 1);
-
-    return {
-        getObject: getObject,
-        setObject: setObject,
-        del: del,
-        genTimeID: genTimeID
-    };
-}
-
-test("getTableColumns - 正常查询表字段", async () => {
-    const mockColumns = [{ Field: "id" }, { Field: "username" }, { Field: "email" }, { Field: "created_at" }];
-
-    const sqlMock = {
-        unsafe: mock(async (sql: string) => {
-            // 验证 SQL 语法正确（使用反引号）
-            expect(sql).toBe("SHOW COLUMNS FROM `users`");
-            return mockColumns;
-        })
-    };
-
-    const redisMock = createRedisMock({
-        getObject: mock(async () => null) // 缓存未命中
-    });
-
-    const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const columns = await (dbHelper as any).getTableColumns("users");
-
-    expect(columns).toEqual(["id", "username", "email", "created_at"]);
-    expect(sqlMock.unsafe).toHaveBeenCalledTimes(1);
-    expect(redisMock.getObject).toHaveBeenCalledWith(CacheKeys.tableColumns("users"));
-    expect(redisMock.setObject).toHaveBeenCalled();
-});
-
-test("getTableColumns - Redis 缓存命中", async () => {
-    const cachedColumns = ["id", "name", "email"];
-    const redisMock = createRedisMock({
-        getObject: mock(async () => cachedColumns)
-    });
-
-    const sqlMock = {
-        unsafe: mock(async () => {
-            throw new Error("不应该执行 SQL 查询");
-        })
-    };
-
-    const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const columns = await (dbHelper as any).getTableColumns("users");
-
-    expect(columns).toEqual(cachedColumns);
-    expect(redisMock.getObject).toHaveBeenCalledWith(CacheKeys.tableColumns("users"));
-    expect(sqlMock.unsafe).not.toHaveBeenCalled(); // SQL 不应该被调用
-    expect(redisMock.setObject).not.toHaveBeenCalled(); // 不需要写缓存
-});
-
-test("getTableColumns - 表不存在错误", async () => {
-    const sqlMock = {
-        unsafe: mock(async () => []) // 返回空结果
-    };
-
-    const redisMock = createRedisMock();
-
-    const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    try {
-        await (dbHelper as any).getTableColumns("non_existent_table");
-        expect(true).toBe(false); // 不应该执行到这里
-    } catch (error: any) {
-        expect(error.message).toContain("表 non_existent_table 不存在或没有字段");
-    }
-});
-
-test("getTableColumns - SQL 语法使用反引号", async () => {
-    const mockColumns = [{ Field: "id" }];
-    let capturedSql = "";
-
-    const sqlMock = {
-        unsafe: mock(async (sql: string) => {
-            capturedSql = sql;
-            return mockColumns;
-        })
-    };
-
-    const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    await (dbHelper as any).getTableColumns("addon_admin_user");
-
-    // 验证 SQL 语法
-    expect(capturedSql).toBe("SHOW COLUMNS FROM `addon_admin_user`");
-    expect(capturedSql).not.toContain("??"); // 不应该包含占位符
-    expect(capturedSql).toContain("`"); // 应该使用反引号
-});
-
-test("getTableColumns - 表名特殊字符处理", async () => {
-    const mockColumns = [{ Field: "id" }];
-    const sqlMock = {
-        unsafe: mock(async () => mockColumns)
-    };
-
-    const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    // 测试下划线表名
-    await (dbHelper as any).getTableColumns("addon_admin_user");
-    expect(sqlMock.unsafe).toHaveBeenLastCalledWith("SHOW COLUMNS FROM `addon_admin_user`");
-
-    // 测试普通表名
-    await (dbHelper as any).getTableColumns("users");
-    expect(sqlMock.unsafe).toHaveBeenLastCalledWith("SHOW COLUMNS FROM `users`");
-});
-
-test("getTableColumns - 缓存键格式正确", async () => {
-    const mockColumns = [{ Field: "id" }];
-    const sqlMock = {
-        unsafe: mock(async () => mockColumns)
-    };
-
-    const redisMock = createRedisMock({
-        getObject: mock(async () => null),
-        setObject: mock(async (key: string, value: any, seconds: number) => {
-            // 验证缓存键格式
-            expect(key).toBe(CacheKeys.tableColumns("test_table"));
-            // 验证缓存值格式
-            expect(Array.isArray(value)).toBe(true);
-            // 验证过期时间
-            expect(seconds).toBe(3600); // 1 小时
-            return true;
-        })
-    });
-
-    const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    await (dbHelper as any).getTableColumns("test_table");
-
-    expect(redisMock.setObject).toHaveBeenCalled();
-});
-
-test("getTableColumns - 多次调用相同表（缓存效果）", async () => {
-    const mockColumns = [{ Field: "id" }, { Field: "name" }];
-    let sqlCallCount = 0;
-
-    const sqlMock = {
-        unsafe: mock(async () => {
-            sqlCallCount++;
-            return mockColumns;
-        })
-    };
-
-    const cache: Record<string, any> = {};
-    const redisMock = createRedisMock({
-        getObject: mock(async (key: string) => cache[key] || null),
-        setObject: mock(async (key: string, value: any) => {
-            cache[key] = value;
-            return true;
-        })
-    });
-
-    const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    // 第一次调用 - 应该查询数据库
-    const columns1 = await (dbHelper as any).getTableColumns("users");
-    expect(columns1).toEqual(["id", "name"]);
-    expect(sqlCallCount).toBe(1);
-
-    // 第二次调用 - 应该从缓存读取
-    const columns2 = await (dbHelper as any).getTableColumns("users");
-    expect(columns2).toEqual(["id", "name"]);
-    expect(sqlCallCount).toBe(1); // SQL 调用次数不变
-
-    // 第三次调用 - 仍然从缓存读取
-    const columns3 = await (dbHelper as any).getTableColumns("users");
-    expect(columns3).toEqual(["id", "name"]);
-    expect(sqlCallCount).toBe(1);
-});
-
-test("getTableColumns - Redis 错误处理", async () => {
-    const mockColumns = [{ Field: "id" }];
-    const sqlMock = {
-        unsafe: mock(async () => mockColumns)
-    };
-
-    const redisMock = createRedisMock({
-        getObject: mock(async () => {
-            throw new Error("Redis 连接失败");
-        })
-    });
-
-    const dbHelper = new DbHelper({ redis: redisMock as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    try {
-        await (dbHelper as any).getTableColumns("users");
-        expect(true).toBe(false); // 不应该执行到这里
-    } catch (error: any) {
-        expect(error.message).toContain("Redis 连接失败");
-    }
-});
-
-test("getTableColumns - 字段映射正确性", async () => {
-    const mockColumns = [
-        { Field: "id", Type: "int" },
-        { Field: "user_name", Type: "varchar" },
-        { Field: "created_at", Type: "timestamp" },
-        { Field: "is_active", Type: "tinyint" }
-    ];
-
-    const sqlMock = {
-        unsafe: mock(async () => mockColumns)
-    };
-
-    const dbHelper = new DbHelper({ redis: createRedisMock() as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const columns = await (dbHelper as any).getTableColumns("users");
-
-    // 验证只提取 Field 字段
-    expect(columns).toEqual(["id", "user_name", "created_at", "is_active"]);
-    expect(columns.length).toBe(4);
-    expect(columns.every((col: string) => typeof col === "string")).toBe(true);
-});

package/tests/dbHelper-execute.test.ts

@@ -1,187 +0,0 @@
-/**
- * DbHelper executeWithConn 方法单元测试
- * 测试 SQL 执行、错误处理等功能
- */
-
-import { test, expect, mock } from "bun:test";
-
-import { MySqlDialect } from "../lib/dbDialect.js";
-import { DbHelper } from "../lib/dbHelper.js";
-
-function createMockRedis() {
-    return {
-        get: mock(async () => null),
-        set: mock(async () => true),
-        del: mock(async () => 1),
-        getObject: mock(async () => null),
-        setObject: mock(async () => true),
-        genTimeID: mock(async () => 1)
-    };
-}
-
-test("executeWithConn - 正常执行（无参数）", async () => {
-    const mockResult = [{ id: 1, name: "test" }];
-    const sqlMock = {
-        unsafe: mock(async () => mockResult)
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    // 使用反射访问私有方法
-    const result = await (dbHelper as any).executeWithConn("SELECT * FROM users");
-
-    expect(result).toEqual(mockResult);
-    expect(sqlMock.unsafe).toHaveBeenCalledWith("SELECT * FROM users");
-});
-
-test("executeWithConn - 正常执行（带参数）", async () => {
-    const mockResult = [{ id: 1, email: "test@example.com" }];
-    const sqlMock = {
-        unsafe: mock(async () => mockResult)
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const result = await (dbHelper as any).executeWithConn("SELECT * FROM users WHERE id = ?", [1]);
-
-    expect(result).toEqual(mockResult);
-    expect(sqlMock.unsafe).toHaveBeenCalledWith("SELECT * FROM users WHERE id = ?", [1]);
-});
-
-test("executeWithConn - SQL 错误捕获", async () => {
-    const sqlError = new Error("You have an error in your SQL syntax");
-    const sqlMock = {
-        unsafe: mock(async () => {
-            throw sqlError;
-        })
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    try {
-        await (dbHelper as any).executeWithConn("SELECT * FROM invalid_table");
-        expect(true).toBe(false); // 不应该执行到这里
-    } catch (error: any) {
-        // 验证错误信息
-        expect(error.message).toContain("SQL执行失败");
-        expect(error.originalError).toBe(sqlError);
-        expect(error.sql).toBe("SELECT * FROM invalid_table");
-        expect(error.params).toEqual([]);
-        expect(error.duration).toBeGreaterThanOrEqual(0);
-    }
-});
-
-test("executeWithConn - 错误信息包含完整信息", async () => {
-    const sqlMock = {
-        unsafe: mock(async () => {
-            throw new Error('Syntax error near "??"');
-        })
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const testSql = "SHOW COLUMNS FROM ??";
-    const testParams = ["users"];
-
-    try {
-        await (dbHelper as any).executeWithConn(testSql, testParams);
-    } catch (error: any) {
-        // 验证增强的错误对象
-        expect(error.sql).toBe(testSql);
-        expect(error.params).toEqual(testParams);
-        expect(typeof error.duration).toBe("number");
-        expect(error.originalError.message).toBe('Syntax error near "??"');
-    }
-});
-
-test("executeWithConn - 超长 SQL 保留在错误对象中", async () => {
-    const longSql = "SELECT * FROM users WHERE " + "id = ? AND ".repeat(50) + "name = ?";
-    const sqlMock = {
-        unsafe: mock(async () => {
-            throw new Error("Test error");
-        })
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    try {
-        await (dbHelper as any).executeWithConn(longSql);
-    } catch (error: any) {
-        // SQL 完整保存在错误对象中
-        expect(error.sql).toBe(longSql);
-        expect(error.params).toEqual([]);
-    }
-});
-
-test("executeWithConn - 慢查询检测（>1000ms）", async () => {
-    const mockResult = [{ id: 1 }];
-    const sqlMock = {
-        unsafe: mock(async () => {
-            // 模拟慢查询
-            await new Promise((resolve) => setTimeout(resolve, 1100));
-            return mockResult;
-        })
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const result = await (dbHelper as any).executeWithConn("SELECT SLEEP(1)");
-
-    // 功能仍正常返回结果
-    expect(result).toEqual(mockResult);
-});
-
-test("executeWithConn - 数据库未连接错误", async () => {
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: null, dialect: new MySqlDialect() }); // 没有 sql 实例
-
-    try {
-        await (dbHelper as any).executeWithConn("SELECT * FROM users");
-        expect(true).toBe(false); // 不应该执行到这里
-    } catch (error: any) {
-        expect(error.message).toBe("数据库连接未初始化");
-    }
-});
-
-test("executeWithConn - 空参数数组", async () => {
-    const mockResult = [{ count: 10 }];
-    const sqlMock = {
-        unsafe: mock(async () => mockResult)
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const result = await (dbHelper as any).executeWithConn("SELECT COUNT(*) as count FROM users", []);
-
-    expect(result).toEqual(mockResult);
-    // 空数组应该走 else 分支（不传参数）
-    expect(sqlMock.unsafe).toHaveBeenCalledWith("SELECT COUNT(*) as count FROM users");
-});
-
-test("executeWithConn - 复杂参数处理", async () => {
-    const sqlMock = {
-        unsafe: mock(async () => {
-            throw new Error("Test error");
-        })
-    };
-
-    const redis = createMockRedis();
-    const dbHelper = new DbHelper({ redis: redis as any, sql: sqlMock, dialect: new MySqlDialect() });
-
-    const complexParams = [1, "test", { nested: "object" }, [1, 2, 3], null, undefined];
-
-    try {
-        await (dbHelper as any).executeWithConn("SELECT ?", complexParams);
-    } catch (error: any) {
-        // 验证参数被正确保存
-        expect(error.params).toEqual(complexParams);
-        expect(error.sql).toBe("SELECT ?");
-    }
-});

package/tests/dbHelper-joins.test.ts

@@ -1,221 +0,0 @@
-/**
- * DbHelper JOIN 功能测试
- * 测试多表联查相关功能（推荐使用表别名）
- */
-
-import { describe, test, expect } from "bun:test";
-
-import { DbUtils } from "../lib/dbUtils.js";
-
-describe("DbUtils tableRef - normalizeTableRef/getJoinMainQualifier", () => {
-    test("普通表名转下划线（无 alias）", () => {
-        expect(DbUtils.normalizeTableRef("userProfile")).toBe("user_profile");
-        expect(DbUtils.normalizeTableRef("orderDetail")).toBe("order_detail");
-        expect(DbUtils.normalizeTableRef("user")).toBe("user");
-        expect(DbUtils.normalizeTableRef("order")).toBe("order");
-    });
-
-    test("带 alias 的 tableRef：只转换 schema/table，不改 alias", () => {
-        expect(DbUtils.normalizeTableRef("UserProfile up")).toBe("user_profile up");
-        expect(DbUtils.normalizeTableRef("myDb.UserProfile up")).toBe("my_db.user_profile up");
-    });
-
-    test("JOIN 主限定符：优先 alias", () => {
-        expect(DbUtils.getJoinMainQualifier("order o")).toBe("o");
-        expect(DbUtils.getJoinMainQualifier("userProfile")).toBe("user_profile");
-    });
-});
-
-describe("DbHelper JOIN - processJoinField", () => {
-    test("带表名的字段", () => {
-        expect(DbUtils.processJoinField("o.userId")).toBe("o.user_id");
-        expect(DbUtils.processJoinField("u.userName")).toBe("u.user_name");
-        expect(DbUtils.processJoinField("o.createdAt")).toBe("o.created_at");
-    });
-
-    test("表/别名部分保持原样（JOIN 场景点号前通常是别名）", () => {
-        expect(DbUtils.processJoinField("orderDetail.productId")).toBe("orderDetail.product_id");
-        expect(DbUtils.processJoinField("userProfile.avatarUrl")).toBe("userProfile.avatar_url");
-    });
-
-    test("普通字段（无表名）", () => {
-        expect(DbUtils.processJoinField("userName")).toBe("user_name");
-        expect(DbUtils.processJoinField("createdAt")).toBe("created_at");
-    });
-
-    test("带 AS 别名的字段", () => {
-        expect(DbUtils.processJoinField("o.totalAmount AS total")).toBe("o.total_amount AS total");
-        expect(DbUtils.processJoinField("u.userName AS name")).toBe("u.user_name AS name");
-        expect(DbUtils.processJoinField("p.name AS productName")).toBe("p.name AS productName");
-    });
-
-    test("函数字段保持原样", () => {
-        expect(DbUtils.processJoinField("COUNT(*)")).toBe("COUNT(*)");
-        expect(DbUtils.processJoinField("SUM(o.amount)")).toBe("SUM(o.amount)");
-    });
-
-    test("星号保持原样", () => {
-        expect(DbUtils.processJoinField("*")).toBe("*");
-    });
-
-    test("已转义字段保持原样", () => {
-        expect(DbUtils.processJoinField("`order`")).toBe("`order`");
-    });
-});
-
-describe("DbHelper JOIN - processJoinWhereKey", () => {
-    test("带表名的字段名", () => {
-        expect(DbUtils.processJoinWhereKey("o.userId")).toBe("o.user_id");
-        expect(DbUtils.processJoinWhereKey("u.userName")).toBe("u.user_name");
-    });
-
-    test("带表名和操作符的字段名", () => {
-        expect(DbUtils.processJoinWhereKey("o.createdAt$gt")).toBe("o.created_at$gt");
-        expect(DbUtils.processJoinWhereKey("u.status$in")).toBe("u.status$in");
-        expect(DbUtils.processJoinWhereKey("o.amount$gte")).toBe("o.amount$gte");
-    });
-
-    test("普通字段带操作符", () => {
-        expect(DbUtils.processJoinWhereKey("createdAt$gt")).toBe("created_at$gt");
-        expect(DbUtils.processJoinWhereKey("userId$ne")).toBe("user_id$ne");
-    });
-
-    test("逻辑操作符保持原样", () => {
-        expect(DbUtils.processJoinWhereKey("$or")).toBe("$or");
-        expect(DbUtils.processJoinWhereKey("$and")).toBe("$and");
-    });
-});
-
-describe("DbHelper JOIN - processJoinWhere", () => {
-    test("简单条件", () => {
-        const where = { "o.userId": 1, "o.state": 1 };
-        const result = DbUtils.processJoinWhere(where);
-        expect(result).toEqual({ "o.user_id": 1, "o.state": 1 });
-    });
-
-    test("带操作符的条件", () => {
-        const where = { "o.createdAt$gt": 1000, "u.state$ne": 0 };
-        const result = DbUtils.processJoinWhere(where);
-        expect(result).toEqual({ "o.created_at$gt": 1000, "u.state$ne": 0 });
-    });
-
-    test("$or 条件", () => {
-        const where = {
-            $or: [{ "u.userName$like": "%test%" }, { "u.email$like": "%test%" }]
-        };
-        const result = DbUtils.processJoinWhere(where);
-        expect(result).toEqual({
-            $or: [{ "u.user_name$like": "%test%" }, { "u.email$like": "%test%" }]
-        });
-    });
-
-    test("复杂嵌套条件", () => {
-        const where = {
-            "o.state": 1,
-            "u.state": 1,
-            $or: [{ "u.userName$like": "%test%" }, { "p.name$like": "%test%" }],
-            "o.createdAt$gte": 1000
-        };
-        const result = DbUtils.processJoinWhere(where);
-        expect(result).toEqual({
-            "o.state": 1,
-            "u.state": 1,
-            $or: [{ "u.user_name$like": "%test%" }, { "p.name$like": "%test%" }],
-            "o.created_at$gte": 1000
-        });
-    });
-});
-
-describe("DbHelper JOIN - processJoinOrderBy", () => {
-    test("带表名的排序", () => {
-        const orderBy = ["o.createdAt#DESC", "u.userName#ASC"];
-        const result = DbUtils.processJoinOrderBy(orderBy);
-        expect(result).toEqual(["o.created_at#DESC", "u.user_name#ASC"]);
-    });
-
-    test("普通排序", () => {
-        const orderBy = ["createdAt#DESC"];
-        const result = DbUtils.processJoinOrderBy(orderBy);
-        expect(result).toEqual(["created_at#DESC"]);
-    });
-
-    test("无排序方向的保持原样", () => {
-        const orderBy = ["id"];
-        const result = DbUtils.processJoinOrderBy(orderBy);
-        expect(result).toEqual(["id"]);
-    });
-});
-
-describe("DbHelper JOIN - JoinOption 类型验证", () => {
-    test("LEFT JOIN（默认）", () => {
-        const join = { table: "user", on: "order.user_id = user.id" };
-        expect(join.type).toBeUndefined();
-        expect(join.table).toBe("user");
-        expect(join.on).toBe("order.user_id = user.id");
-    });
-
-    test("INNER JOIN", () => {
-        const join = { type: "inner" as const, table: "product", on: "order.product_id = product.id" };
-        expect(join.type).toBe("inner");
-    });
-
-    test("RIGHT JOIN", () => {
-        const join = {
-            type: "right" as const,
-            table: "category",
-            on: "product.category_id = category.id"
-        };
-        expect(join.type).toBe("right");
-    });
-});
-
-describe("DbHelper JOIN - 完整场景模拟", () => {
-    test("订单列表联查参数处理", () => {
-        // 模拟输入
-        const options = {
-            table: "order o",
-            joins: [
-                { table: "user u", on: "o.user_id = u.id" },
-                { table: "product p", on: "o.product_id = p.id" }
-            ],
-            fields: ["o.id", "o.totalAmount", "u.userName", "p.name AS productName"],
-            where: {
-                "o.state": 1,
-                "u.state": 1,
-                "o.createdAt$gte": 1701388800000
-            },
-            orderBy: ["o.createdAt#DESC"]
-        };
-
-        // 处理表名（tableRef 规范化）
-        const processedTable = DbUtils.normalizeTableRef(options.table);
-        expect(processedTable).toBe("order o");
-
-        // 处理字段
-        const processedFields = options.fields.map((f) => DbUtils.processJoinField(f));
-        expect(processedFields).toEqual(["o.id", "o.total_amount", "u.user_name", "p.name AS productName"]);
-
-        // 处理 where
-        const processedWhere = DbUtils.processJoinWhere(options.where);
-        expect(processedWhere).toEqual({
-            "o.state": 1,
-            "u.state": 1,
-            "o.created_at$gte": 1701388800000
-        });
-
-        // 处理 orderBy
-        const processedOrderBy = DbUtils.processJoinOrderBy(options.orderBy);
-        expect(processedOrderBy).toEqual(["o.created_at#DESC"]);
-
-        // 处理 joins
-        const processedJoins = options.joins.map((j) => ({
-            type: (j as any).type || "left",
-            table: DbUtils.normalizeTableRef(j.table),
-            on: j.on
-        }));
-        expect(processedJoins).toEqual([
-            { type: "left", table: "user u", on: "o.user_id = u.id" },
-            { type: "left", table: "product p", on: "o.product_id = p.id" }
-        ]);
-    });
-});