@spfn/core 0.2.0-beta.17 → 0.2.0-beta.18

package/dist/db/index.js

@@ -503,6 +503,8 @@ var setMonitoringConfig = (config) => {
   globalThis.__SPFN_DB_MONITORING__ = config;
 };
 var dbLogger3 = logger.child("@spfn/core:database");
+var CLIENT_CLOSE_TIMEOUT = 5;
+var isReconnecting = false;
 async function testDatabaseConnection(db) {
   await db.execute("SELECT 1");
 }
@@ -514,8 +516,13 @@ async function performHealthCheck(getDatabase2) {
     await testDatabaseConnection(read);
   }
 }
-async function reconnectAndRestore(options, closeDatabase2) {
-  await closeDatabase2();
+async function closeClient(client) {
+  try {
+    await client.end({ timeout: CLIENT_CLOSE_TIMEOUT });
+  } catch {
+  }
+}
+async function reconnectAndRestore(options) {
   const result = await createDatabaseFromEnv(options);
   if (!result.write) {
     return false;
@@ -524,15 +531,23 @@ async function reconnectAndRestore(options, closeDatabase2) {
   if (result.read && result.read !== result.write) {
     await testDatabaseConnection(result.read);
   }
+  const oldWriteClient = getWriteClient();
+  const oldReadClient = getReadClient();
   setWriteInstance(result.write);
   setReadInstance(result.read);
   setWriteClient(result.writeClient);
   setReadClient(result.readClient);
   const monConfig = buildMonitoringConfig(options?.monitoring);
   setMonitoringConfig(monConfig);
+  if (oldWriteClient) {
+    closeClient(oldWriteClient);
+  }
+  if (oldReadClient && oldReadClient !== oldWriteClient) {
+    closeClient(oldReadClient);
+  }
   return true;
 }
-function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
+function startHealthCheck(config, options, getDatabase2) {
   const healthCheck = getHealthCheckInterval();
   if (healthCheck) {
     dbLogger3.debug("Health check already running");
@@ -543,47 +558,56 @@ function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
     reconnect: config.reconnect
   });
   const interval = setInterval(async () => {
+    if (isReconnecting) {
+      dbLogger3.debug("Health check skipped: reconnection in progress");
+      return;
+    }
     try {
       await performHealthCheck(getDatabase2);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       dbLogger3.error("Database health check failed", { error: message });
       if (config.reconnect) {
-        await attemptReconnection(config, options, closeDatabase2);
+        await attemptReconnection(config, options);
       }
     }
   }, config.interval);
   setHealthCheckInterval(interval);
 }
-async function attemptReconnection(config, options, closeDatabase2) {
+async function attemptReconnection(config, options) {
+  isReconnecting = true;
   dbLogger3.warn("Attempting database reconnection", {
     maxRetries: config.maxRetries,
     retryInterval: `${config.retryInterval}ms`
   });
-  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-    try {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
-      if (attempt > 1) {
-        await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
+  try {
+    for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
+      try {
+        dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
+        if (attempt > 1) {
+          await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
+        }
+        const success = await reconnectAndRestore(options);
+        if (success) {
+          dbLogger3.info("Database reconnection successful", { attempt });
+          return;
+        } else {
+          dbLogger3.error(`Reconnection attempt ${attempt} failed: No write database instance created`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
+          error: message,
+          attempt,
+          maxRetries: config.maxRetries
+        });
       }
-      const success = await reconnectAndRestore(options, closeDatabase2);
-      if (success) {
-        dbLogger3.info("Database reconnection successful", { attempt });
-        return;
-      } else {
-        dbLogger3.error(`Reconnection attempt ${attempt} failed: No write database instance created`);
+      if (attempt === config.maxRetries) {
+        dbLogger3.error("Max reconnection attempts reached, will retry on next health check");
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
-        error: message,
-        attempt,
-        maxRetries: config.maxRetries
-      });
-    }
-    if (attempt === config.maxRetries) {
-      dbLogger3.error("Max reconnection attempts reached, giving up");
     }
+  } finally {
+    isReconnecting = false;
   }
 }
 function stopHealthCheck() {
@@ -593,6 +617,7 @@ function stopHealthCheck() {
     setHealthCheckInterval(void 0);
     dbLogger3.info("Database health check stopped");
   }
+  isReconnecting = false;
 }
 
 // src/db/manager/manager.ts
@@ -742,7 +767,7 @@ async function initDatabase(options) {
       );
       const healthCheckConfig = buildHealthCheckConfig(options?.healthCheck);
       if (healthCheckConfig.enabled) {
-        startHealthCheck(healthCheckConfig, options, getDatabase, closeDatabase);
+        startHealthCheck(healthCheckConfig, options, getDatabase);
       }
       const monConfig = buildMonitoringConfig(options?.monitoring);
       setMonitoringConfig(monConfig);