befly 3.8.29 → 3.8.31

package/lib/connect.ts

@@ -1,23 +1,22 @@
 /**
  * 数据库连接管理器
  * 统一管理 SQL 和 Redis 连接
+ * 配置从 beflyConfig 全局对象获取
  */
 
 import { SQL, RedisClient } from 'bun';
+
+import { beflyConfig } from '../befly.config.js';
 import { Logger } from './logger.js';
-import { DbHelper } from './dbHelper.js';
-import { RedisHelper } from './redisHelper.js';
-import type { BeflyContext, BeflyOptions, DatabaseConfig, RedisConfig } from '../types/befly.js';
-import type { SqlClientOptions } from '../types/database.js';
 
 /**
  * 数据库连接管理器
  * 使用静态方法管理全局单例连接
+ * 所有配置从 beflyConfig 自动获取
  */
 export class Connect {
     private static sqlClient: SQL | null = null;
     private static redisClient: RedisClient | null = null;
-    private static dbHelper: DbHelper | null = null;
 
     // 连接统计信息
     private static sqlConnectedAt: number | null = null;
@@ -30,10 +29,12 @@ export class Connect {
 
     /**
      * 连接 SQL 数据库
-     * @param config - 数据库配置
+     * 配置从 beflyConfig.db 获取
      * @returns SQL 客户端实例
      */
-    static async connectSql(config: DatabaseConfig): Promise<SQL> {
+    static async connectSql(): Promise<SQL> {
+        const config = beflyConfig.db || {};
+
         // 构建数据库连接字符串
         const type = config.type || 'mysql';
         const host = config.host || '127.0.0.1';
@@ -95,7 +96,7 @@ export class Connect {
             this.sqlPoolMax = config.poolMax ?? 1;
             return sql;
         } catch (error: any) {
-            Logger.error('[Connect] SQL 连接失败', error);
+            Logger.error({ err: error }, '[Connect] SQL 连接失败');
             try {
                 await sql?.close();
             } catch (cleanupError) {}
@@ -112,15 +113,11 @@ export class Connect {
             try {
                 await this.sqlClient.close();
             } catch (error: any) {
-                Logger.error('[Connect] 关闭 SQL 连接时出错', error);
+                Logger.error({ err: error }, '[Connect] 关闭 SQL 连接时出错');
             }
             this.sqlClient = null;
             this.sqlConnectedAt = null;
         }
-
-        if (this.dbHelper) {
-            this.dbHelper = null;
-        }
     }
 
     /**
@@ -134,37 +131,18 @@ export class Connect {
         return this.sqlClient;
     }
 
-    /**
-     * 获取 DbHelper 实例
-     * @throws 如果未连接则抛出错误
-     */
-    static getDbHelper(befly?: BeflyContext): DbHelper {
-        if (!this.dbHelper) {
-            if (!this.sqlClient) {
-                throw new Error('SQL 客户端未连接，请先调用 Connect.connectSql()');
-            }
-            // 创建临时 befly 上下文（仅用于 DbHelper）
-            const ctx = befly || {
-                redis: new RedisHelper(),
-                db: null as any,
-                tool: null as any,
-                logger: null as any
-            };
-            this.dbHelper = new DbHelper(ctx, this.sqlClient);
-        }
-        return this.dbHelper;
-    }
-
     // ========================================
     // Redis 连接管理
     // ========================================
 
     /**
      * 连接 Redis
-     * @param config - Redis 配置
+     * 配置从 beflyConfig.redis 获取
      * @returns Redis 客户端实例
      */
-    static async connectRedis(config: RedisConfig = {}): Promise<RedisClient> {
+    static async connectRedis(): Promise<RedisClient> {
+        const config = beflyConfig.redis || {};
+
         try {
             // 构建 Redis URL
             const host = config.host || '127.0.0.1';
@@ -197,7 +175,7 @@ export class Connect {
             this.redisConnectedAt = Date.now();
             return redis;
         } catch (error: any) {
-            Logger.error('[Connect] Redis 连接失败', error);
+            Logger.error({ err: error }, '[Connect] Redis 连接失败');
             throw new Error(`Redis 连接失败: ${error.message}`);
         }
     }
@@ -211,7 +189,7 @@ export class Connect {
                 this.redisClient.close();
                 this.redisConnectedAt = null;
             } catch (error: any) {
-                Logger.error('[Connect] 关闭 Redis 连接时出错', error);
+                Logger.error({ err: error }, '[Connect] 关闭 Redis 连接时出错');
             }
             this.redisClient = null;
         }
@@ -234,23 +212,17 @@ export class Connect {
 
     /**
      * 连接所有数据库（SQL + Redis）
-     * @param config - Befly 配置对象（可选）
-     * @param options - 连接选项
+     * 配置从 beflyConfig 自动获取
      */
-    static async connect(config?: BeflyOptions, options?: { sql?: SqlClientOptions; redis?: boolean }): Promise<void> {
+    static async connect(): Promise<void> {
         try {
-            // 如果 sql 参数不是 false，则连接 SQL
-            // 优先级：options.sql > config.db > 跳过
-            const sqlConfig = options?.db || {};
-            if (sqlConfig) {
-                await this.connectSql(sqlConfig);
-            }
+            // 连接 SQL
+            await this.connectSql();
 
-            // 如果 redis 参数不是 false，则连接 Redis
-            const redisConfig = config?.redis || {};
-            await this.connectRedis(redisConfig);
+            // 连接 Redis
+            await this.connectRedis();
         } catch (error: any) {
-            Logger.error('数据库初始化失败', error);
+            Logger.error({ err: error }, '数据库初始化失败');
             await this.disconnect();
             throw error;
         }
@@ -330,7 +302,6 @@ export class Connect {
     static __reset(): void {
         this.sqlClient = null;
         this.redisClient = null;
-        this.dbHelper = null;
         this.sqlConnectedAt = null;
         this.redisConnectedAt = null;
         this.sqlPoolMax = 1;

package/lib/dbHelper.ts

@@ -5,8 +5,12 @@
 
 import { snakeCase } from 'es-toolkit/string';
 import { SqlBuilder } from './sqlBuilder.js';
-import { keysToCamel, arrayKeysToCamel, keysToSnake, fieldClear } from 'befly-util';
-import { Logger } from '../lib/logger.js';
+import { keysToCamel } from 'befly-shared/keysToCamel';
+import { arrayKeysToCamel } from 'befly-shared/arrayKeysToCamel';
+import { keysToSnake } from 'befly-shared/keysToSnake';
+import { fieldClear } from 'befly-shared/fieldClear';
+import { RedisTTL, RedisKeys } from 'befly-shared/redisKeys';
+import { Logger } from './logger.js';
 import type { WhereConditions } from '../types/common.js';
 import type { BeflyContext } from '../types/befly.js';
 import type { QueryOptions, InsertOptions, UpdateOptions, DeleteOptions, ListResult, TransactionCallback } from '../types/database.js';
@@ -81,7 +85,7 @@ export class DbHelper {
      */
     private async getTableColumns(table: string): Promise<string[]> {
         // 1. 先查 Redis 缓存
-        const cacheKey = `table:columns:${table}`;
+        const cacheKey = RedisKeys.tableColumns(table);
         let columns = await this.befly.redis.getObject<string[]>(cacheKey);
 
         if (columns && columns.length > 0) {
@@ -98,8 +102,8 @@ export class DbHelper {
 
         columns = result.map((row: any) => row.Field);
 
-        // 3. 写入 Redis 缓存（1小时过期）
-        await this.befly.redis.setObject(cacheKey, columns, 3600);
+        // 3. 写入 Redis 缓存
+        await this.befly.redis.setObject(cacheKey, columns, RedisTTL.tableColumns);
 
         return columns;
     }
@@ -507,12 +511,12 @@ export class DbHelper {
 
         // 警告日志：返回数据超过警告阈值
         if (result.length >= WARNING_LIMIT) {
-            Logger.warn(`⚠️ getAll 从表 \`${options.table}\` 返回了 ${result.length} 行数据，建议使用 getList 分页查询以获得更好的性能。`);
+            Logger.warn({ table: options.table, count: result.length }, 'getAll 返回数据过多，建议使用 getList 分页查询');
         }
 
         // 如果达到上限，额外警告
         if (result.length >= MAX_LIMIT) {
-            Logger.warn(`🚨 getAll 达到了最大限制 (${MAX_LIMIT})，可能还有更多数据。请使用 getList 分页查询。`);
+            Logger.warn({ table: options.table, limit: MAX_LIMIT }, 'getAll 达到最大限制，可能还有更多数据');
         }
 
         // 字段名转换：下划线 → 小驼峰
@@ -625,8 +629,7 @@ export class DbHelper {
             await this.executeWithConn(sql, params);
             return ids;
         } catch (error: any) {
-            // 批量插入失败，记录错误
-            Logger.error(`表 \`${table}\` 批量插入失败`, error);
+            Logger.error({ err: error, table: table }, '批量插入失败');
             throw error;
         }
     }
@@ -759,7 +762,7 @@ export class DbHelper {
                 await conn.query('COMMIT');
                 committed = true;
             } catch (commitError: any) {
-                Logger.error('事务提交失败，正在回滚', commitError);
+                Logger.error({ err: commitError }, '事务提交失败，正在回滚');
                 await conn.query('ROLLBACK');
                 throw new Error(`事务提交失败: ${commitError.message}`);
             }
@@ -772,7 +775,7 @@ export class DbHelper {
                     await conn.query('ROLLBACK');
                     Logger.warn('事务已回滚');
                 } catch (rollbackError: any) {
-                    Logger.error('事务回滚失败', rollbackError);
+                    Logger.error({ err: rollbackError }, '事务回滚失败');
                 }
             }
             throw error;