befly 3.9.38 → 3.9.40

package/tests/dbHelper-joins.test.ts

@@ -3,8 +3,9 @@
  * 测试多表联查相关功能（不支持表别名）
  */
 
-import { describe, test, expect } from 'bun:test';
-import { snakeCase } from 'es-toolkit/string';
+import { describe, test, expect } from "bun:test";
+
+import { snakeCase } from "es-toolkit/string";
 
 // ============================================
 // 辅助函数单元测试（模拟 DbHelper 私有方法）
@@ -21,17 +22,17 @@ function processTableName(table: string): string {
  * 处理联查字段（支持表名.字段名格式）
  */
 function processJoinField(field: string): string {
-    if (field.includes('(') || field === '*' || field.startsWith('`')) {
+    if (field.includes("(") || field === "*" || field.startsWith("`")) {
         return field;
     }
 
-    if (field.toUpperCase().includes(' AS ')) {
+    if (field.toUpperCase().includes(" AS ")) {
         const [fieldPart, aliasPart] = field.split(/\s+AS\s+/i);
         return `${processJoinField(fieldPart.trim())} AS ${aliasPart.trim()}`;
     }
 
-    if (field.includes('.')) {
-        const [tableName, fieldName] = field.split('.');
+    if (field.includes(".")) {
+        const [tableName, fieldName] = field.split(".");
         return `${snakeCase(tableName)}.${snakeCase(fieldName)}`;
     }
 
@@ -42,24 +43,24 @@ function processJoinField(field: string): string {
  * 处理联查 where 条件键名
  */
 function processJoinWhereKey(key: string): string {
-    if (key === '$or' || key === '$and') {
+    if (key === "$or" || key === "$and") {
         return key;
     }
 
-    if (key.includes('$')) {
-        const lastDollarIndex = key.lastIndexOf('$');
+    if (key.includes("$")) {
+        const lastDollarIndex = key.lastIndexOf("$");
         const fieldPart = key.substring(0, lastDollarIndex);
         const operator = key.substring(lastDollarIndex);
 
-        if (fieldPart.includes('.')) {
-            const [tableName, fieldName] = fieldPart.split('.');
+        if (fieldPart.includes(".")) {
+            const [tableName, fieldName] = fieldPart.split(".");
             return `${snakeCase(tableName)}.${snakeCase(fieldName)}${operator}`;
         }
         return `${snakeCase(fieldPart)}${operator}`;
     }
 
-    if (key.includes('.')) {
-        const [tableName, fieldName] = key.split('.');
+    if (key.includes(".")) {
+        const [tableName, fieldName] = key.split(".");
         return `${snakeCase(tableName)}.${snakeCase(fieldName)}`;
     }
 
@@ -70,7 +71,7 @@ function processJoinWhereKey(key: string): string {
  * 递归处理联查 where 条件
  */
 function processJoinWhere(where: any): any {
-    if (!where || typeof where !== 'object') return where;
+    if (!where || typeof where !== "object") return where;
 
     if (Array.isArray(where)) {
         return where.map((item) => processJoinWhere(item));
@@ -80,9 +81,9 @@ function processJoinWhere(where: any): any {
     for (const [key, value] of Object.entries(where)) {
         const newKey = processJoinWhereKey(key);
 
-        if (key === '$or' || key === '$and') {
+        if (key === "$or" || key === "$and") {
             result[newKey] = (value as any[]).map((item) => processJoinWhere(item));
-        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
             result[newKey] = processJoinWhere(value);
         } else {
             result[newKey] = value;
@@ -97,8 +98,8 @@ function processJoinWhere(where: any): any {
 function processJoinOrderBy(orderBy: string[]): string[] {
     if (!orderBy || !Array.isArray(orderBy)) return orderBy;
     return orderBy.map((item) => {
-        if (typeof item !== 'string' || !item.includes('#')) return item;
-        const [field, direction] = item.split('#');
+        if (typeof item !== "string" || !item.includes("#")) return item;
+        const [field, direction] = item.split("#");
         return `${processJoinField(field.trim())}#${direction.trim()}`;
     });
 }
@@ -107,201 +108,205 @@ function processJoinOrderBy(orderBy: string[]): string[] {
 // 测试用例
 // ============================================
 
-describe('DbHelper JOIN - processTableName', () => {
-    test('普通表名转下划线', () => {
-        expect(processTableName('userProfile')).toBe('user_profile');
-        expect(processTableName('orderDetail')).toBe('order_detail');
-        expect(processTableName('user')).toBe('user');
-        expect(processTableName('order')).toBe('order');
+describe("DbHelper JOIN - processTableName", () => {
+    test("普通表名转下划线", () => {
+        expect(processTableName("userProfile")).toBe("user_profile");
+        expect(processTableName("orderDetail")).toBe("order_detail");
+        expect(processTableName("user")).toBe("user");
+        expect(processTableName("order")).toBe("order");
     });
 });
 
-describe('DbHelper JOIN - processJoinField', () => {
-    test('带表名的字段', () => {
-        expect(processJoinField('order.userId')).toBe('order.user_id');
-        expect(processJoinField('user.userName')).toBe('user.user_name');
-        expect(processJoinField('order.createdAt')).toBe('order.created_at');
+describe("DbHelper JOIN - processJoinField", () => {
+    test("带表名的字段", () => {
+        expect(processJoinField("order.userId")).toBe("order.user_id");
+        expect(processJoinField("user.userName")).toBe("user.user_name");
+        expect(processJoinField("order.createdAt")).toBe("order.created_at");
     });
 
-    test('表名也转下划线', () => {
-        expect(processJoinField('orderDetail.productId')).toBe('order_detail.product_id');
-        expect(processJoinField('userProfile.avatarUrl')).toBe('user_profile.avatar_url');
+    test("表名也转下划线", () => {
+        expect(processJoinField("orderDetail.productId")).toBe("order_detail.product_id");
+        expect(processJoinField("userProfile.avatarUrl")).toBe("user_profile.avatar_url");
     });
 
-    test('普通字段（无表名）', () => {
-        expect(processJoinField('userName')).toBe('user_name');
-        expect(processJoinField('createdAt')).toBe('created_at');
+    test("普通字段（无表名）", () => {
+        expect(processJoinField("userName")).toBe("user_name");
+        expect(processJoinField("createdAt")).toBe("created_at");
     });
 
-    test('带 AS 别名的字段', () => {
-        expect(processJoinField('order.totalAmount AS total')).toBe('order.total_amount AS total');
-        expect(processJoinField('user.userName AS name')).toBe('user.user_name AS name');
-        expect(processJoinField('product.name AS productName')).toBe('product.name AS productName');
+    test("带 AS 别名的字段", () => {
+        expect(processJoinField("order.totalAmount AS total")).toBe("order.total_amount AS total");
+        expect(processJoinField("user.userName AS name")).toBe("user.user_name AS name");
+        expect(processJoinField("product.name AS productName")).toBe("product.name AS productName");
     });
 
-    test('函数字段保持原样', () => {
-        expect(processJoinField('COUNT(*)')).toBe('COUNT(*)');
-        expect(processJoinField('SUM(order.amount)')).toBe('SUM(order.amount)');
+    test("函数字段保持原样", () => {
+        expect(processJoinField("COUNT(*)")).toBe("COUNT(*)");
+        expect(processJoinField("SUM(order.amount)")).toBe("SUM(order.amount)");
     });
 
-    test('星号保持原样', () => {
-        expect(processJoinField('*')).toBe('*');
+    test("星号保持原样", () => {
+        expect(processJoinField("*")).toBe("*");
     });
 
-    test('已转义字段保持原样', () => {
-        expect(processJoinField('`order`')).toBe('`order`');
+    test("已转义字段保持原样", () => {
+        expect(processJoinField("`order`")).toBe("`order`");
     });
 });
 
-describe('DbHelper JOIN - processJoinWhereKey', () => {
-    test('带表名的字段名', () => {
-        expect(processJoinWhereKey('order.userId')).toBe('order.user_id');
-        expect(processJoinWhereKey('user.userName')).toBe('user.user_name');
+describe("DbHelper JOIN - processJoinWhereKey", () => {
+    test("带表名的字段名", () => {
+        expect(processJoinWhereKey("order.userId")).toBe("order.user_id");
+        expect(processJoinWhereKey("user.userName")).toBe("user.user_name");
     });
 
-    test('带表名和操作符的字段名', () => {
-        expect(processJoinWhereKey('order.createdAt$gt')).toBe('order.created_at$gt');
-        expect(processJoinWhereKey('user.status$in')).toBe('user.status$in');
-        expect(processJoinWhereKey('order.amount$gte')).toBe('order.amount$gte');
+    test("带表名和操作符的字段名", () => {
+        expect(processJoinWhereKey("order.createdAt$gt")).toBe("order.created_at$gt");
+        expect(processJoinWhereKey("user.status$in")).toBe("user.status$in");
+        expect(processJoinWhereKey("order.amount$gte")).toBe("order.amount$gte");
     });
 
-    test('普通字段带操作符', () => {
-        expect(processJoinWhereKey('createdAt$gt')).toBe('created_at$gt');
-        expect(processJoinWhereKey('userId$ne')).toBe('user_id$ne');
+    test("普通字段带操作符", () => {
+        expect(processJoinWhereKey("createdAt$gt")).toBe("created_at$gt");
+        expect(processJoinWhereKey("userId$ne")).toBe("user_id$ne");
     });
 
-    test('逻辑操作符保持原样', () => {
-        expect(processJoinWhereKey('$or')).toBe('$or');
-        expect(processJoinWhereKey('$and')).toBe('$and');
+    test("逻辑操作符保持原样", () => {
+        expect(processJoinWhereKey("$or")).toBe("$or");
+        expect(processJoinWhereKey("$and")).toBe("$and");
     });
 });
 
-describe('DbHelper JOIN - processJoinWhere', () => {
-    test('简单条件', () => {
-        const where = { 'order.userId': 1, 'order.state': 1 };
+describe("DbHelper JOIN - processJoinWhere", () => {
+    test("简单条件", () => {
+        const where = { "order.userId": 1, "order.state": 1 };
         const result = processJoinWhere(where);
-        expect(result).toEqual({ 'order.user_id': 1, 'order.state': 1 });
+        expect(result).toEqual({ "order.user_id": 1, "order.state": 1 });
     });
 
-    test('带操作符的条件', () => {
-        const where = { 'order.createdAt$gt': 1000, 'user.state$ne': 0 };
+    test("带操作符的条件", () => {
+        const where = { "order.createdAt$gt": 1000, "user.state$ne": 0 };
         const result = processJoinWhere(where);
-        expect(result).toEqual({ 'order.created_at$gt': 1000, 'user.state$ne': 0 });
+        expect(result).toEqual({ "order.created_at$gt": 1000, "user.state$ne": 0 });
     });
 
-    test('$or 条件', () => {
+    test("$or 条件", () => {
         const where = {
-            $or: [{ 'user.userName$like': '%test%' }, { 'user.email$like': '%test%' }]
+            $or: [{ "user.userName$like": "%test%" }, { "user.email$like": "%test%" }]
         };
         const result = processJoinWhere(where);
         expect(result).toEqual({
-            $or: [{ 'user.user_name$like': '%test%' }, { 'user.email$like': '%test%' }]
+            $or: [{ "user.user_name$like": "%test%" }, { "user.email$like": "%test%" }]
         });
     });
 
-    test('复杂嵌套条件', () => {
+    test("复杂嵌套条件", () => {
         const where = {
-            'order.state': 1,
-            'user.state': 1,
-            $or: [{ 'user.userName$like': '%test%' }, { 'product.name$like': '%test%' }],
-            'order.createdAt$gte': 1000
+            "order.state": 1,
+            "user.state": 1,
+            $or: [{ "user.userName$like": "%test%" }, { "product.name$like": "%test%" }],
+            "order.createdAt$gte": 1000
         };
         const result = processJoinWhere(where);
         expect(result).toEqual({
-            'order.state': 1,
-            'user.state': 1,
-            $or: [{ 'user.user_name$like': '%test%' }, { 'product.name$like': '%test%' }],
-            'order.created_at$gte': 1000
+            "order.state": 1,
+            "user.state": 1,
+            $or: [{ "user.user_name$like": "%test%" }, { "product.name$like": "%test%" }],
+            "order.created_at$gte": 1000
         });
     });
 });
 
-describe('DbHelper JOIN - processJoinOrderBy', () => {
-    test('带表名的排序', () => {
-        const orderBy = ['order.createdAt#DESC', 'user.userName#ASC'];
+describe("DbHelper JOIN - processJoinOrderBy", () => {
+    test("带表名的排序", () => {
+        const orderBy = ["order.createdAt#DESC", "user.userName#ASC"];
         const result = processJoinOrderBy(orderBy);
-        expect(result).toEqual(['order.created_at#DESC', 'user.user_name#ASC']);
+        expect(result).toEqual(["order.created_at#DESC", "user.user_name#ASC"]);
     });
 
-    test('普通排序', () => {
-        const orderBy = ['createdAt#DESC'];
+    test("普通排序", () => {
+        const orderBy = ["createdAt#DESC"];
         const result = processJoinOrderBy(orderBy);
-        expect(result).toEqual(['created_at#DESC']);
+        expect(result).toEqual(["created_at#DESC"]);
     });
 
-    test('无排序方向的保持原样', () => {
-        const orderBy = ['id'];
+    test("无排序方向的保持原样", () => {
+        const orderBy = ["id"];
         const result = processJoinOrderBy(orderBy);
-        expect(result).toEqual(['id']);
+        expect(result).toEqual(["id"]);
     });
 });
 
-describe('DbHelper JOIN - JoinOption 类型验证', () => {
-    test('LEFT JOIN（默认）', () => {
-        const join = { table: 'user', on: 'order.user_id = user.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');
+        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("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');
+    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('订单列表联查参数处理', () => {
+describe("DbHelper JOIN - 完整场景模拟", () => {
+    test("订单列表联查参数处理", () => {
         // 模拟输入
         const options = {
-            table: 'order',
+            table: "order",
             joins: [
-                { table: 'user', on: 'order.userId = user.id' },
-                { table: 'product', on: 'order.productId = product.id' }
+                { table: "user", on: "order.userId = user.id" },
+                { table: "product", on: "order.productId = product.id" }
             ],
-            fields: ['order.id', 'order.totalAmount', 'user.userName', 'product.name AS productName'],
+            fields: ["order.id", "order.totalAmount", "user.userName", "product.name AS productName"],
             where: {
-                'order.state': 1,
-                'user.state': 1,
-                'order.createdAt$gte': 1701388800000
+                "order.state": 1,
+                "user.state": 1,
+                "order.createdAt$gte": 1701388800000
             },
-            orderBy: ['order.createdAt#DESC']
+            orderBy: ["order.createdAt#DESC"]
         };
 
         // 处理表名
         const processedTable = processTableName(options.table);
-        expect(processedTable).toBe('order');
+        expect(processedTable).toBe("order");
 
         // 处理字段
         const processedFields = options.fields.map((f) => processJoinField(f));
-        expect(processedFields).toEqual(['order.id', 'order.total_amount', 'user.user_name', 'product.name AS productName']);
+        expect(processedFields).toEqual(["order.id", "order.total_amount", "user.user_name", "product.name AS productName"]);
 
         // 处理 where
         const processedWhere = processJoinWhere(options.where);
         expect(processedWhere).toEqual({
-            'order.state': 1,
-            'user.state': 1,
-            'order.created_at$gte': 1701388800000
+            "order.state": 1,
+            "user.state": 1,
+            "order.created_at$gte": 1701388800000
         });
 
         // 处理 orderBy
         const processedOrderBy = processJoinOrderBy(options.orderBy);
-        expect(processedOrderBy).toEqual(['order.created_at#DESC']);
+        expect(processedOrderBy).toEqual(["order.created_at#DESC"]);
 
         // 处理 joins
         const processedJoins = options.joins.map((j) => ({
-            type: (j as any).type || 'left',
+            type: (j as any).type || "left",
             table: processTableName(j.table),
             on: j.on
         }));
         expect(processedJoins).toEqual([
-            { type: 'left', table: 'user', on: 'order.userId = user.id' },
-            { type: 'left', table: 'product', on: 'order.productId = product.id' }
+            { type: "left", table: "user", on: "order.userId = user.id" },
+            { type: "left", table: "product", on: "order.productId = product.id" }
         ]);
     });
 });

package/tests/fields-redis-cache.test.ts

@@ -2,9 +2,11 @@
  * 验证 Redis 缓存的字段查询功能
  */
 
-import { RedisKeys, RedisTTL } from 'befly-shared/redisKeys';
+import { CacheKeys } from "../lib/cacheKeys.js";
 
-console.log('\n========== Redis 缓存验证 ==========\n');
+const TABLE_COLUMNS_CACHE_TTL_SECONDS = 3600;
+
+console.log("\n========== Redis 缓存验证 ==========\n");
 
 // 模拟 Redis 缓存逻辑
 class MockRedis {
@@ -34,13 +36,13 @@ async function queryDatabase(table: string): Promise<string[]> {
     console.log(`🔍 查询数据库表结构: ${table}`);
     // 模拟数据库延迟
     await new Promise((resolve) => setTimeout(resolve, 3));
-    return ['id', 'name', 'email', 'password', 'salt', 'created_at'];
+    return ["id", "name", "email", "password", "salt", "created_at"];
 }
 
 // 模拟 getTableColumns 方法
 async function getTableColumns(redis: MockRedis, table: string): Promise<string[]> {
     // 1. 先查 Redis 缓存
-    const cacheKey = RedisKeys.tableColumns(table);
+    const cacheKey = CacheKeys.tableColumns(table);
     let columns = await redis.getObject<string[]>(cacheKey);
 
     if (columns && columns.length > 0) {
@@ -51,7 +53,7 @@ async function getTableColumns(redis: MockRedis, table: string): Promise<string[
     columns = await queryDatabase(table);
 
     // 3. 写入 Redis 缓存
-    await redis.setObject(cacheKey, columns, RedisTTL.tableColumns);
+    await redis.setObject(cacheKey, columns, TABLE_COLUMNS_CACHE_TTL_SECONDS);
 
     return columns;
 }
@@ -59,63 +61,63 @@ async function getTableColumns(redis: MockRedis, table: string): Promise<string[
 async function test() {
     const redis = new MockRedis();
 
-    console.log('【场景1】单进程多次查询\n');
+    console.log("【场景1】单进程多次查询\n");
 
     // 第1次查询（缓存未命中）
-    console.log('--- 第1次查询 user 表 ---');
+    console.log("--- 第1次查询 user 表 ---");
     const start1 = Date.now();
-    const columns1 = await getTableColumns(redis, 'user');
+    const columns1 = await getTableColumns(redis, "user");
     const time1 = Date.now() - start1;
-    console.log(`结果: ${columns1.join(', ')}`);
+    console.log(`结果: ${columns1.join(", ")}`);
     console.log(`耗时: ${time1}ms\n`);
 
     // 第2次查询（缓存命中）
-    console.log('--- 第2次查询 user 表 ---');
+    console.log("--- 第2次查询 user 表 ---");
     const start2 = Date.now();
-    const columns2 = await getTableColumns(redis, 'user');
+    const columns2 = await getTableColumns(redis, "user");
     const time2 = Date.now() - start2;
-    console.log(`结果: ${columns2.join(', ')}`);
+    console.log(`结果: ${columns2.join(", ")}`);
     console.log(`耗时: ${time2}ms\n`);
 
     // 第3次查询（缓存命中）
-    console.log('--- 第3次查询 user 表 ---');
+    console.log("--- 第3次查询 user 表 ---");
     const start3 = Date.now();
-    const columns3 = await getTableColumns(redis, 'user');
+    const columns3 = await getTableColumns(redis, "user");
     const time3 = Date.now() - start3;
-    console.log(`结果: ${columns3.join(', ')}`);
+    console.log(`结果: ${columns3.join(", ")}`);
     console.log(`耗时: ${time3}ms\n`);
 
-    console.log('【场景2】模拟 PM2 cluster（多进程共享 Redis）\n');
+    console.log("【场景2】模拟 PM2 cluster（多进程共享 Redis）\n");
 
     // 模拟 Worker 1 查询
-    console.log('--- Worker 1 查询 article 表 ---');
+    console.log("--- Worker 1 查询 article 表 ---");
     const worker1Start = Date.now();
-    const worker1Columns = await getTableColumns(redis, 'article');
+    const worker1Columns = await getTableColumns(redis, "article");
     const worker1Time = Date.now() - worker1Start;
-    console.log(`结果: ${worker1Columns.join(', ')}`);
+    console.log(`结果: ${worker1Columns.join(", ")}`);
     console.log(`耗时: ${worker1Time}ms\n`);
 
     // 模拟 Worker 2 查询（共享 Redis 缓存）
-    console.log('--- Worker 2 查询 article 表 ---');
+    console.log("--- Worker 2 查询 article 表 ---");
     const worker2Start = Date.now();
-    const worker2Columns = await getTableColumns(redis, 'article');
+    const worker2Columns = await getTableColumns(redis, "article");
     const worker2Time = Date.now() - worker2Start;
-    console.log(`结果: ${worker2Columns.join(', ')}`);
+    console.log(`结果: ${worker2Columns.join(", ")}`);
     console.log(`耗时: ${worker2Time}ms`);
     console.log(`✅ Worker 2 直接使用 Worker 1 的缓存，无需再查数据库\n`);
 
     // 模拟 Worker 3 查询（共享 Redis 缓存）
-    console.log('--- Worker 3 查询 article 表 ---');
+    console.log("--- Worker 3 查询 article 表 ---");
     const worker3Start = Date.now();
-    const worker3Columns = await getTableColumns(redis, 'article');
+    const worker3Columns = await getTableColumns(redis, "article");
     const worker3Time = Date.now() - worker3Start;
-    console.log(`结果: ${worker3Columns.join(', ')}`);
+    console.log(`结果: ${worker3Columns.join(", ")}`);
     console.log(`耗时: ${worker3Time}ms`);
     console.log(`✅ Worker 3 直接使用 Worker 1 的缓存，无需再查数据库\n`);
 
-    console.log('========== 验证完成 ==========\n');
+    console.log("========== 验证完成 ==========\n");
 
-    console.log('📊 性能总结:');
+    console.log("📊 性能总结:");
     console.log(`- 首次查询（数据库）: ${time1}ms`);
     console.log(`- 后续查询（Redis）: ${time2}ms`);
     console.log(`- 性能提升: ${(time1 / time2).toFixed(1)}x`);