@lark-apaas/nestjs-datapaas 1.0.16 → 1.0.18

package/dist/index.cjs

@@ -47,6 +47,8 @@ var import_common2 = require("@nestjs/common");
 var import_postgres_js = require("drizzle-orm/postgres-js");
 var import_drizzle_orm = require("drizzle-orm");
 var import_postgres = __toESM(require("postgres"), 1);
+var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
 
 // src/database/const.ts
 var DRIZZLE_DATABASE = "DRIZZLE_DATABASE";
@@ -222,19 +224,38 @@ var DrizzleDatabaseManager = class {
   observable;
   requestContext;
   db = null;
+  sqlClient = null;
+  connectionOpPromise = null;
   currentConnectionInfo = null;
   isConnected = false;
   skipInitDbConnection = false;
+  currentToken = null;
+  currentResolvedConnectionString = null;
+  tokenWatchFilePath = null;
+  tokenWatchDebounceTimer = null;
+  refreshingByTokenChange = false;
+  sqlClientShutdownTimeoutSeconds = 5;
+  /**
+  * 构造函数：注入配置、日志能力与请求上下文。
+  */
   constructor(config, observable, requestContext) {
     this.config = config;
     this.observable = observable;
     this.requestContext = requestContext;
     this.skipInitDbConnection = !!process.env.DEPRECATED_SKIP_INIT_DB_CONNECTION;
   }
+  /**
+  * 模块初始化：建立首个数据库连接并启动 token 监听。
+  */
   async onModuleInit() {
     await this.initialize();
+    this.startTokenWatcher();
   }
+  /**
+  * 模块销毁：先停止 token 监听，再断开数据库连接。
+  */
   async onModuleDestroy() {
+    this.stopTokenWatcher();
     await this.disconnect();
   }
   /**
@@ -249,29 +270,30 @@ var DrizzleDatabaseManager = class {
       };
       return this.db;
     }
-    try {
-      const { connectionString, connectionConfig } = parseConnectionInfo(this.config.connectionString, this.config);
-      const baseSql = (0, import_postgres.default)(connectionString, connectionConfig);
-      const sqlProxy = genPostgresProxy(baseSql, this.observable, this.requestContext);
-      this.db = (0, import_postgres_js.drizzle)(sqlProxy, {
-        schema: this.config.schema,
-        logger: this.config.logger
-      });
-      this.currentConnectionInfo = {
-        connectionString,
-        connectionConfig: {
-          ssl: connectionConfig.ssl,
-          connectionTimeout: connectionConfig.connect_timeout,
-          idleTimeout: connectionConfig.idle_timeout,
-          maxConnections: connectionConfig.max
-        }
-      };
-      this.isConnected = true;
+    if (this.db && this.isConnected) {
       return this.db;
-    } catch (error) {
-      this.isConnected = false;
-      throw new Error(`Failed to initialize database connection: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
+    if (this.connectionOpPromise) {
+      return this.connectionOpPromise;
+    }
+    return this.runWithConnectionLock(async () => {
+      if (this.db && this.isConnected) {
+        return this.db;
+      }
+      try {
+        const token = await this.readConnectionTokenFromFile();
+        const resolvedConnectionString = this.appendTokenToConnectionString(this.config.connectionString, token);
+        const nextState = await this.createConnectedState(resolvedConnectionString, token);
+        this.applyConnectedState(nextState);
+        return nextState.db;
+      } catch (error) {
+        if (!this.db || !this.isConnected) {
+          this.isConnected = false;
+          this.db = null;
+        }
+        throw new Error(`Failed to initialize database connection: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    });
   }
   /**
   * 获取数据库实例
@@ -301,27 +323,34 @@ var DrizzleDatabaseManager = class {
     }
   }
   /**
-  * 重新连接数据库
-  * @param forceRefresh 是否强制刷新连接信息
+  * 重新连接数据库。
+  * 注意：重连时不关闭 token watcher，避免重连后丢失后续文件变更监听。
+  * 同时通过 promise 锁避免并发重连导致状态抖动。
   * @returns 新的数据库实例
   */
-  async reconnect(_forceRefresh = false) {
-    await this.disconnect();
-    return this.initialize();
+  async reconnect() {
+    return this.reconnectInternal();
   }
   /**
   * 断开数据库连接
   */
-  async disconnect() {
-    if (this.db) {
-      try {
-        this.db = null;
-        this.isConnected = false;
-        this.currentConnectionInfo = null;
-      } catch (error) {
-        console.error("Error disconnecting from database:", error);
-      }
+  async disconnect(shouldStopWatcher = true) {
+    if (shouldStopWatcher) {
+      this.stopTokenWatcher();
+    }
+    const pendingOp = this.connectionOpPromise;
+    if (pendingOp) {
+      await Promise.allSettled([
+        pendingOp
+      ]);
     }
+    await this.shutdownSqlClientSafely(this.sqlClient, "Error disconnecting from database:");
+    this.sqlClient = null;
+    this.db = null;
+    this.isConnected = false;
+    this.currentConnectionInfo = null;
+    this.currentResolvedConnectionString = null;
+    this.currentToken = null;
   }
   /**
   * 获取当前连接信息
@@ -356,6 +385,193 @@ var DrizzleDatabaseManager = class {
       connectionInfo: this.currentConnectionInfo
     };
   }
+  /**
+  * 读取 token 文件，空文件等价于无 token
+  */
+  async readConnectionTokenFromFile() {
+    const tokenFilePath = this.config.connectionTokenFilePath;
+    if (!tokenFilePath) {
+      return null;
+    }
+    try {
+      const raw = await (0, import_promises.readFile)(tokenFilePath, "utf-8");
+      const trimmed = raw.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+  * 基于基础 connectionString 和 token 生成最终连接串
+  * 只修改 options 参数值，在末尾追加 -c miaoda.zti_token=<token>
+  */
+  appendTokenToConnectionString(connectionString, token) {
+    if (!token) {
+      return connectionString;
+    }
+    const url = new URL(connectionString);
+    const currentOptions = url.searchParams.get("options") || "";
+    const optionsWithoutToken = currentOptions.replace(/(?:^|\s)-c\s+miaoda.zti_token=[^\s]*/g, " ").replace(/\s+/g, " ").trim();
+    const tokenOption = `-c miaoda.zti_token=${token}`;
+    const nextOptions = [
+      optionsWithoutToken,
+      tokenOption
+    ].filter(Boolean).join(" ").trim();
+    url.searchParams.set("options", nextOptions);
+    return url.toString();
+  }
+  async createConnectedState(resolvedConnectionString, token) {
+    const { connectionString, connectionConfig } = parseConnectionInfo(resolvedConnectionString, this.config);
+    const baseSql = (0, import_postgres.default)(connectionString, connectionConfig);
+    try {
+      const sqlProxy = genPostgresProxy(baseSql, this.observable, this.requestContext);
+      const db = (0, import_postgres_js.drizzle)(sqlProxy, {
+        schema: this.config.schema,
+        logger: this.config.logger
+      });
+      return {
+        db,
+        sqlClient: baseSql,
+        resolvedConnectionString: connectionString,
+        token,
+        connectionInfo: {
+          connectionString,
+          connectionConfig: {
+            ssl: connectionConfig.ssl,
+            connectionTimeout: connectionConfig.connect_timeout,
+            idleTimeout: connectionConfig.idle_timeout,
+            maxConnections: connectionConfig.max
+          }
+        }
+      };
+    } catch (error) {
+      await this.shutdownSqlClientSafely(baseSql, "Error closing failed new database client:");
+      throw error;
+    }
+  }
+  applyConnectedState(nextState) {
+    this.db = nextState.db;
+    this.sqlClient = nextState.sqlClient;
+    this.currentConnectionInfo = nextState.connectionInfo;
+    this.currentResolvedConnectionString = nextState.resolvedConnectionString;
+    this.currentToken = nextState.token;
+    this.isConnected = true;
+  }
+  reconnectInternal(nextResolvedConnectionString, nextToken) {
+    return this.runWithConnectionLock(() => this.reconnectWithResolvedConnectionString(nextResolvedConnectionString, nextToken));
+  }
+  runWithConnectionLock(operation) {
+    if (this.connectionOpPromise) {
+      return this.connectionOpPromise;
+    }
+    this.connectionOpPromise = (async () => {
+      try {
+        return await operation();
+      } finally {
+        this.connectionOpPromise = null;
+      }
+    })();
+    return this.connectionOpPromise;
+  }
+  async reconnectWithResolvedConnectionString(nextResolvedConnectionString, nextToken) {
+    const resolvedToken = nextToken ?? await this.readConnectionTokenFromFile();
+    const resolvedConnectionString = nextResolvedConnectionString ?? this.appendTokenToConnectionString(this.config.connectionString, resolvedToken);
+    const nextState = await this.createConnectedState(resolvedConnectionString, resolvedToken);
+    const previousSqlClient = this.sqlClient;
+    this.applyConnectedState(nextState);
+    if (previousSqlClient && previousSqlClient !== nextState.sqlClient) {
+      await this.shutdownSqlClientSafely(previousSqlClient, "Error shutting down previous database client after reconnect:");
+    }
+    return nextState.db;
+  }
+  async shutdownSqlClientSafely(client, errorPrefix) {
+    try {
+      if (client && typeof client.end === "function") {
+        await client.end({
+          timeout: this.sqlClientShutdownTimeoutSeconds
+        });
+      }
+    } catch (error) {
+      console.error(errorPrefix, error);
+    }
+  }
+  /**
+  * 启动 token 文件监听；若已存在旧监听则先清理后重建。
+  * 使用 watchFile 轮询，规避虚拟化/网络文件系统下 fs.watch 不可靠的问题。
+  */
+  startTokenWatcher() {
+    const tokenFilePath = this.config.connectionTokenFilePath;
+    if (!tokenFilePath || this.skipInitDbConnection) {
+      return;
+    }
+    this.stopTokenWatcher();
+    this.startTokenWatchFileFallback(tokenFilePath);
+  }
+  /**
+  * watchFile 兜底监听：即使 fs.watch 丢事件，也能通过轮询感知 token 文件变化。
+  */
+  startTokenWatchFileFallback(tokenFilePath) {
+    if (this.tokenWatchFilePath === tokenFilePath) {
+      return;
+    }
+    if (this.tokenWatchFilePath) {
+      (0, import_node_fs.unwatchFile)(this.tokenWatchFilePath);
+      this.tokenWatchFilePath = null;
+    }
+    (0, import_node_fs.watchFile)(tokenFilePath, {
+      interval: 6e5
+    }, () => {
+      this.scheduleTokenRefresh();
+    });
+    this.tokenWatchFilePath = tokenFilePath;
+  }
+  /**
+  * 停止 watcher 与防抖定时器，释放监听资源。
+  */
+  stopTokenWatcher() {
+    if (this.tokenWatchDebounceTimer) {
+      clearTimeout(this.tokenWatchDebounceTimer);
+      this.tokenWatchDebounceTimer = null;
+    }
+    if (this.tokenWatchFilePath) {
+      (0, import_node_fs.unwatchFile)(this.tokenWatchFilePath);
+      this.tokenWatchFilePath = null;
+    }
+  }
+  /**
+  * 对频繁文件事件做防抖，避免短时间重复重连。
+  */
+  scheduleTokenRefresh() {
+    if (this.tokenWatchDebounceTimer) {
+      clearTimeout(this.tokenWatchDebounceTimer);
+    }
+    this.tokenWatchDebounceTimer = setTimeout(() => {
+      void this.refreshConnectionIfTokenChanged();
+    }, 300);
+  }
+  /**
+  * token 变化时刷新连接：仅在 token/连接串发生变化，或当前连接不可用时触发重连。
+  */
+  async refreshConnectionIfTokenChanged() {
+    if (this.refreshingByTokenChange) {
+      return;
+    }
+    this.refreshingByTokenChange = true;
+    try {
+      const nextToken = await this.readConnectionTokenFromFile();
+      const nextResolvedConnectionString = this.appendTokenToConnectionString(this.config.connectionString, nextToken);
+      const sameToken = nextToken === this.currentToken;
+      const sameConnectionString = nextResolvedConnectionString === this.currentResolvedConnectionString;
+      if (sameToken && sameConnectionString && this.isConnected) {
+        return;
+      }
+      await this.reconnectInternal(nextResolvedConnectionString, nextToken);
+    } catch (error) {
+      console.error("Failed to refresh database connection from token file:", error);
+    } finally {
+      this.refreshingByTokenChange = false;
+    }
+  }
 };
 DrizzleDatabaseManager = _ts_decorate([
   (0, import_common2.Injectable)(),
@@ -416,11 +632,10 @@ var DataPaasDatabaseService = class {
   }
   /**
   * 重新连接数据库
-  * @param forceRefresh 是否强制刷新连接信息
   * @returns 新的数据库实例
   */
-  async reconnect(forceRefresh = false) {
-    return this.databaseManager.reconnect(forceRefresh);
+  async reconnect() {
+    return this.databaseManager.reconnect();
   }
   /**
   * 获取当前连接信息
@@ -584,7 +799,8 @@ var DataPaasModule = class _DataPaasModule {
       connectionTimeout: options.connectionTimeout || 10,
       ssl: options.ssl || (sslModeRequired ? "require" : false),
       autoContext: options.autoContext == null ? true : !!options.autoContext,
-      roleSchema
+      roleSchema,
+      connectionTokenFilePath: options.connectionTokenFilePath
     };
     const providers = [
       // 配置提供者 - 使用 useValue
@@ -611,7 +827,16 @@ var DataPaasModule = class _DataPaasModule {
         provide: DRIZZLE_DATABASE,
         useFactory: /* @__PURE__ */ __name(async (manager) => {
           await manager.initialize();
-          return manager.getDatabase();
+          return new Proxy({}, {
+            get: /* @__PURE__ */ __name((_target, prop, receiver) => {
+              const db = manager.getDatabase();
+              const value = Reflect.get(db, prop, receiver);
+              if (typeof value === "function") {
+                return value.bind(db);
+              }
+              return value;
+            }, "get")
+          });
         }, "useFactory"),
         inject: [
           DrizzleDatabaseManager
@@ -670,7 +895,16 @@ var DataPaasModule = class _DataPaasModule {
         provide: DRIZZLE_DATABASE,
         useFactory: /* @__PURE__ */ __name(async (manager) => {
           await manager.initialize();
-          return manager.getDatabase();
+          return new Proxy({}, {
+            get: /* @__PURE__ */ __name((_target, prop, receiver) => {
+              const db = manager.getDatabase();
+              const value = Reflect.get(db, prop, receiver);
+              if (typeof value === "function") {
+                return value.bind(db);
+              }
+              return value;
+            }, "get")
+          });
         }, "useFactory"),
         inject: [
           DrizzleDatabaseManager
@@ -743,7 +977,8 @@ var DataPaasModule = class _DataPaasModule {
       connectionTimeout: config.connectionTimeout || 10,
       ssl: config.ssl || (sslModeRequired ? "require" : false),
       autoContext: config.autoContext == null ? true : !!config.autoContext,
-      roleSchema
+      roleSchema,
+      connectionTokenFilePath: config.connectionTokenFilePath
     };
   }
 };