@agentforge/tools 0.16.14 → 0.16.16

package/dist/index.cjs

@@ -4044,6 +4044,94 @@ function quoteQualifiedIdentifier(qualifiedName, vendor) {
   const parts = qualifiedName.split(".");
   return parts.map((part) => quoteIdentifier(part, vendor)).join(".");
 }
+
+// src/data/relational/connection/lifecycle.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["RECONNECTING"] = "reconnecting";
+  ConnectionState2["ERROR"] = "error";
+  return ConnectionState2;
+})(ConnectionState || {});
+function cancelPendingReconnection(timer, logger23, vendor, message) {
+  if (!timer) {
+    return null;
+  }
+  logger23.debug(message, { vendor });
+  clearTimeout(timer);
+  return null;
+}
+async function waitForInFlightConnection(promise, logger23, vendor, phase) {
+  if (!promise) {
+    return null;
+  }
+  logger23.debug(`Waiting for in-flight connection attempt to complete before ${phase}`, {
+    vendor
+  });
+  try {
+    await promise;
+  } catch {
+  }
+  return null;
+}
+function shutdownClient(vendor, client) {
+  if (vendor === "postgresql" || vendor === "mysql") {
+    return client.end();
+  }
+  if (vendor === "sqlite") {
+    client.close();
+  }
+}
+function scheduleReconnection(context, logger23) {
+  if (context.reconnectionConfig.maxAttempts > 0 && context.reconnectionAttempts >= context.reconnectionConfig.maxAttempts) {
+    logger23.error("Max reconnection attempts reached", {
+      vendor: context.vendor,
+      attempts: context.reconnectionAttempts,
+      maxAttempts: context.reconnectionConfig.maxAttempts
+    });
+    return;
+  }
+  const delay2 = Math.min(
+    context.reconnectionConfig.baseDelayMs * Math.pow(2, context.reconnectionAttempts),
+    context.reconnectionConfig.maxDelayMs
+  );
+  const nextAttempt = context.reconnectionAttempts + 1;
+  context.setReconnectionAttempts(nextAttempt);
+  context.setState("reconnecting" /* RECONNECTING */);
+  logger23.info("Scheduling reconnection attempt", {
+    vendor: context.vendor,
+    attempt: nextAttempt,
+    maxAttempts: context.reconnectionConfig.maxAttempts,
+    delayMs: delay2
+  });
+  context.emitReconnecting({
+    attempt: nextAttempt,
+    maxAttempts: context.reconnectionConfig.maxAttempts,
+    delayMs: delay2
+  });
+  const timer = setTimeout(async () => {
+    context.setReconnectionTimer(null);
+    try {
+      logger23.info("Attempting reconnection", {
+        vendor: context.vendor,
+        attempt: nextAttempt
+      });
+      const promise = context.initialize().finally(() => {
+        context.setConnectPromise(null);
+      });
+      context.setConnectPromise(promise);
+      await promise;
+    } catch (error) {
+      logger23.error("Reconnection attempt failed", {
+        vendor: context.vendor,
+        attempt: nextAttempt,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }, delay2);
+  context.setReconnectionTimer(timer);
+}
 var logger7 = core.createLogger("agentforge:tools:data:relational:connection:vendor-init");
 var SAFE_INITIALIZATION_PATTERNS = [
   "Pool max connections must be",
@@ -4199,14 +4287,6 @@ async function initializeSQLiteConnection(connection) {
   return { client, db };
 }
 var logger8 = core.createLogger("agentforge:tools:data:relational:connection");
-var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
-  ConnectionState2["DISCONNECTED"] = "disconnected";
-  ConnectionState2["CONNECTING"] = "connecting";
-  ConnectionState2["CONNECTED"] = "connected";
-  ConnectionState2["RECONNECTING"] = "reconnecting";
-  ConnectionState2["ERROR"] = "error";
-  return ConnectionState2;
-})(ConnectionState || {});
 var ConnectionManager = class extends events.EventEmitter {
   vendor;
   db;
@@ -4256,13 +4336,12 @@ var ConnectionManager = class extends events.EventEmitter {
       });
       return this.connectPromise;
     }
-    if (this.reconnectionTimer) {
-      logger8.debug("Clearing pending reconnection timer before manual connect", {
-        vendor: this.vendor
-      });
-      clearTimeout(this.reconnectionTimer);
-      this.reconnectionTimer = null;
-    }
+    this.reconnectionTimer = cancelPendingReconnection(
+      this.reconnectionTimer,
+      logger8,
+      this.vendor,
+      "Clearing pending reconnection timer before manual connect"
+    );
     this.connectPromise = this.initialize().finally(() => {
       this.connectPromise = null;
     });
@@ -4277,21 +4356,19 @@ var ConnectionManager = class extends events.EventEmitter {
    */
   async disconnect() {
     this.connectionGeneration++;
-    if (this.reconnectionTimer) {
-      clearTimeout(this.reconnectionTimer);
-      this.reconnectionTimer = null;
-    }
+    this.reconnectionTimer = cancelPendingReconnection(
+      this.reconnectionTimer,
+      logger8,
+      this.vendor,
+      "Clearing pending reconnection timer before disconnect"
+    );
     this.reconnectionAttempts = 0;
-    if (this.connectPromise) {
-      logger8.debug("Waiting for in-flight connection attempt to complete before disconnect", {
-        vendor: this.vendor
-      });
-      try {
-        await this.connectPromise;
-      } catch {
-      }
-      this.connectPromise = null;
-    }
+    this.connectPromise = await waitForInFlightConnection(
+      this.connectPromise,
+      logger8,
+      this.vendor,
+      "disconnect"
+    );
     await this.close();
   }
   /**
@@ -4446,50 +4523,30 @@ var ConnectionManager = class extends events.EventEmitter {
    * @private
    */
   scheduleReconnection() {
-    if (this.reconnectionConfig.maxAttempts > 0 && this.reconnectionAttempts >= this.reconnectionConfig.maxAttempts) {
-      logger8.error("Max reconnection attempts reached", {
+    scheduleReconnection(
+      {
         vendor: this.vendor,
-        attempts: this.reconnectionAttempts,
-        maxAttempts: this.reconnectionConfig.maxAttempts
-      });
-      return;
-    }
-    const delay2 = Math.min(
-      this.reconnectionConfig.baseDelayMs * Math.pow(2, this.reconnectionAttempts),
-      this.reconnectionConfig.maxDelayMs
+        reconnectionConfig: this.reconnectionConfig,
+        reconnectionAttempts: this.reconnectionAttempts,
+        setReconnectionAttempts: (attempts) => {
+          this.reconnectionAttempts = attempts;
+        },
+        setState: (state) => {
+          this.setState(state);
+        },
+        emitReconnecting: (payload) => {
+          this.emit("reconnecting", payload);
+        },
+        initialize: () => this.initialize(),
+        setConnectPromise: (promise) => {
+          this.connectPromise = promise;
+        },
+        setReconnectionTimer: (timer) => {
+          this.reconnectionTimer = timer;
+        }
+      },
+      logger8
     );
-    this.reconnectionAttempts++;
-    this.setState("reconnecting" /* RECONNECTING */);
-    logger8.info("Scheduling reconnection attempt", {
-      vendor: this.vendor,
-      attempt: this.reconnectionAttempts,
-      maxAttempts: this.reconnectionConfig.maxAttempts,
-      delayMs: delay2
-    });
-    this.emit("reconnecting", {
-      attempt: this.reconnectionAttempts,
-      maxAttempts: this.reconnectionConfig.maxAttempts,
-      delayMs: delay2
-    });
-    this.reconnectionTimer = setTimeout(async () => {
-      this.reconnectionTimer = null;
-      try {
-        logger8.info("Attempting reconnection", {
-          vendor: this.vendor,
-          attempt: this.reconnectionAttempts
-        });
-        this.connectPromise = this.initialize().finally(() => {
-          this.connectPromise = null;
-        });
-        await this.connectPromise;
-      } catch (error) {
-        logger8.error("Reconnection attempt failed", {
-          vendor: this.vendor,
-          attempt: this.reconnectionAttempts,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }, delay2);
   }
   /**
    * Determine whether an error thrown by drizzle-orm's better-sqlite3 adapter
@@ -4659,34 +4716,25 @@ var ConnectionManager = class extends events.EventEmitter {
    */
   async close() {
     this.connectionGeneration++;
-    if (this.reconnectionTimer) {
-      logger8.debug("Canceling pending reconnection timer during close", {
-        vendor: this.vendor
-      });
-      clearTimeout(this.reconnectionTimer);
-      this.reconnectionTimer = null;
-    }
-    if (this.connectPromise) {
-      logger8.debug("Waiting for in-flight connection attempt to complete before close", {
-        vendor: this.vendor
-      });
-      try {
-        await this.connectPromise;
-      } catch {
-      }
-      this.connectPromise = null;
-    }
+    this.reconnectionTimer = cancelPendingReconnection(
+      this.reconnectionTimer,
+      logger8,
+      this.vendor,
+      "Canceling pending reconnection timer during close"
+    );
+    this.connectPromise = await waitForInFlightConnection(
+      this.connectPromise,
+      logger8,
+      this.vendor,
+      "close"
+    );
     if (this.client) {
       logger8.info("Closing database connection", {
         vendor: this.vendor,
         state: this.state
       });
       try {
-        if (this.vendor === "postgresql" || this.vendor === "mysql") {
-          await this.client.end();
-        } else if (this.vendor === "sqlite") {
-          this.client.close();
-        }
+        await shutdownClient(this.vendor, this.client);
         this.setState("disconnected" /* DISCONNECTED */);
         this.emit("disconnected");
         logger8.debug("Database connection closed successfully", {
@@ -4723,11 +4771,7 @@ var ConnectionManager = class extends events.EventEmitter {
       vendor: this.vendor
     });
     try {
-      if (this.vendor === "postgresql" || this.vendor === "mysql") {
-        await this.client.end();
-      } else if (this.vendor === "sqlite") {
-        this.client.close();
-      }
+      await shutdownClient(this.vendor, this.client);
     } catch (error) {
       logger8.debug("Error during cancelled connection cleanup", {
         vendor: this.vendor,