@agentforge/tools 0.16.38 → 0.16.40

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");
@@ -5065,11 +5061,9 @@ function rowsHaveHomogeneousColumns(rows) {
 function buildSingleRowInsert(table, row, vendor) {
   const columns = Object.keys(row);
   if (columns.length === 0) {
-    const quotedTable2 = quoteQualifiedIdentifier(table, vendor);
-    return sql.raw(`INSERT INTO ${quotedTable2} DEFAULT VALUES`);
+    return sql.raw(`INSERT INTO ${quoteQualifiedIdentifier(table, vendor)} DEFAULT VALUES`);
   }
   columns.forEach((column) => validateIdentifier(column, "Insert column"));
-  const quotedTable = quoteQualifiedIdentifier(table, vendor);
   const quotedColumns = columns.map((column) => quoteIdentifier(column, vendor)).join(", ");
   const valueFragments = columns.map((column) => {
     const value = row[column];
@@ -5080,7 +5074,9 @@ function buildSingleRowInsert(table, row, vendor) {
   });
   return sql.join(
     [
-      sql.raw(`INSERT INTO ${quotedTable} (${quotedColumns}) VALUES (`),
+      sql.raw(
+        `INSERT INTO ${quoteQualifiedIdentifier(table, vendor)} (${quotedColumns}) VALUES (`
+      ),
       sql.join(valueFragments, sql.raw(", ")),
       sql.raw(")")
     ],
@@ -5091,12 +5087,13 @@ function buildInsertValuesQuery(table, columns, rows, vendor) {
   if (vendor === "sqlite" && !rowsHaveHomogeneousColumns(rows)) {
     return rows.map((row) => buildSingleRowInsert(table, row, vendor));
   }
-  const quotedTable = quoteQualifiedIdentifier(table, vendor);
   const quotedColumns = columns.map((column) => quoteIdentifier(column, vendor)).join(", ");
   const rowTuples = rows.map((row) => buildValuesTuple(columns, row));
   return sql.join(
     [
-      sql.raw(`INSERT INTO ${quotedTable} (${quotedColumns}) VALUES `),
+      sql.raw(
+        `INSERT INTO ${quoteQualifiedIdentifier(table, vendor)} (${quotedColumns}) VALUES `
+      ),
       sql.join(rowTuples, sql.raw(", "))
     ],
     sql.raw("")
@@ -5106,8 +5103,7 @@ function buildInsertDefaultValuesQuery(table, rowCount, vendor) {
   if (rowCount > 1) {
     throw new Error("Batch INSERT with only DEFAULT VALUES is not supported");
   }
-  const quotedTable = quoteQualifiedIdentifier(table, vendor);
-  return sql.raw(`INSERT INTO ${quotedTable} DEFAULT VALUES`);
+  return sql.raw(`INSERT INTO ${quoteQualifiedIdentifier(table, vendor)} DEFAULT VALUES`);
 }
 function buildInsertQuery(input) {
   validateQualifiedIdentifier(input.table, "Table name");
@@ -5130,9 +5126,7 @@ function buildInsertQuery(input) {
     let queries = valuesResult;
     if (returningMode !== "none" && supportsReturning) {
       const returningClause = returningMode === "id" ? sql.raw(` RETURNING ${quoteIdentifier(idColumn, input.vendor)}`) : sql.raw(" RETURNING *");
-      queries = queries.map(
-        (q) => sql.join([q, returningClause], sql.raw(""))
-      );
+      queries = queries.map((query2) => sql.join([query2, returningClause], sql.raw("")));
     }
     return {
       query: queries,
@@ -5144,14 +5138,10 @@ function buildInsertQuery(input) {
   }
   let query = valuesResult;
   if (returningMode !== "none" && supportsReturning) {
-    if (returningMode === "id") {
-      query = sql.join(
-        [query, sql.raw(` RETURNING ${quoteIdentifier(idColumn, input.vendor)}`)],
-        sql.raw("")
-      );
-    } else {
-      query = sql.join([query, sql.raw(" RETURNING *")], sql.raw(""));
-    }
+    query = returningMode === "id" ? sql.join(
+      [query, sql.raw(` RETURNING ${quoteIdentifier(idColumn, input.vendor)}`)],
+      sql.raw("")
+    ) : sql.join([query, sql.raw(" RETURNING *")], sql.raw(""));
   }
   return {
     query,
@@ -5161,23 +5151,7 @@ function buildInsertQuery(input) {
     supportsReturning
   };
 }
-function normalizeUpdateData(data) {
-  if (!data || typeof data !== "object" || Array.isArray(data)) {
-    throw new Error("Update data must be an object");
-  }
-  const keys = Object.keys(data);
-  if (keys.length === 0) {
-    throw new Error("Update data must not be empty");
-  }
-  keys.forEach((column) => {
-    validateIdentifier(column, "Update column");
-    if (data[column] === void 0) {
-      throw new Error(`Update value for column "${column}" must not be undefined`);
-    }
-  });
-  return data;
-}
-function buildUpdateWhereCondition(condition, vendor) {
+function buildWhereCondition(condition, vendor) {
   validateIdentifier(condition.column, "WHERE column");
   const column = sql.raw(quoteIdentifier(condition.column, vendor));
   switch (condition.operator) {
@@ -5226,12 +5200,12 @@ function buildUpdateWhereCondition(condition, vendor) {
       if (!Array.isArray(condition.value) || condition.value.length === 0) {
         throw new Error(`IN operator requires a non-empty array value for column ${condition.column}`);
       }
-      return sql`${column} IN (${sql.join(condition.value.map((v) => sql`${v}`), sql.raw(", "))})`;
+      return sql`${column} IN (${sql.join(condition.value.map((value) => sql`${value}`), sql.raw(", "))})`;
     case "notIn":
       if (!Array.isArray(condition.value) || condition.value.length === 0) {
         throw new Error(`NOT IN operator requires a non-empty array value for column ${condition.column}`);
       }
-      return sql`${column} NOT IN (${sql.join(condition.value.map((v) => sql`${v}`), sql.raw(", "))})`;
+      return sql`${column} NOT IN (${sql.join(condition.value.map((value) => sql`${value}`), sql.raw(", "))})`;
     case "isNull":
       if (condition.value !== void 0) {
         throw new Error(`IS NULL operator must not include value for column ${condition.column}`);
@@ -5244,6 +5218,24 @@ function buildUpdateWhereCondition(condition, vendor) {
       return sql`${column} IS NOT NULL`;
   }
 }
+
+// src/data/relational/query/query-builder-mutation.ts
+function normalizeUpdateData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Update data must be an object");
+  }
+  const keys = Object.keys(data);
+  if (keys.length === 0) {
+    throw new Error("Update data must not be empty");
+  }
+  keys.forEach((column) => {
+    validateIdentifier(column, "Update column");
+    if (data[column] === void 0) {
+      throw new Error(`Update value for column "${column}" must not be undefined`);
+    }
+  });
+  return data;
+}
 function buildUpdateQuery(input) {
   validateQualifiedIdentifier(input.table, "Table name");
   const normalizedData = normalizeUpdateData(input.data);
@@ -5252,7 +5244,7 @@ function buildUpdateQuery(input) {
     return sql`${quotedColumn} = ${value}`;
   });
   const whereConditions = (input.where ?? []).map(
-    (condition) => buildUpdateWhereCondition(condition, input.vendor)
+    (condition) => buildWhereCondition(condition, input.vendor)
   );
   if (input.optimisticLock) {
     validateIdentifier(input.optimisticLock.column, "Optimistic lock column");
@@ -5263,7 +5255,9 @@ function buildUpdateQuery(input) {
     whereConditions.push(sql`${lockColumn} = ${input.optimisticLock.expectedValue}`);
   }
   if (whereConditions.length === 0 && !input.allowFullTableUpdate) {
-    throw new Error("WHERE conditions are required for UPDATE queries. Set allowFullTableUpdate=true to override.");
+    throw new Error(
+      "WHERE conditions are required for UPDATE queries. Set allowFullTableUpdate=true to override."
+    );
   }
   let query = sql.join(
     [
@@ -5273,7 +5267,10 @@ function buildUpdateQuery(input) {
     sql.raw("")
   );
   if (whereConditions.length > 0) {
-    query = sql.join([query, sql.raw(" WHERE "), sql.join(whereConditions, sql.raw(" AND "))], sql.raw(""));
+    query = sql.join(
+      [query, sql.raw(" WHERE "), sql.join(whereConditions, sql.raw(" AND "))],
+      sql.raw("")
+    );
   }
   return {
     query,
@@ -5284,10 +5281,12 @@ function buildUpdateQuery(input) {
 function buildDeleteQuery(input) {
   validateQualifiedIdentifier(input.table, "Table name");
   const whereConditions = (input.where ?? []).map(
-    (condition) => buildUpdateWhereCondition(condition, input.vendor)
+    (condition) => buildWhereCondition(condition, input.vendor)
   );
   if (whereConditions.length === 0 && !input.allowFullTableDelete) {
-    throw new Error("WHERE conditions are required for DELETE queries. Set allowFullTableDelete=true to override.");
+    throw new Error(
+      "WHERE conditions are required for DELETE queries. Set allowFullTableDelete=true to override."
+    );
   }
   const softDeleteColumn = input.softDelete?.column ?? "deleted_at";
   const softDeleteValue = input.softDelete?.value ?? (/* @__PURE__ */ new Date()).toISOString();
@@ -5306,7 +5305,10 @@ function buildDeleteQuery(input) {
     query = sql.raw(`DELETE FROM ${quoteQualifiedIdentifier(input.table, input.vendor)}`);
   }
   if (whereConditions.length > 0) {
-    query = sql.join([query, sql.raw(" WHERE "), sql.join(whereConditions, sql.raw(" AND "))], sql.raw(""));
+    query = sql.join(
+      [query, sql.raw(" WHERE "), sql.join(whereConditions, sql.raw(" AND "))],
+      sql.raw("")
+    );
   }
   return {
     query,
@@ -5315,73 +5317,6 @@ function buildDeleteQuery(input) {
     softDeleteColumn: input.softDelete ? softDeleteColumn : void 0
   };
 }
-function buildSelectWhereCondition(condition, vendor) {
-  validateIdentifier(condition.column, "WHERE column");
-  const column = sql.raw(quoteIdentifier(condition.column, vendor));
-  switch (condition.operator) {
-    case "eq":
-      if (condition.value === void 0) {
-        throw new Error(`EQ operator requires a value for column ${condition.column}`);
-      }
-      if (condition.value === null) {
-        throw new Error("null is only allowed with isNull/isNotNull operators");
-      }
-      return sql`${column} = ${condition.value}`;
-    case "ne":
-      if (condition.value === void 0) {
-        throw new Error(`NE operator requires a value for column ${condition.column}`);
-      }
-      if (condition.value === null) {
-        throw new Error("null is only allowed with isNull/isNotNull operators");
-      }
-      return sql`${column} != ${condition.value}`;
-    case "gt":
-      if (typeof condition.value !== "string" && typeof condition.value !== "number") {
-        throw new Error(`GT operator requires a string or number value for column ${condition.column}`);
-      }
-      return sql`${column} > ${condition.value}`;
-    case "lt":
-      if (typeof condition.value !== "string" && typeof condition.value !== "number") {
-        throw new Error(`LT operator requires a string or number value for column ${condition.column}`);
-      }
-      return sql`${column} < ${condition.value}`;
-    case "gte":
-      if (typeof condition.value !== "string" && typeof condition.value !== "number") {
-        throw new Error(`GTE operator requires a string or number value for column ${condition.column}`);
-      }
-      return sql`${column} >= ${condition.value}`;
-    case "lte":
-      if (typeof condition.value !== "string" && typeof condition.value !== "number") {
-        throw new Error(`LTE operator requires a string or number value for column ${condition.column}`);
-      }
-      return sql`${column} <= ${condition.value}`;
-    case "like":
-      if (typeof condition.value !== "string") {
-        throw new Error(`LIKE operator requires a string value for column ${condition.column}`);
-      }
-      return sql`${column} LIKE ${condition.value}`;
-    case "in":
-      if (!Array.isArray(condition.value) || condition.value.length === 0) {
-        throw new Error(`IN operator requires a non-empty array value for column ${condition.column}`);
-      }
-      return sql`${column} IN (${sql.join(condition.value.map((v) => sql`${v}`), sql.raw(", "))})`;
-    case "notIn":
-      if (!Array.isArray(condition.value) || condition.value.length === 0) {
-        throw new Error(`NOT IN operator requires a non-empty array value for column ${condition.column}`);
-      }
-      return sql`${column} NOT IN (${sql.join(condition.value.map((v) => sql`${v}`), sql.raw(", "))})`;
-    case "isNull":
-      if (condition.value !== void 0) {
-        throw new Error(`IS NULL operator must not include value for column ${condition.column}`);
-      }
-      return sql`${column} IS NULL`;
-    case "isNotNull":
-      if (condition.value !== void 0) {
-        throw new Error(`IS NOT NULL operator must not include value for column ${condition.column}`);
-      }
-      return sql`${column} IS NOT NULL`;
-  }
-}
 function buildSelectQuery(input) {
   validateQualifiedIdentifier(input.table, "Table name");
   let query = sql.raw("SELECT ");
@@ -5399,7 +5334,9 @@ function buildSelectQuery(input) {
     sql.raw("")
   );
   if (input.where && input.where.length > 0) {
-    const whereConditions = input.where.map((condition) => buildSelectWhereCondition(condition, input.vendor));
+    const whereConditions = input.where.map(
+      (condition) => buildWhereCondition(condition, input.vendor)
+    );
     query = sql.join(
       [query, sql.raw(" WHERE "), sql.join(whereConditions, sql.raw(" AND "))],
       sql.raw("")