befly 3.9.38 → 3.9.40

package/tests/sqlBuilder.test.ts

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

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