@agentforge/tools 0.16.39 → 0.16.41

package/dist/index.js

@@ -4199,6 +4199,59 @@ function scheduleReconnection(context, logger23) {
   }, delay2);
   context.setReconnectionTimer(timer);
 }
+
+// src/data/relational/connection/connection-cleanup.ts
+async function cleanupConnectionResources(vendor, client, clearConnection, logger23) {
+  if (!client) {
+    return;
+  }
+  logger23.debug("Cleaning up cancelled connection", {
+    vendor
+  });
+  try {
+    await shutdownClient(vendor, client);
+  } catch (error) {
+    logger23.debug("Error during cancelled connection cleanup", {
+      vendor,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  } finally {
+    clearConnection();
+  }
+}
+async function closeManagedConnection(runtime, logger23) {
+  const client = runtime.getClient();
+  if (client) {
+    logger23.info("Closing database connection", {
+      vendor: runtime.vendor,
+      state: runtime.getState()
+    });
+    try {
+      await shutdownClient(runtime.vendor, client);
+      runtime.setState("disconnected" /* DISCONNECTED */);
+      runtime.emitDisconnected();
+      logger23.debug("Database connection closed successfully", {
+        vendor: runtime.vendor,
+        state: runtime.getState()
+      });
+    } catch (error) {
+      logger23.error("Error closing database connection", {
+        vendor: runtime.vendor,
+        error: error instanceof Error ? error.message : String(error),
+        state: runtime.getState()
+      });
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      runtime.setState("error" /* ERROR */);
+      runtime.emitError(normalizedError);
+    } finally {
+      runtime.setClient(null);
+      runtime.setDb(null);
+    }
+  } else if (runtime.getState() !== "disconnected" /* DISCONNECTED */) {
+    runtime.setState("disconnected" /* DISCONNECTED */);
+    runtime.emitDisconnected();
+  }
+}
 var logger7 = createLogger("agentforge:tools:data:relational:connection:vendor-init");
 var SAFE_INITIALIZATION_PATTERNS = [
   "Pool max connections must be",
@@ -4354,6 +4407,190 @@ async function initializeSQLiteConnection(connection) {
   return { client, db };
 }
 
+// src/data/relational/connection/connection-initialization.ts
+async function initializeManagedConnection(runtime, logger23) {
+  const startTime = Date.now();
+  const currentGeneration = runtime.getConnectionGeneration();
+  if (runtime.getState() === "connected" /* CONNECTED */ && runtime.getClient()) {
+    logger23.warn("Re-initializing an already connected manager; emitting disconnected before cleanup", {
+      vendor: runtime.vendor
+    });
+    runtime.setState("disconnected" /* DISCONNECTED */);
+    runtime.emitDisconnected();
+    await cleanupConnectionResources(
+      runtime.vendor,
+      runtime.getClient(),
+      () => {
+        runtime.setClient(null);
+        runtime.setDb(null);
+      },
+      logger23
+    );
+  }
+  runtime.setState("connecting" /* CONNECTING */);
+  logger23.info("Initializing database connection", {
+    vendor: runtime.vendor,
+    connectionType: typeof runtime.config.connection,
+    state: runtime.getState()
+  });
+  try {
+    const initialized = await initializeVendorConnection(runtime.config);
+    runtime.setClient(initialized.client);
+    runtime.setDb(initialized.db);
+    if (currentGeneration !== runtime.getConnectionGeneration()) {
+      logger23.debug("Connection cancelled during initialization", {
+        vendor: runtime.vendor,
+        currentGeneration,
+        newGeneration: runtime.getConnectionGeneration()
+      });
+      await cleanupConnectionResources(
+        runtime.vendor,
+        runtime.getClient(),
+        () => {
+          runtime.setClient(null);
+          runtime.setDb(null);
+        },
+        logger23
+      );
+      runtime.setState("disconnected" /* DISCONNECTED */);
+      throw new Error("Connection cancelled during initialization");
+    }
+    logger23.debug("Validating connection health", { vendor: runtime.vendor });
+    const healthy = await runtime.isHealthy();
+    if (!healthy) {
+      throw new Error(`Failed to establish healthy connection to ${runtime.vendor} database`);
+    }
+    if (currentGeneration !== runtime.getConnectionGeneration()) {
+      logger23.debug("Connection cancelled during health check", {
+        vendor: runtime.vendor,
+        currentGeneration,
+        newGeneration: runtime.getConnectionGeneration()
+      });
+      await cleanupConnectionResources(
+        runtime.vendor,
+        runtime.getClient(),
+        () => {
+          runtime.setClient(null);
+          runtime.setDb(null);
+        },
+        logger23
+      );
+      runtime.setState("disconnected" /* DISCONNECTED */);
+      throw new Error("Connection cancelled during health check");
+    }
+    runtime.setState("connected" /* CONNECTED */);
+    runtime.emitConnected();
+    runtime.resetReconnectionAttempts();
+    logger23.info("Database connection initialized successfully", {
+      vendor: runtime.vendor,
+      duration: Date.now() - startTime,
+      state: runtime.getState()
+    });
+  } catch (error) {
+    const errorMessage = `Failed to initialize ${runtime.vendor} connection`;
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    const isValidationError = SAFE_INITIALIZATION_PATTERNS.some(
+      (pattern) => normalizedError.message.includes(pattern)
+    );
+    if (isValidationError) {
+      runtime.setState("error" /* ERROR */);
+      throw normalizedError;
+    }
+    const isCancellation = normalizedError.message.includes("Connection cancelled");
+    if (!isCancellation) {
+      runtime.setState("error" /* ERROR */);
+      if (runtime.errorListenerCount() > 0) {
+        runtime.emitError(normalizedError);
+      }
+      logger23.error(errorMessage, {
+        vendor: runtime.vendor,
+        error: normalizedError.message,
+        duration: Date.now() - startTime,
+        state: runtime.getState()
+      });
+      await cleanupConnectionResources(
+        runtime.vendor,
+        runtime.getClient(),
+        () => {
+          runtime.setClient(null);
+          runtime.setDb(null);
+        },
+        logger23
+      );
+      if (runtime.getReconnectionConfig().enabled && currentGeneration === runtime.getConnectionGeneration()) {
+        runtime.scheduleReconnection();
+      }
+    } else {
+      logger23.debug("Connection initialization cancelled", {
+        vendor: runtime.vendor,
+        duration: Date.now() - startTime,
+        state: runtime.getState()
+      });
+    }
+    if (error instanceof Error) {
+      throw new Error(errorMessage, { cause: error });
+    }
+    throw new Error(`${errorMessage}: ${String(error)}`);
+  }
+}
+function isSqliteNonQueryError(error) {
+  if (!(error instanceof Error)) return false;
+  const isSqliteOrTypeError = error.constructor?.name === "SqliteError" || error.name === "SqliteError" || error instanceof TypeError;
+  const hasNonQueryMessage = error.message.includes("does not return data");
+  return isSqliteOrTypeError && hasNonQueryMessage;
+}
+async function checkConnectionHealth(args, logger23) {
+  if (!args.db || !args.client) {
+    logger23.debug("Health check failed: connection not initialized", { vendor: args.vendor });
+    return false;
+  }
+  try {
+    await args.execute(sql`SELECT 1`);
+    logger23.debug("Health check passed", { vendor: args.vendor });
+    return true;
+  } catch (error) {
+    logger23.debug("Health check failed", {
+      vendor: args.vendor,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+function getConnectionPoolMetrics(vendor, client) {
+  if (!client) {
+    return { totalCount: 0, activeCount: 0, idleCount: 0, waitingCount: 0 };
+  }
+  if (vendor === "postgresql") {
+    const pgClient = client;
+    const totalCount2 = pgClient.totalCount || 0;
+    const idleCount = pgClient.idleCount || 0;
+    const waitingCount = pgClient.waitingCount || 0;
+    const activeCount = Math.max(totalCount2 - idleCount, 0);
+    return {
+      totalCount: totalCount2,
+      activeCount,
+      idleCount,
+      waitingCount
+    };
+  }
+  if (vendor === "mysql") {
+    return {
+      totalCount: 0,
+      activeCount: 0,
+      idleCount: 0,
+      waitingCount: 0
+    };
+  }
+  const sqliteClient = client;
+  const totalCount = sqliteClient.open ? 1 : 0;
+  return {
+    totalCount,
+    activeCount: totalCount,
+    idleCount: 0,
+    waitingCount: 0
+  };
+}
+
 // src/data/relational/connection/query-execution.ts
 async function executeQuery(context, query, logger23) {
   logger23.debug("Executing SQL query", {
@@ -4373,11 +4610,11 @@ async function executeQuery(context, query, logger23) {
   }
   return context.db.execute(query);
 }
-async function executeSqliteQuery(db, query, isSqliteNonQueryError) {
+async function executeSqliteQuery(db, query, isSqliteNonQueryError2) {
   try {
     return db.all(query);
   } catch (error) {
-    if (isSqliteNonQueryError(error)) {
+    if (isSqliteNonQueryError2(error)) {
       const runResult = db.run(query);
       return { ...runResult, affectedRows: runResult.changes ?? 0 };
     }
@@ -4442,11 +4679,6 @@ var ConnectionManager = class extends EventEmitter {
   // Track in-flight connection attempts
   connectionGeneration = 0;
   // Cancellation token for disconnect
-  /**
-   * Create a new ConnectionManager instance
-   * @param config - Connection configuration
-   * @param reconnectionConfig - Optional reconnection configuration
-   */
   constructor(config, reconnectionConfig) {
     super();
     this.config = config;
@@ -4459,11 +4691,6 @@ var ConnectionManager = class extends EventEmitter {
     };
     checkPeerDependency(this.vendor);
   }
-  /**
-   * Connect to the database
-   * Initializes the connection and sets up automatic reconnection if configured
-   * @throws {Error} If connection fails or configuration is invalid
-   */
   async connect() {
     if (this.state === "connected" /* CONNECTED */) {
       logger8.debug("Already connected", { vendor: this.vendor });
@@ -4487,13 +4714,6 @@ var ConnectionManager = class extends EventEmitter {
     });
     return this.connectPromise;
   }
-  /**
-   * Disconnect from the database
-   * Closes the connection and cancels any pending reconnection attempts
-   *
-   * Note: Event listeners are NOT removed by this method. If you need to dispose
-   * of the ConnectionManager instance entirely, call dispose() instead.
-   */
   async disconnect() {
     this.connectionGeneration++;
     this.reconnectionTimer = cancelPendingReconnection(
@@ -4511,142 +4731,22 @@ var ConnectionManager = class extends EventEmitter {
     );
     await this.close();
   }
-  /**
-   * Dispose of the ConnectionManager instance
-   * Disconnects and removes all event listeners
-   * Call this when you're done with the ConnectionManager and won't reuse it
-   */
   async dispose() {
     await this.disconnect();
     this.removeAllListeners();
   }
-  /**
-   * Check if the connection is currently connected
-   * @returns true if connected, false otherwise
-   */
   isConnected() {
     return this.state === "connected" /* CONNECTED */;
   }
-  /**
-   * Get the current connection state
-   * @returns Current connection state
-   */
   getState() {
     return this.state;
   }
-  /**
-   * Get the configured database vendor.
-   */
   getVendor() {
     return this.vendor;
   }
-  /**
-   * Initialize the database connection
-   *
-   * This method is public to maintain compatibility with the DatabaseConnection interface
-   * and existing code (e.g., relational-query.ts). For new code, prefer using connect()
-   * which provides lifecycle management and automatic reconnection.
-   *
-   * @throws {Error} If connection fails or configuration is invalid
-   */
   async initialize() {
-    const startTime = Date.now();
-    const currentGeneration = this.connectionGeneration;
-    if (this.state === "connected" /* CONNECTED */ && this.client) {
-      logger8.warn("Re-initializing an already connected manager; emitting disconnected before cleanup", {
-        vendor: this.vendor
-      });
-      this.setState("disconnected" /* DISCONNECTED */);
-      this.emit("disconnected");
-      await this.cleanupCancelledConnection();
-    }
-    this.setState("connecting" /* CONNECTING */);
-    logger8.info("Initializing database connection", {
-      vendor: this.vendor,
-      connectionType: typeof this.config.connection,
-      state: this.state
-    });
-    try {
-      const initialized = await initializeVendorConnection(this.config);
-      this.client = initialized.client;
-      this.db = initialized.db;
-      if (currentGeneration !== this.connectionGeneration) {
-        logger8.debug("Connection cancelled during initialization", {
-          vendor: this.vendor,
-          currentGeneration,
-          newGeneration: this.connectionGeneration
-        });
-        await this.cleanupCancelledConnection();
-        this.setState("disconnected" /* DISCONNECTED */);
-        throw new Error("Connection cancelled during initialization");
-      }
-      logger8.debug("Validating connection health", { vendor: this.vendor });
-      const healthy = await this.isHealthy();
-      if (!healthy) {
-        throw new Error(`Failed to establish healthy connection to ${this.vendor} database`);
-      }
-      if (currentGeneration !== this.connectionGeneration) {
-        logger8.debug("Connection cancelled during health check", {
-          vendor: this.vendor,
-          currentGeneration,
-          newGeneration: this.connectionGeneration
-        });
-        await this.cleanupCancelledConnection();
-        this.setState("disconnected" /* DISCONNECTED */);
-        throw new Error("Connection cancelled during health check");
-      }
-      this.setState("connected" /* CONNECTED */);
-      this.emit("connected");
-      this.reconnectionAttempts = 0;
-      logger8.info("Database connection initialized successfully", {
-        vendor: this.vendor,
-        duration: Date.now() - startTime,
-        state: this.state
-      });
-    } catch (error) {
-      const errorMessage = `Failed to initialize ${this.vendor} connection`;
-      const normalizedError = error instanceof Error ? error : new Error(String(error));
-      const isValidationError = SAFE_INITIALIZATION_PATTERNS.some(
-        (pattern) => normalizedError.message.includes(pattern)
-      );
-      if (isValidationError) {
-        this.setState("error" /* ERROR */);
-        throw normalizedError;
-      }
-      const isCancellation = normalizedError.message.includes("Connection cancelled");
-      if (!isCancellation) {
-        this.setState("error" /* ERROR */);
-        if (this.listenerCount("error") > 0) {
-          this.emit("error", normalizedError);
-        }
-        logger8.error(errorMessage, {
-          vendor: this.vendor,
-          error: normalizedError.message,
-          duration: Date.now() - startTime,
-          state: this.state
-        });
-        await this.cleanupCancelledConnection();
-        if (this.reconnectionConfig.enabled && currentGeneration === this.connectionGeneration) {
-          this.scheduleReconnection();
-        }
-      } else {
-        logger8.debug("Connection initialization cancelled", {
-          vendor: this.vendor,
-          duration: Date.now() - startTime,
-          state: this.state
-        });
-      }
-      if (error instanceof Error) {
-        throw new Error(errorMessage, { cause: error });
-      }
-      throw new Error(`${errorMessage}: ${String(error)}`);
-    }
+    return initializeManagedConnection(this.createRuntimeAdapter(), logger8);
   }
-  /**
-   * Set the connection state and log the change
-   * @param newState - New connection state
-   * @private
-   */
   setState(newState) {
     const oldState = this.state;
     this.state = newState;
@@ -4658,10 +4758,6 @@ var ConnectionManager = class extends EventEmitter {
       });
     }
   }
-  /**
-   * Schedule a reconnection attempt with exponential backoff
-   * @private
-   */
   scheduleReconnection() {
     scheduleReconnection(
       {
@@ -4688,40 +4784,39 @@ var ConnectionManager = class extends EventEmitter {
       logger8
     );
   }
-  /**
-   * Determine whether an error thrown by drizzle-orm's better-sqlite3 adapter
-   * `.all()` indicates the statement does not return data (i.e. it is DML/DDL,
-   * not a SELECT).
-   *
-   * The adapter may surface this as either a native `SqliteError` or a
-   * `TypeError` depending on the drizzle-orm / better-sqlite3 version, so we
-   * accept both types while still requiring the distinctive message substring
-   * to avoid false positives from unrelated errors.
-   */
-  isSqliteNonQueryError(error) {
-    if (!(error instanceof Error)) return false;
-    const isSqliteOrTypeError = error.constructor?.name === "SqliteError" || error.name === "SqliteError" || error instanceof TypeError;
-    const hasNonQueryMessage = error.message.includes("does not return data");
-    return isSqliteOrTypeError && hasNonQueryMessage;
+  createRuntimeAdapter() {
+    return {
+      vendor: this.vendor,
+      config: this.config,
+      getState: () => this.state,
+      setState: (state) => this.setState(state),
+      getClient: () => this.client,
+      setClient: (client) => {
+        this.client = client;
+      },
+      getDb: () => this.db,
+      setDb: (db) => {
+        this.db = db;
+      },
+      emitConnected: () => {
+        this.emit("connected");
+      },
+      emitDisconnected: () => {
+        this.emit("disconnected");
+      },
+      emitError: (error) => {
+        this.emit("error", error);
+      },
+      errorListenerCount: () => this.listenerCount("error"),
+      getReconnectionConfig: () => this.reconnectionConfig,
+      scheduleReconnection: () => this.scheduleReconnection(),
+      resetReconnectionAttempts: () => {
+        this.reconnectionAttempts = 0;
+      },
+      getConnectionGeneration: () => this.connectionGeneration,
+      isHealthy: () => this.isHealthy()
+    };
   }
-  /**
-   * Execute a SQL query
-   *
-   * Executes a parameterized SQL query using Drizzle's SQL template objects.
-   * This method provides safe parameter binding to prevent SQL injection.
-   *
-   * @param query - Drizzle SQL template object with parameter binding
-   * @returns Query result
-   *
-   * @example
-   * ```typescript
-   * import { sql } from 'drizzle-orm';
-   *
-   * const result = await manager.execute(
-   *   sql`SELECT * FROM users WHERE id = ${userId}`
-   * );
-   * ```
-   */
   async execute(query) {
     if (!this.db) {
       throw new Error("Database not initialized. Call initialize() first.");
@@ -4730,18 +4825,12 @@ var ConnectionManager = class extends EventEmitter {
       {
         vendor: this.vendor,
         db: this.db,
-        isSqliteNonQueryError: (error) => this.isSqliteNonQueryError(error)
+        isSqliteNonQueryError
       },
       query,
       logger8
     );
   }
-  /**
-   * Execute a callback with a single dedicated database connection/session.
-   *
-   * This is required for multi-statement transactions so all statements run on
-   * the same underlying connection.
-   */
   async executeInConnection(callback) {
     if (!this.client || !this.db) {
       throw new Error("Database not initialized. Call connect() first.");
@@ -4751,65 +4840,14 @@ var ConnectionManager = class extends EventEmitter {
         vendor: this.vendor,
         client: this.client,
         db: this.db,
-        isSqliteNonQueryError: (error) => this.isSqliteNonQueryError(error)
+        isSqliteNonQueryError
       },
       callback
     );
   }
-  /**
-   * Get connection pool metrics
-   *
-   * Returns information about the current state of the connection pool.
-   * For SQLite, returns basic connection status since it uses a single connection.
-   *
-   * @returns Pool metrics including total, active, idle, and waiting connections
-   */
   getPoolMetrics() {
-    if (!this.client) {
-      return { totalCount: 0, activeCount: 0, idleCount: 0, waitingCount: 0 };
-    }
-    if (this.vendor === "postgresql") {
-      const totalCount = this.client.totalCount || 0;
-      const idleCount = this.client.idleCount || 0;
-      const waitingCount = this.client.waitingCount || 0;
-      const activeCount = Math.max(totalCount - idleCount, 0);
-      return {
-        totalCount,
-        activeCount,
-        idleCount,
-        waitingCount
-      };
-    } else if (this.vendor === "mysql") {
-      return {
-        totalCount: 0,
-        activeCount: 0,
-        idleCount: 0,
-        waitingCount: 0
-      };
-    } else {
-      const totalCount = this.client.open ? 1 : 0;
-      const idleCount = 0;
-      const waitingCount = 0;
-      const activeCount = this.client.open ? 1 : 0;
-      return {
-        totalCount,
-        activeCount,
-        idleCount,
-        waitingCount
-      };
-    }
+    return getConnectionPoolMetrics(this.vendor, this.client);
   }
-  /**
-   * Close the database connection
-   *
-   * This method is public to maintain compatibility with the DatabaseConnection interface
-   * and existing code (e.g., relational-query.ts). For new code, prefer using disconnect()
-   * for connection lifecycle management. Note that disconnect() does NOT clean up event
-   * listeners; call dispose() if you need full cleanup including listener removal.
-   *
-   * Note: This method coordinates with in-flight connect()/initialize() operations
-   * and cancels pending reconnection timers to prevent unexpected reconnections.
-   */
   async close() {
     this.connectionGeneration++;
     this.reconnectionTimer = cancelPendingReconnection(
@@ -4824,80 +4862,38 @@ var ConnectionManager = class extends EventEmitter {
       this.vendor,
       "close"
     );
-    if (this.client) {
-      logger8.info("Closing database connection", {
-        vendor: this.vendor,
-        state: this.state
-      });
-      try {
-        await shutdownClient(this.vendor, this.client);
-        this.setState("disconnected" /* DISCONNECTED */);
-        this.emit("disconnected");
-        logger8.debug("Database connection closed successfully", {
-          vendor: this.vendor,
-          state: this.state
-        });
-      } catch (error) {
-        logger8.error("Error closing database connection", {
-          vendor: this.vendor,
-          error: error instanceof Error ? error.message : String(error),
-          state: this.state
-        });
-        const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.setState("error" /* ERROR */);
-        this.emit("error", normalizedError);
-      } finally {
-        this.client = null;
-        this.db = null;
-      }
-    } else if (this.state !== "disconnected" /* DISCONNECTED */) {
-      this.setState("disconnected" /* DISCONNECTED */);
-      this.emit("disconnected");
-    }
-  }
-  /**
-   * Clean up resources when a connection is cancelled during initialization
-   * This prevents connection leaks when disconnect() is called while initialize() is in-flight
-   */
-  async cleanupCancelledConnection() {
-    if (!this.client) {
-      return;
-    }
-    logger8.debug("Cleaning up cancelled connection", {
-      vendor: this.vendor
-    });
-    try {
-      await shutdownClient(this.vendor, this.client);
-    } catch (error) {
-      logger8.debug("Error during cancelled connection cleanup", {
+    await closeManagedConnection(
+      {
         vendor: this.vendor,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    } finally {
-      this.client = null;
-      this.db = null;
-    }
+        getState: () => this.state,
+        setState: (state) => this.setState(state),
+        getClient: () => this.client,
+        setClient: (client) => {
+          this.client = client;
+        },
+        setDb: (db) => {
+          this.db = db;
+        },
+        emitDisconnected: () => {
+          this.emit("disconnected");
+        },
+        emitError: (error) => {
+          this.emit("error", error);
+        }
+      },
+      logger8
+    );
   }
-  /**
-   * Check if the connection is healthy
-   * @returns true if connection is healthy, false otherwise
-   */
   async isHealthy() {
-    if (!this.db || !this.client) {
-      logger8.debug("Health check failed: connection not initialized", { vendor: this.vendor });
-      return false;
-    }
-    try {
-      await this.execute(sql`SELECT 1`);
-      logger8.debug("Health check passed", { vendor: this.vendor });
-      return true;
-    } catch (error) {
-      logger8.debug("Health check failed", {
+    return checkConnectionHealth(
+      {
         vendor: this.vendor,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return false;
-    }
+        db: this.db,
+        client: this.client,
+        execute: (query) => this.execute(query)
+      },
+      logger8
+    );
   }
 };
 var logger9 = createLogger("agentforge:tools:data:relational:query");