@carllee1983/dbcli 1.52.0 → 1.53.0

package/dist/core.d.ts

@@ -3010,6 +3010,10 @@ export declare class DataExecutor {
 	 * Get identifier quote character (for table names and column names)
 	 */
 	private getQuoteChar;
+	private checkBlacklist;
+	private executeMutation;
+	private successResult;
+	private handleMutationError;
 	/**
 	 * Build a parameterized UPDATE SQL statement
 	 */

package/dist/core.mjs

@@ -13639,6 +13639,23 @@ function mapError(error, system, options) {
   ]);
 }
 
+// src/adapters/sql-adapter-utils.ts
+function requireConnected(connection) {
+  if (!connection) {
+    throw new ConnectionError("UNKNOWN", "Database connection not established", [
+      "Call connect() to establish a connection"
+    ]);
+  }
+  return connection;
+}
+async function withMappedConnectionError(system, options, operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw mapError(error, system, options);
+  }
+}
+
 // src/adapters/postgresql-adapter.ts
 import { Pool } from "pg";
 // resources/lang/en/messages.json
@@ -14461,7 +14478,7 @@ class PostgreSQLAdapter {
     }
   }
   async connect() {
-    try {
+    await withMappedConnectionError("postgresql", this.options, async () => {
       this.pool = new Pool({
         host: this.options.host,
         port: this.options.port,
@@ -14477,9 +14494,7 @@ class PostgreSQLAdapter {
         const result = checkDbVersion(rawVersion, "postgresql");
         warnIfUnsupported(result);
       } catch {}
-    } catch (error) {
-      throw mapError(error, "postgresql", this.options);
-    }
+    });
   }
   async disconnect() {
     try {
@@ -14494,45 +14509,29 @@ class PostgreSQLAdapter {
     } catch {}
   }
   async testConnection() {
-    if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
+    requireConnected(this.pool);
+    return withMappedConnectionError("postgresql", this.options, async () => {
       const result = await this.execute("SELECT 1 as count");
       return result.rows.length > 0;
-    } catch (error) {
-      throw mapError(error, "postgresql", this.options);
-    }
+    });
   }
   async execute(sql, params) {
-    if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
-      const result = params ? await this.pool.query(sql, params) : await this.pool.query(sql);
+    const pool = requireConnected(this.pool);
+    return withMappedConnectionError("postgresql", this.options, async () => {
+      const result = params ? await pool.query(sql, params) : await pool.query(sql);
       return {
         rows: result.rows,
         affectedRows: result.rowCount ?? 0
       };
-    } catch (error) {
-      throw mapError(error, "postgresql", this.options);
-    }
+    });
   }
   async getServerVersion() {
     const result = await this.execute("SHOW server_version");
     return result.rows[0]?.server_version ?? "unknown";
   }
   async listTables() {
-    if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
+    requireConnected(this.pool);
+    return withMappedConnectionError("postgresql", this.options, async () => {
       const query = `
         SELECT
           n.nspname as schema_name,
@@ -14563,17 +14562,11 @@ class PostgreSQLAdapter {
         estimatedRowCount: Math.max(0, row.estimated_rows || 0),
         tableType: row.table_type
       }));
-    } catch (error) {
-      throw mapError(error, "postgresql", this.options);
-    }
+    });
   }
   async getTableSchema(tableName) {
-    if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
+    requireConnected(this.pool);
+    return withMappedConnectionError("postgresql", this.options, async () => {
       const columnQuery = `
         SELECT
           c.column_name as name,
@@ -14760,9 +14753,7 @@ class PostgreSQLAdapter {
         estimatedRowCount: Math.max(0, estimateResults[0]?.estimated_rows || 0)
       };
       return schema;
-    } catch (error) {
-      throw mapError(error, "postgresql", this.options);
-    }
+    });
   }
 }
 
@@ -14787,7 +14778,7 @@ class MySQLAdapter {
     }
   }
   async connect() {
-    try {
+    await withMappedConnectionError(this.system, this.options, async () => {
       this.db = await mysql.createConnection({
         host: this.options.host,
         port: this.options.port,
@@ -14803,9 +14794,7 @@ class MySQLAdapter {
         const result = checkDbVersion(rawVersion, this.system);
         warnIfUnsupported(result);
       } catch {}
-    } catch (error) {
-      throw mapError(error, this.system, this.options);
-    }
+    });
   }
   async disconnect() {
     try {
@@ -14816,26 +14805,16 @@ class MySQLAdapter {
     } catch {}
   }
   async testConnection() {
-    if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
+    requireConnected(this.db);
+    return withMappedConnectionError(this.system, this.options, async () => {
       const result = await this.execute("SELECT 1 as count");
       return result.rows.length > 0;
-    } catch (error) {
-      throw mapError(error, this.system, this.options);
-    }
+    });
   }
   async execute(sql, params) {
-    if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
-      const [result] = params ? await this.db.execute(sql, params) : await this.db.execute(sql);
+    const db = requireConnected(this.db);
+    return withMappedConnectionError(this.system, this.options, async () => {
+      const [result] = params ? await db.execute(sql, params) : await db.execute(sql);
       if (Array.isArray(result)) {
         return {
           rows: result,
@@ -14848,21 +14827,15 @@ class MySQLAdapter {
         affectedRows: header.affectedRows || 0,
         lastInsertId: header.insertId
       };
-    } catch (error) {
-      throw mapError(error, this.system, this.options);
-    }
+    });
   }
   async getServerVersion() {
     const result = await this.execute("SELECT VERSION() as version");
     return result.rows[0]?.version ?? "unknown";
   }
   async listTables() {
-    if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
+    requireConnected(this.db);
+    return withMappedConnectionError(this.system, this.options, async () => {
       const query = `
         SELECT
           t.TABLE_NAME as table_name,
@@ -14887,17 +14860,11 @@ class MySQLAdapter {
         estimatedRowCount: row.row_count || 0,
         tableType: row.table_type === "VIEW" ? "view" : "table"
       }));
-    } catch (error) {
-      throw mapError(error, this.system, this.options);
-    }
+    });
   }
   async getTableSchema(tableName) {
-    if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "Database connection not established", [
-        "Call connect() to establish a connection"
-      ]);
-    }
-    try {
+    requireConnected(this.db);
+    return withMappedConnectionError(this.system, this.options, async () => {
       const columnQuery = `
         SELECT
           COLUMN_NAME as name,
@@ -14997,9 +14964,7 @@ class MySQLAdapter {
         estimatedRowCount: estimateResults[0]?.estimated_rows || 0
       };
       return schema;
-    } catch (error) {
-      throw mapError(error, this.system, this.options);
-    }
+    });
   }
 }
 
@@ -22937,7 +22902,7 @@ DBCLI_PASSWORD=${password}
 };
 
 // src/utils/redaction.ts
-var SQL_SUBCOMMANDS = new Set(["query", "export", "lint"]);
+var SQL_SUBCOMMANDS = new Set(["query", "export", "lint", "assert", "verify"]);
 var REDACTED_VALUE_FLAGS = new Set([
   "--where",
   "--set",
@@ -22951,6 +22916,12 @@ var REDACTED_VALUE_FLAGS = new Set([
   "--secret",
   "--bulk",
   "--query-file",
+  "--expect",
+  "--vs",
+  "--against",
+  "--verification-subject",
+  "--verification-summary",
+  "--evidence-receipt",
   "-f"
 ]);
 var KEEP_VALUE_FLAGS = new Set([
@@ -22967,6 +22938,22 @@ var KEEP_VALUE_FLAGS = new Set([
 ]);
 var LINT_BOOLEAN_FLAGS = new Set(["--no-schema", "--recovery"]);
 var QUERY_BOOLEAN_FLAGS = new Set(["--ui", "--no-limit", "--no-truncate", "--recovery"]);
+var ASSERT_BOOLEAN_FLAGS = new Set(["--no-fail", "--write-verification-artifact"]);
+var VERIFY_REDACTED_VALUE_FLAGS = new Set([
+  "--table",
+  "--query",
+  "--verify-query",
+  "--ddl",
+  "--statement",
+  "--check",
+  "--column",
+  "--references",
+  "--violation-query",
+  "--subject-name",
+  "--summary",
+  "--baseline"
+]);
+var VERIFY_BOOLEAN_FLAGS = new Set(["--after-write", "--allow-preexisting"]);
 function optionParts(token) {
   if (token.startsWith("-f") && !token.startsWith("--") && token.length > 2) {
     return { name: "-f", inlineValue: token.slice(2) };
@@ -22982,14 +22969,21 @@ function isKnownBooleanFlag(command, name) {
     return LINT_BOOLEAN_FLAGS.has(name);
   if (command === "query")
     return QUERY_BOOLEAN_FLAGS.has(name);
+  if (command === "assert")
+    return ASSERT_BOOLEAN_FLAGS.has(name);
+  if (command === "verify")
+    return VERIFY_BOOLEAN_FLAGS.has(name);
   return false;
 }
+function isRedactedValueFlag(command, name) {
+  return REDACTED_VALUE_FLAGS.has(name) || command === "verify" && VERIFY_REDACTED_VALUE_FLAGS.has(name);
+}
 function findSensitiveSubcommand(argv) {
   for (let index = 1;index < argv.length; index++) {
     const token = argv[index];
     if (isOptionToken(token)) {
       const { name, inlineValue } = optionParts(token);
-      if (inlineValue === undefined && (REDACTED_VALUE_FLAGS.has(name) || KEEP_VALUE_FLAGS.has(name))) {
+      if (inlineValue === undefined && (isRedactedValueFlag(undefined, name) || KEEP_VALUE_FLAGS.has(name))) {
         index++;
       }
       continue;
@@ -23003,6 +22997,7 @@ function sensitiveArgvValues(argv) {
   const sensitiveCommand = findSensitiveSubcommand(argv);
   const values = new Set;
   let capturedSingleSql = false;
+  let verifyScenarioSeen = false;
   let afterEndOfOptions = false;
   for (let index = 0;index < argv.length; index++) {
     const token = argv[index];
@@ -23012,7 +23007,7 @@ function sensitiveArgvValues(argv) {
     }
     if (!afterEndOfOptions && isOptionToken(token)) {
       const { name, inlineValue } = optionParts(token);
-      if (REDACTED_VALUE_FLAGS.has(name)) {
+      if (isRedactedValueFlag(sensitiveCommand?.command, name)) {
         const value = inlineValue ?? argv[index + 1];
         if (value) {
           values.add(value);
@@ -23039,6 +23034,10 @@ function sensitiveArgvValues(argv) {
       }
       continue;
     }
+    if (sensitiveCommand?.command === "verify" && index > sensitiveCommand.index && !verifyScenarioSeen) {
+      verifyScenarioSeen = true;
+      continue;
+    }
     if (sensitiveCommand && index > sensitiveCommand.index && (sensitiveCommand.command === "lint" || !capturedSingleSql)) {
       values.add(token);
       capturedSingleSql = true;
@@ -23052,6 +23051,7 @@ function redactArgv(argv) {
   const sensitiveCommand = findSensitiveSubcommand(argv);
   const out = [];
   let redactedSingleSql = false;
+  let verifyScenarioSeen = false;
   let afterEndOfOptions = false;
   for (let i = 0;i < argv.length; i++) {
     const tok = argv[i];
@@ -23062,7 +23062,7 @@ function redactArgv(argv) {
     }
     if (!afterEndOfOptions && isOptionToken(tok)) {
       const { name, inlineValue } = optionParts(tok);
-      if (REDACTED_VALUE_FLAGS.has(name)) {
+      if (isRedactedValueFlag(sensitiveCommand?.command, name)) {
         out.push(`${name} <redacted>`);
         if (inlineValue === undefined)
           i++;
@@ -23088,6 +23088,11 @@ function redactArgv(argv) {
         continue;
       }
     }
+    if (sensitiveCommand?.command === "verify" && i > sensitiveCommand.index && !verifyScenarioSeen) {
+      out.push(tok);
+      verifyScenarioSeen = true;
+      continue;
+    }
     if (sensitiveCommand && i > sensitiveCommand.index && (sensitiveCommand.command === "lint" || !redactedSingleSql)) {
       out.push("<sql>");
       redactedSingleSql = true;
@@ -23650,141 +23655,27 @@ class DataExecutor {
   async executeInsert(tableName, data, schema, options) {
     const timestamp = new Date().toISOString();
     try {
-      if (this.blacklistValidator) {
-        this.blacklistValidator.checkTableBlacklist("INSERT", tableName, []);
-      }
+      this.checkBlacklist("INSERT", tableName);
       enforcePermission("INSERT INTO dummy", this.permission);
-      const { sql, params } = this.buildInsertSql(tableName, data, schema);
-      if (options?.dryRun) {
-        return {
-          status: "success",
-          operation: "insert",
-          rows_affected: 0,
-          timestamp,
-          sql
-        };
-      }
-      if (!options?.force) {
-        console.log(`
-Generated SQL:`);
-        console.log(`  ${sql}`);
-        console.log(`
-Parameters:`);
-        console.log(`  ${JSON.stringify(params, null, 2)}`);
-        const confirmed = await promptUser.confirm("Proceed with this operation?");
-        if (!confirmed) {
-          return {
-            status: "success",
-            operation: "insert",
-            rows_affected: 0,
-            timestamp,
-            sql
-          };
-        }
-      }
-      const result = await this.adapter.execute(sql, params);
-      return {
-        status: "success",
-        operation: "insert",
-        rows_affected: result.affectedRows,
-        timestamp,
-        sql
-      };
+      return await this.executeMutation("insert", this.buildInsertSql(tableName, data, schema), timestamp, options, { prompt: "Proceed with this operation?" });
     } catch (error) {
-      if (error instanceof BlacklistError) {
-        throw error;
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (error instanceof PermissionError) {
-        return {
-          status: "error",
-          operation: "insert",
-          rows_affected: 0,
-          timestamp,
-          error: "Permission denied: Query-only mode only allows SELECT. Use Read-Write or Admin mode to execute INSERT."
-        };
-      }
-      return {
-        status: "error",
-        operation: "insert",
-        rows_affected: 0,
-        timestamp,
-        error: `INSERT failed: ${errorMessage}`
-      };
+      return this.handleMutationError("insert", timestamp, error);
     }
   }
   async executeUpdate(tableName, data, where, schema, options) {
     const timestamp = new Date().toISOString();
     try {
-      if (this.blacklistValidator) {
-        this.blacklistValidator.checkTableBlacklist("UPDATE", tableName, []);
-      }
+      this.checkBlacklist("UPDATE", tableName);
       enforcePermission("UPDATE dummy", this.permission);
-      const { sql, params } = this.buildUpdateSql(tableName, data, where, schema);
-      if (options?.dryRun) {
-        return {
-          status: "success",
-          operation: "update",
-          rows_affected: 0,
-          timestamp,
-          sql
-        };
-      }
-      if (!options?.force) {
-        console.log(`
-Generated SQL:`);
-        console.log(`  ${sql}`);
-        console.log(`
-Parameters:`);
-        console.log(`  ${JSON.stringify(params, null, 2)}`);
-        const confirmed = await promptUser.confirm("Proceed with this operation?");
-        if (!confirmed) {
-          return {
-            status: "success",
-            operation: "update",
-            rows_affected: 0,
-            timestamp,
-            sql
-          };
-        }
-      }
-      const result = await this.adapter.execute(sql, params);
-      return {
-        status: "success",
-        operation: "update",
-        rows_affected: result.affectedRows,
-        timestamp,
-        sql
-      };
+      return await this.executeMutation("update", this.buildUpdateSql(tableName, data, where, schema), timestamp, options, { prompt: "Proceed with this operation?" });
     } catch (error) {
-      if (error instanceof BlacklistError) {
-        throw error;
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (error instanceof PermissionError) {
-        return {
-          status: "error",
-          operation: "update",
-          rows_affected: 0,
-          timestamp,
-          error: "Permission denied: Query-only mode only allows SELECT. Use Read-Write or Admin mode to execute UPDATE."
-        };
-      }
-      return {
-        status: "error",
-        operation: "update",
-        rows_affected: 0,
-        timestamp,
-        error: `UPDATE failed: ${errorMessage}`
-      };
+      return this.handleMutationError("update", timestamp, error);
     }
   }
   async executeDelete(tableName, where, schema, options) {
     const timestamp = new Date().toISOString();
     try {
-      if (this.blacklistValidator) {
-        this.blacklistValidator.checkTableBlacklist("DELETE", tableName, []);
-      }
+      this.checkBlacklist("DELETE", tableName);
       if (this.permission !== "data-admin" && this.permission !== "admin") {
         return {
           status: "error",
@@ -23794,63 +23685,75 @@ Parameters:`);
           error: "Permission denied: DELETE operation requires Data-Admin or Admin permission."
         };
       }
-      const { sql, params } = this.buildDeleteSql(tableName, where, schema);
-      if (options?.dryRun) {
-        return {
-          status: "success",
-          operation: "delete",
-          rows_affected: 0,
-          timestamp,
-          sql
-        };
-      }
-      if (!options?.force) {
-        console.log(`
-\u26A0\uFE0F  Warning: DELETE operation is destructive and cannot be undone!`);
+      return await this.executeMutation("delete", this.buildDeleteSql(tableName, where, schema), timestamp, options, {
+        warning: "\u26A0\uFE0F  Warning: DELETE operation is destructive and cannot be undone!",
+        prompt: "Are you sure you want to execute this DELETE operation? This cannot be undone."
+      });
+    } catch (error) {
+      return this.handleMutationError("delete", timestamp, error);
+    }
+  }
+  getSystemType() {
+    return this.dbSystem;
+  }
+  getQuoteChar() {
+    return this.dbSystem === "mysql" ? "`" : '"';
+  }
+  checkBlacklist(operation, tableName) {
+    this.blacklistValidator?.checkTableBlacklist(operation, tableName, []);
+  }
+  async executeMutation(operation, statement, timestamp, options, confirmation) {
+    if (options?.dryRun) {
+      return this.successResult(operation, 0, timestamp, statement.sql);
+    }
+    if (!options?.force) {
+      if (confirmation.warning) {
         console.log(`
+${confirmation.warning}`);
+      }
+      console.log(`
 Generated SQL:`);
-        console.log(`  ${sql}`);
-        console.log(`
+      console.log(`  ${statement.sql}`);
+      console.log(`
 Parameters:`);
-        console.log(`  ${JSON.stringify(params, null, 2)}`);
-        const confirmed = await promptUser.confirm("Are you sure you want to execute this DELETE operation? This cannot be undone.");
-        if (!confirmed) {
-          return {
-            status: "success",
-            operation: "delete",
-            rows_affected: 0,
-            timestamp,
-            sql
-          };
-        }
+      console.log(`  ${JSON.stringify(statement.params, null, 2)}`);
+      if (!await promptUser.confirm(confirmation.prompt)) {
+        return this.successResult(operation, 0, timestamp, statement.sql);
       }
-      const result = await this.adapter.execute(sql, params);
-      return {
-        status: "success",
-        operation: "delete",
-        rows_affected: result.affectedRows,
-        timestamp,
-        sql
-      };
-    } catch (error) {
-      if (error instanceof BlacklistError) {
-        throw error;
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
+    }
+    const result = await this.adapter.execute(statement.sql, statement.params);
+    return this.successResult(operation, result.affectedRows, timestamp, statement.sql);
+  }
+  successResult(operation, rowsAffected, timestamp, sql) {
+    return {
+      status: "success",
+      operation,
+      rows_affected: rowsAffected,
+      timestamp,
+      sql
+    };
+  }
+  handleMutationError(operation, timestamp, error) {
+    if (error instanceof BlacklistError) {
+      throw error;
+    }
+    if (error instanceof PermissionError && operation !== "delete") {
       return {
         status: "error",
-        operation: "delete",
+        operation,
         rows_affected: 0,
         timestamp,
-        error: `DELETE failed: ${errorMessage}`
+        error: `Permission denied: Query-only mode only allows SELECT. Use Read-Write or Admin mode to execute ${operation.toUpperCase()}.`
       };
     }
-  }
-  getSystemType() {
-    return this.dbSystem;
-  }
-  getQuoteChar() {
-    return this.dbSystem === "mysql" ? "`" : '"';
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      status: "error",
+      operation,
+      rows_affected: 0,
+      timestamp,
+      error: `${operation.toUpperCase()} failed: ${errorMessage}`
+    };
   }
   buildUpdateSql(tableName, data, where, schema) {
     const dataKeys = Object.keys(data);