befly 3.10.18 → 3.11.1

package/{lib/connect.ts → dist/lib/connect.js}

@@ -2,37 +2,28 @@
  * 数据库连接管理器
  * 统一管理 SQL 和 Redis 连接
  */
-
-import type { DatabaseConfig, RedisConfig } from "../types/befly.ts";
-
 import { SQL, RedisClient } from "bun";
-
-import { Logger } from "./logger.ts";
-
+import { Logger } from "./logger";
 /**
  * 数据库连接管理器
  * 使用静态方法管理全局单例连接
  */
 export class Connect {
-    private static sqlClient: SQL | null = null;
-    private static redisClient: RedisClient | null = null;
-
+    static sqlClient = null;
+    static redisClient = null;
     // 连接统计信息
-    private static sqlConnectedAt: number | null = null;
-    private static redisConnectedAt: number | null = null;
-    private static sqlPoolMax: number = 1;
-
+    static sqlConnectedAt = null;
+    static redisConnectedAt = null;
+    static sqlPoolMax = 1;
     // ========================================
     // SQL 连接管理
     // ========================================
-
     /**
      * 连接 SQL 数据库
      * @returns SQL 客户端实例
      */
-    static async connectSql(dbConfig: DatabaseConfig): Promise<SQL> {
+    static async connectSql(dbConfig) {
         const config = dbConfig || {};
-
         // 构建数据库连接字符串
         const type = config.type || "mysql";
         const host = config.host || "127.0.0.1";
@@ -40,106 +31,99 @@ export class Connect {
         const user = encodeURIComponent(config.username || "root");
         const password = encodeURIComponent(config.password || "root");
         const database = encodeURIComponent(config.database || "befly_demo");
-
-        let finalUrl: string;
+        let finalUrl;
         if (type === "sqlite") {
             finalUrl = database;
-        } else {
+        }
+        else {
             if (!host || !database) {
                 throw new Error("数据库配置不完整，请检查配置参数");
             }
             finalUrl = `${type}://${user}:${password}@${host}:${port}/${database}`;
         }
-
-        let sql: SQL;
-
+        let sql;
         if (type === "sqlite") {
             sql = new SQL(finalUrl);
-        } else {
+        }
+        else {
             sql = new SQL({
                 url: finalUrl,
                 max: config.poolMax ?? 1,
                 bigint: false
             });
         }
-
         try {
             const timeout = 30000;
-
             const healthCheckPromise = (async () => {
                 let version = "";
                 if (type === "sqlite") {
-                    const v = await sql`SELECT sqlite_version() AS version`;
+                    const v = await sql `SELECT sqlite_version() AS version`;
                     version = v?.[0]?.version;
-                } else if (type === "postgresql" || type === "postgres") {
-                    const v = await sql`SELECT version() AS version`;
+                }
+                else if (type === "postgresql" || type === "postgres") {
+                    const v = await sql `SELECT version() AS version`;
                     version = v?.[0]?.version;
-                } else {
-                    const v = await sql`SELECT VERSION() AS version`;
+                }
+                else {
+                    const v = await sql `SELECT VERSION() AS version`;
                     version = v?.[0]?.version;
                 }
                 return version;
             })();
-
-            const timeoutPromise = new Promise<never>((_, reject) => {
+            const timeoutPromise = new Promise((_, reject) => {
                 setTimeout(() => {
                     reject(new Error(`数据库连接超时 (${timeout}ms)`));
                 }, timeout);
             });
-
             await Promise.race([healthCheckPromise, timeoutPromise]);
-
             this.sqlClient = sql;
             this.sqlConnectedAt = Date.now();
             this.sqlPoolMax = config.poolMax ?? 1;
             return sql;
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "[Connect] SQL 连接失败");
             try {
                 await sql?.close();
-            } catch {}
-
+            }
+            catch { }
             throw error;
         }
     }
-
     /**
      * 断开 SQL 连接
      */
-    static async disconnectSql(): Promise<void> {
+    static async disconnectSql() {
         if (this.sqlClient) {
             try {
                 await this.sqlClient.close();
-            } catch (error: any) {
+            }
+            catch (error) {
                 Logger.error({ err: error }, "[Connect] 关闭 SQL 连接时出错");
             }
             this.sqlClient = null;
             this.sqlConnectedAt = null;
         }
     }
-
     /**
      * 获取 SQL 客户端实例
      * @throws 如果未连接则抛出错误
      */
-    static getSql(): SQL {
+    static getSql() {
         if (!this.sqlClient) {
             throw new Error("SQL 客户端未连接，请先调用 Connect.connectSql()");
         }
         return this.sqlClient;
     }
-
     // ========================================
     // Redis 连接管理
     // ========================================
-
     /**
      * 连接 Redis
      * @returns Redis 客户端实例
      */
-    static async connectRedis(redisConfig: RedisConfig): Promise<RedisClient> {
+    static async connectRedis(redisConfig) {
         const config = redisConfig || {};
-
         try {
             // 构建 Redis URL
             const host = config.host || "127.0.0.1";
@@ -147,16 +131,14 @@ export class Connect {
             const username = config.username || "";
             const password = config.password || "";
             const db = config.db || 0;
-
             let auth = "";
             if (username && password) {
                 auth = `${username}:${password}@`;
-            } else if (password) {
+            }
+            else if (password) {
                 auth = `:${password}@`;
             }
-
             const url = `redis://${auth}${host}:${port}/${db}`;
-
             const redis = new RedisClient(url, {
                 connectionTimeout: 30000,
                 idleTimeout: 0,
@@ -165,99 +147,80 @@ export class Connect {
                 enableOfflineQueue: true,
                 enableAutoPipelining: true
             });
-
             await redis.ping();
-
             this.redisClient = redis;
             this.redisConnectedAt = Date.now();
             return redis;
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "[Connect] Redis 连接失败");
             throw new Error(`Redis 连接失败: ${error.message}`);
         }
     }
-
     /**
      * 断开 Redis 连接
      */
-    static async disconnectRedis(): Promise<void> {
+    static async disconnectRedis() {
         if (this.redisClient) {
             try {
                 this.redisClient.close();
                 this.redisConnectedAt = null;
-            } catch (error: any) {
+            }
+            catch (error) {
                 Logger.error({ err: error }, "[Connect] 关闭 Redis 连接时出错");
             }
             this.redisClient = null;
         }
     }
-
     /**
      * 获取 Redis 客户端实例
      * @throws 如果未连接则抛出错误
      */
-    static getRedis(): RedisClient {
+    static getRedis() {
         if (!this.redisClient) {
             throw new Error("Redis 客户端未连接，请先调用 Connect.connectRedis()");
         }
         return this.redisClient;
     }
-
     // ========================================
     // 统一连接管理
     // ========================================
-
     /**
      * 连接所有数据库（SQL + Redis）
      */
-    static async connect(config: { db: DatabaseConfig; redis: RedisConfig }): Promise<void> {
+    static async connect(config) {
         try {
             // 连接 SQL
             await this.connectSql(config.db || {});
-
             // 连接 Redis
             await this.connectRedis(config.redis || {});
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error }, "数据库初始化失败");
             await this.disconnect();
             throw error;
         }
     }
-
     /**
      * 断开所有数据库连接
      */
-    static async disconnect(): Promise<void> {
+    static async disconnect() {
         await this.disconnectSql();
         await this.disconnectRedis();
     }
-
     /**
      * 检查连接状态
      */
-    static isConnected(): { sql: boolean; redis: boolean } {
+    static isConnected() {
         return {
             sql: this.sqlClient !== null,
             redis: this.redisClient !== null
         };
     }
-
     /**
      * 获取连接状态详细信息（用于监控和调试）
      */
-    static getStatus(): {
-        sql: {
-            connected: boolean;
-            connectedAt: number | null;
-            uptime: number | null;
-            poolMax: number;
-        };
-        redis: {
-            connected: boolean;
-            connectedAt: number | null;
-            uptime: number | null;
-        };
-    } {
+    static getStatus() {
         const now = Date.now();
         return {
             sql: {
@@ -273,29 +236,25 @@ export class Connect {
             }
         };
     }
-
     // ========================================
     // 测试辅助方法
     // ========================================
-
     /**
      * 设置 mock SQL 客户端（仅用于测试）
      */
-    static __setMockSql(mockClient: SQL): void {
+    static __setMockSql(mockClient) {
         this.sqlClient = mockClient;
     }
-
     /**
      * 设置 mock Redis 客户端（仅用于测试）
      */
-    static __setMockRedis(mockClient: RedisClient): void {
+    static __setMockRedis(mockClient) {
         this.redisClient = mockClient;
     }
-
     /**
      * 重置所有连接状态（仅用于测试）
      */
-    static __reset(): void {
+    static __reset() {
         this.sqlClient = null;
         this.redisClient = null;
         this.sqlConnectedAt = null;

package/dist/lib/dbDialect.d.ts

@@ -0,0 +1,87 @@
+export type DbDialectName = "mysql" | "postgresql" | "sqlite";
+/**
+ * 获取方言实例（内部缓存，避免到处 new）。
+ *
+ * 约束：dialect 实例应当是纯逻辑对象（无连接/无 IO/无状态副作用），可全局复用。
+ */
+export declare function getDialectByName(name: DbDialectName): DbDialect;
+export type SqlTextQuery = {
+    sql: string;
+    params: unknown[];
+};
+export type SyncTableColumnsInfoQuery = {
+    columns: SqlTextQuery;
+    comments?: SqlTextQuery;
+};
+export type SyncTableIndexesQuery = SqlTextQuery;
+/**
+ * syncTable 专用：获取“列元信息”查询。
+ *
+ * 说明：
+ * - 这里仅负责 SQL + 参数构造（方言差异）；
+ * - 解析为 ColumnInfo 的逻辑仍放在 syncTable.ts（保持同步算法聚合）。
+ */
+export declare function getSyncTableColumnsInfoQuery(options: {
+    dialect: DbDialectName;
+    table: string;
+    dbName: string;
+    schema?: string;
+}): SyncTableColumnsInfoQuery;
+/**
+ * syncTable 专用：获取“索引元信息”查询（只负责 SQL + 参数构造）。
+ *
+ * 约束：
+ * - 仅下沉 MySQL / PostgreSQL；SQLite 仍走 PRAGMA（需要多次查询）。
+ * - 解析（比如 PG indexdef 解析列名）仍留在 syncTable.ts。
+ */
+export declare function getSyncTableIndexesQuery(options: {
+    dialect: DbDialectName;
+    table: string;
+    dbName: string;
+    schema?: string;
+}): SyncTableIndexesQuery;
+export interface DbDialect {
+    name: DbDialectName;
+    /**
+     * 转义/引用 SQL 标识符（表名/字段名）。
+     * 注意：仅用于单个标识符片段，不支持包含空格、点号、函数等复杂表达式。
+     */
+    quoteIdent(identifier: string): string;
+    /**
+     * 获取表字段列表的查询。
+     * 约定：返回结果应能通过 getTableColumnsFromResult 提取列名。
+     */
+    getTableColumnsQuery(table: string, schema?: string): SqlTextQuery;
+    /** 从 getTableColumnsQuery 的结果中提取列名数组 */
+    getTableColumnsFromResult(result: any): string[];
+    /** 检查表是否存在的查询 */
+    tableExistsQuery(table: string, schema?: string): SqlTextQuery;
+    /**
+     * 是否支持 schema.table 形式（仅用于校验；具体 quoting 仍由 SqlBuilder 处理）。
+     */
+    supportsSchema: boolean;
+}
+export declare class MySqlDialect implements DbDialect {
+    name: DbDialectName;
+    supportsSchema: boolean;
+    quoteIdent(identifier: string): string;
+    getTableColumnsQuery(table: string, _schema?: string): SqlTextQuery;
+    getTableColumnsFromResult(result: any): string[];
+    tableExistsQuery(table: string, schema?: string): SqlTextQuery;
+}
+export declare class PostgresDialect implements DbDialect {
+    name: DbDialectName;
+    supportsSchema: boolean;
+    quoteIdent(identifier: string): string;
+    getTableColumnsQuery(table: string, schema?: string): SqlTextQuery;
+    getTableColumnsFromResult(result: any): string[];
+    tableExistsQuery(table: string, schema?: string): SqlTextQuery;
+}
+export declare class SqliteDialect implements DbDialect {
+    name: DbDialectName;
+    supportsSchema: boolean;
+    quoteIdent(identifier: string): string;
+    getTableColumnsQuery(table: string, _schema?: string): SqlTextQuery;
+    getTableColumnsFromResult(result: any): string[];
+    tableExistsQuery(table: string, _schema?: string): SqlTextQuery;
+}