@tejasanik/postgres-mcp-server 1.7.0 → 2.0.0

package/dist/tools/sql-tools.js

@@ -26,8 +26,8 @@ export async function executeSql(args) {
     if (!args.allowLargeScript && sql.length > DEFAULT_SQL_LENGTH_LIMIT) {
         throw new Error(`SQL query exceeds ${DEFAULT_SQL_LENGTH_LIMIT} characters. Use allowLargeScript=true for deployment scripts.`);
     }
-    // Validate params if provided
-    if (args.params !== undefined) {
+    // Validate params if provided (only for single statement)
+    if (args.params !== undefined && !args.allowMultipleStatements) {
         if (!Array.isArray(args.params)) {
             throw new Error('params must be an array');
         }
@@ -35,22 +35,46 @@ export async function executeSql(args) {
             throw new Error(`Maximum ${MAX_PARAMS} parameters allowed`);
         }
     }
+    // Params not supported with multiple statements
+    if (args.allowMultipleStatements && args.params && args.params.length > 0) {
+        throw new Error('params not supported with allowMultipleStatements. Use separate execute_sql calls for parameterized queries.');
+    }
     const dbManager = getDbManager();
     const maxRows = validatePositiveInteger(args.maxRows, 'maxRows', 1, MAX_ROWS_LIMIT) || MAX_ROWS_DEFAULT;
     const offset = args.offset !== undefined ? validatePositiveInteger(args.offset, 'offset', 0, Number.MAX_SAFE_INTEGER) : 0;
+    // Get schema hints if requested
+    let schemaHint;
+    if (args.includeSchemaHint) {
+        schemaHint = await getSchemaHintForSql(sql);
+    }
+    // Handle multi-statement execution
+    if (args.allowMultipleStatements) {
+        return executeMultipleStatements(sql, schemaHint, args.transactionId);
+    }
     // Record start time for execution timing
     const startTime = process.hrtime.bigint();
-    // Execute query with optional parameters
-    const result = await dbManager.query(sql, args.params);
+    // Execute query with optional parameters (supports transaction)
+    let result;
+    if (args.transactionId) {
+        result = await dbManager.queryInTransaction(args.transactionId, sql, args.params);
+    }
+    else {
+        result = await dbManager.query(sql, args.params);
+    }
     // Calculate execution time in milliseconds
     const endTime = process.hrtime.bigint();
     const executionTimeMs = Number(endTime - startTime) / 1_000_000;
+    // Defensive: ensure result has expected structure
+    if (!result || typeof result !== 'object') {
+        throw new Error('Query returned invalid result');
+    }
     const fields = result.fields?.map(f => f.name) || [];
-    const totalRows = result.rows.length;
+    const rows = result.rows || [];
+    const totalRows = rows.length;
     // Apply offset and limit to the results
     const startIndex = Math.min(offset, totalRows);
     const endIndex = Math.min(startIndex + maxRows, totalRows);
-    const paginatedRows = result.rows.slice(startIndex, endIndex);
+    const paginatedRows = rows.slice(startIndex, endIndex);
     const returnedRows = paginatedRows.length;
     // Calculate actual output size
     const outputJson = JSON.stringify(paginatedRows);
@@ -78,7 +102,8 @@ export async function executeSql(args) {
             truncated: true,
             executionTimeMs: Math.round(executionTimeMs * 100) / 100,
             offset: startIndex,
-            hasMore: endIndex < totalRows
+            hasMore: endIndex < totalRows,
+            ...(schemaHint && { schemaHint })
         };
     }
     return {
@@ -87,7 +112,66 @@ export async function executeSql(args) {
         fields,
         executionTimeMs: Math.round(executionTimeMs * 100) / 100,
         offset: startIndex,
-        hasMore: endIndex < totalRows
+        hasMore: endIndex < totalRows,
+        ...(schemaHint && { schemaHint })
+    };
+}
+/**
+ * Execute multiple SQL statements and return results for each
+ */
+async function executeMultipleStatements(sql, schemaHint, transactionId) {
+    const dbManager = getDbManager();
+    const startTime = process.hrtime.bigint();
+    // Parse statements with line numbers
+    const parsedStatements = splitSqlStatementsWithLineNumbers(sql);
+    // Filter out empty statements and comments-only
+    const executableStatements = parsedStatements.filter(stmt => {
+        const trimmed = stmt.sql.trim();
+        if (!trimmed)
+            return false;
+        const withoutComments = stripLeadingComments(trimmed);
+        return withoutComments.length > 0;
+    });
+    const results = [];
+    let successCount = 0;
+    let failureCount = 0;
+    for (let i = 0; i < executableStatements.length; i++) {
+        const stmt = executableStatements[i];
+        const stmtResult = {
+            statementIndex: i + 1,
+            sql: stmt.sql.length > 200 ? stmt.sql.substring(0, 200) + '...' : stmt.sql,
+            lineNumber: stmt.lineNumber,
+            success: false,
+        };
+        try {
+            let result;
+            if (transactionId) {
+                result = await dbManager.queryInTransaction(transactionId, stmt.sql);
+            }
+            else {
+                result = await dbManager.query(stmt.sql);
+            }
+            stmtResult.success = true;
+            stmtResult.rows = result.rows?.slice(0, 100); // Limit rows per statement
+            stmtResult.rowCount = result.rowCount ?? result.rows?.length ?? 0;
+            successCount++;
+        }
+        catch (error) {
+            stmtResult.success = false;
+            stmtResult.error = error instanceof Error ? error.message : String(error);
+            failureCount++;
+        }
+        results.push(stmtResult);
+    }
+    const endTime = process.hrtime.bigint();
+    const executionTimeMs = Number(endTime - startTime) / 1_000_000;
+    return {
+        results,
+        totalStatements: executableStatements.length,
+        successCount,
+        failureCount,
+        executionTimeMs: Math.round(executionTimeMs * 100) / 100,
+        ...(schemaHint && { schemaHint })
     };
 }
 export async function explainQuery(args) {
@@ -243,30 +327,23 @@ export async function executeSqlFile(args) {
     let totalRowsAffected = 0;
     let rolledBack = false;
     const collectedErrors = [];
-    // Split SQL into statements first to get total count
-    const statements = splitSqlStatements(sqlContent);
-    const executableStatements = statements.filter(s => {
-        const trimmed = s.trim();
-        return trimmed && !trimmed.startsWith('--');
+    // Split SQL into statements with line number tracking
+    const parsedStatements = splitSqlStatementsWithLineNumbers(sqlContent);
+    const executableStatements = parsedStatements.filter(stmt => {
+        const trimmed = stmt.sql.trim();
+        if (!trimmed)
+            return false;
+        const withoutComments = stripLeadingComments(trimmed);
+        return withoutComments.length > 0;
     });
     const totalStatements = executableStatements.length;
     try {
         if (useTransaction) {
             await client.query('BEGIN');
         }
-        let statementIndex = 0;
-        for (const statement of statements) {
-            const trimmed = statement.trim();
-            // Skip empty statements
-            if (!trimmed) {
-                continue;
-            }
-            // Skip pure comment-only statements (just -- comments with no SQL after)
-            const withoutComments = stripLeadingComments(trimmed);
-            if (!withoutComments) {
-                continue;
-            }
-            statementIndex++;
+        for (let statementIndex = 0; statementIndex < executableStatements.length; statementIndex++) {
+            const stmt = executableStatements[statementIndex];
+            const trimmed = stmt.sql.trim();
             try {
                 const result = await client.query(trimmed);
                 statementsExecuted++;
@@ -284,7 +361,8 @@ export async function executeSqlFile(args) {
                     }
                     // Add the error to collection before throwing
                     collectedErrors.push({
-                        statementIndex,
+                        statementIndex: statementIndex + 1,
+                        lineNumber: stmt.lineNumber,
                         sql: trimmed.length > 200 ? trimmed.substring(0, 200) + '...' : trimmed,
                         error: errorMessage
                     });
@@ -292,11 +370,12 @@ export async function executeSqlFile(args) {
                 }
                 // If stopOnError is false, collect error and continue
                 collectedErrors.push({
-                    statementIndex,
+                    statementIndex: statementIndex + 1,
+                    lineNumber: stmt.lineNumber,
                     sql: trimmed.length > 200 ? trimmed.substring(0, 200) + '...' : trimmed,
                     error: errorMessage
                 });
-                console.error(`Warning: Statement ${statementIndex} failed: ${errorMessage}`);
+                console.error(`Warning: Statement ${statementIndex + 1} at line ${stmt.lineNumber} failed: ${errorMessage}`);
             }
         }
         if (useTransaction && !rolledBack) {
@@ -375,12 +454,14 @@ function stripLeadingComments(sql) {
     return result;
 }
 /**
- * Split SQL content into individual statements.
- * Handles basic cases like semicolons, comments, and string literals.
+ * Split SQL content into individual statements with line number tracking.
+ * Returns ParsedStatement objects with SQL and line number info.
  */
-function splitSqlStatements(sql) {
+function splitSqlStatementsWithLineNumbers(sql) {
     const statements = [];
     let current = '';
+    let currentLineNumber = 1;
+    let statementStartLine = 1;
     let inString = false;
     let stringChar = '';
     let inLineComment = false;
@@ -389,6 +470,14 @@ function splitSqlStatements(sql) {
     while (i < sql.length) {
         const char = sql[i];
         const nextChar = sql[i + 1] || '';
+        // Track line numbers
+        if (char === '\n') {
+            currentLineNumber++;
+        }
+        // If starting a new statement (current is empty/whitespace), record line number
+        if (current.trim() === '' && char.trim() !== '') {
+            statementStartLine = currentLineNumber;
+        }
         // Handle line comments
         if (!inString && !inBlockComment && char === '-' && nextChar === '-') {
             inLineComment = true;
@@ -422,7 +511,6 @@ function splitSqlStatements(sql) {
                 stringChar = char;
             }
             else if (char === stringChar) {
-                // Check for escaped quote (doubled)
                 if (nextChar === stringChar) {
                     current += char + nextChar;
                     i += 2;
@@ -439,7 +527,11 @@ function splitSqlStatements(sql) {
                 const dollarTag = dollarMatch[1];
                 const endIndex = sql.indexOf(dollarTag, i + dollarTag.length);
                 if (endIndex !== -1) {
-                    current += sql.slice(i, endIndex + dollarTag.length);
+                    const dollarContent = sql.slice(i, endIndex + dollarTag.length);
+                    // Count newlines in dollar-quoted content
+                    const newlines = (dollarContent.match(/\n/g) || []).length;
+                    currentLineNumber += newlines;
+                    current += dollarContent;
                     i = endIndex + dollarTag.length;
                     continue;
                 }
@@ -448,8 +540,12 @@ function splitSqlStatements(sql) {
         // Handle statement separator
         if (!inString && !inLineComment && !inBlockComment && char === ';') {
             current += char;
-            statements.push(current.trim());
+            const trimmed = current.trim();
+            if (trimmed) {
+                statements.push({ sql: trimmed, lineNumber: statementStartLine });
+            }
             current = '';
+            statementStartLine = currentLineNumber;
             i++;
             continue;
         }
@@ -457,9 +553,412 @@ function splitSqlStatements(sql) {
         i++;
     }
     // Add remaining content if any
-    if (current.trim()) {
-        statements.push(current.trim());
+    const trimmed = current.trim();
+    if (trimmed) {
+        statements.push({ sql: trimmed, lineNumber: statementStartLine });
+    }
+    return statements;
+}
+/**
+ * Extracts table names from a SQL query.
+ * Handles common patterns: FROM, JOIN, INTO, UPDATE, DELETE FROM
+ */
+function extractTablesFromSql(sql) {
+    const tables = [];
+    const seen = new Set();
+    // Normalize SQL: remove comments and extra whitespace
+    const normalized = sql
+        .replace(/--[^\n]*/g, '') // Remove line comments
+        .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
+        .replace(/\s+/g, ' ') // Normalize whitespace
+        .trim();
+    // Patterns to find table references
+    const patterns = [
+        /\bFROM\s+(["`]?[\w]+["`]?(?:\s*\.\s*["`]?[\w]+["`]?)?)/gi,
+        /\bJOIN\s+(["`]?[\w]+["`]?(?:\s*\.\s*["`]?[\w]+["`]?)?)/gi,
+        /\bINTO\s+(["`]?[\w]+["`]?(?:\s*\.\s*["`]?[\w]+["`]?)?)/gi,
+        /\bUPDATE\s+(["`]?[\w]+["`]?(?:\s*\.\s*["`]?[\w]+["`]?)?)/gi,
+        /\bDELETE\s+FROM\s+(["`]?[\w]+["`]?(?:\s*\.\s*["`]?[\w]+["`]?)?)/gi,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(normalized)) !== null) {
+            const tableRef = match[1].replace(/["`]/g, '').trim();
+            // Skip common SQL keywords that might be matched
+            if (['SELECT', 'WHERE', 'SET', 'VALUES', 'AND', 'OR'].includes(tableRef.toUpperCase())) {
+                continue;
+            }
+            let schema = 'public';
+            let table = tableRef;
+            if (tableRef.includes('.')) {
+                const parts = tableRef.split('.');
+                schema = parts[0].trim();
+                table = parts[1].trim();
+            }
+            const key = `${schema}.${table}`.toLowerCase();
+            if (!seen.has(key)) {
+                seen.add(key);
+                tables.push({ schema, table });
+            }
+        }
+    }
+    return tables;
+}
+/**
+ * Gets schema hints for tables mentioned in SQL
+ */
+async function getSchemaHintForSql(sql) {
+    const dbManager = getDbManager();
+    const tables = extractTablesFromSql(sql);
+    const tableHints = [];
+    for (const { schema, table } of tables.slice(0, 10)) { // Limit to 10 tables
+        try {
+            // Get columns
+            const columnsResult = await dbManager.query(`
+        SELECT
+          column_name as name,
+          data_type as type,
+          is_nullable = 'YES' as nullable
+        FROM information_schema.columns
+        WHERE table_schema = $1 AND table_name = $2
+        ORDER BY ordinal_position
+      `, [schema, table]);
+            // Get primary key
+            const pkResult = await dbManager.query(`
+        SELECT a.attname as column_name
+        FROM pg_index i
+        JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+        JOIN pg_class c ON c.oid = i.indrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE i.indisprimary
+          AND n.nspname = $1
+          AND c.relname = $2
+      `, [schema, table]);
+            // Get foreign keys
+            const fkResult = await dbManager.query(`
+        SELECT
+          kcu.column_name,
+          ccu.table_schema || '.' || ccu.table_name as referenced_table,
+          ccu.column_name as referenced_column
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage ccu
+          ON ccu.constraint_name = tc.constraint_name
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND tc.table_name = $2
+      `, [schema, table]);
+            // Get row count estimate
+            const countResult = await dbManager.query(`
+        SELECT reltuples::bigint as estimate
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = $1 AND c.relname = $2
+      `, [schema, table]);
+            const hint = {
+                schema,
+                table,
+                columns: columnsResult.rows.map(r => ({
+                    name: r.name,
+                    type: r.type,
+                    nullable: r.nullable
+                })),
+                primaryKey: pkResult.rows.map(r => r.column_name),
+                rowCountEstimate: countResult.rows[0]?.estimate || 0
+            };
+            // Group foreign keys by constraint
+            if (fkResult.rows.length > 0) {
+                const fkMap = new Map();
+                for (const row of fkResult.rows) {
+                    const key = row.referenced_table;
+                    if (!fkMap.has(key)) {
+                        fkMap.set(key, { columns: [], referencedColumns: [] });
+                    }
+                    fkMap.get(key).columns.push(row.column_name);
+                    fkMap.get(key).referencedColumns.push(row.referenced_column);
+                }
+                hint.foreignKeys = Array.from(fkMap.entries()).map(([refTable, data]) => ({
+                    columns: data.columns,
+                    referencedTable: refTable,
+                    referencedColumns: data.referencedColumns
+                }));
+            }
+            tableHints.push(hint);
+        }
+        catch (error) {
+            // Skip tables that don't exist or have permission issues
+            console.error(`Could not get schema hint for ${schema}.${table}: ${error}`);
+        }
+    }
+    return { tables: tableHints };
+}
+/**
+ * Preview the effect of a mutation (INSERT/UPDATE/DELETE) without executing it.
+ * Returns estimated rows affected and sample of rows that would be affected.
+ */
+export async function mutationPreview(args) {
+    if (!args.sql || typeof args.sql !== 'string') {
+        throw new Error('sql parameter is required');
+    }
+    const sql = args.sql.trim();
+    const sampleSize = Math.min(args.sampleSize || 5, 20); // Default 5, max 20
+    // Detect mutation type
+    const upperSql = sql.toUpperCase();
+    let mutationType = 'UNKNOWN';
+    if (upperSql.startsWith('UPDATE')) {
+        mutationType = 'UPDATE';
+    }
+    else if (upperSql.startsWith('DELETE')) {
+        mutationType = 'DELETE';
+    }
+    else if (upperSql.startsWith('INSERT')) {
+        mutationType = 'INSERT';
+    }
+    else {
+        throw new Error('SQL must be an INSERT, UPDATE, or DELETE statement');
+    }
+    const dbManager = getDbManager();
+    // For INSERT, we can't preview affected rows
+    if (mutationType === 'INSERT') {
+        // Use EXPLAIN to estimate rows
+        const explainResult = await dbManager.query(`EXPLAIN (FORMAT JSON) ${sql}`);
+        const plan = explainResult.rows[0]['QUERY PLAN'][0];
+        return {
+            mutationType,
+            estimatedRowsAffected: plan?.Plan?.['Plan Rows'] || 1,
+            sampleAffectedRows: [],
+            warning: 'INSERT preview cannot show affected rows - they do not exist yet'
+        };
+    }
+    // For UPDATE and DELETE, extract WHERE clause and table
+    let targetTable;
+    let whereClause;
+    if (mutationType === 'UPDATE') {
+        // Pattern: UPDATE table SET ... WHERE ...
+        const updateMatch = sql.match(/UPDATE\s+(["`]?[\w.]+["`]?)\s+SET/i);
+        const whereMatch = sql.match(/\bWHERE\s+(.+)$/is);
+        targetTable = updateMatch?.[1]?.replace(/["`]/g, '');
+        whereClause = whereMatch?.[1];
+    }
+    else if (mutationType === 'DELETE') {
+        // Pattern: DELETE FROM table WHERE ...
+        const deleteMatch = sql.match(/DELETE\s+FROM\s+(["`]?[\w.]+["`]?)/i);
+        const whereMatch = sql.match(/\bWHERE\s+(.+)$/is);
+        targetTable = deleteMatch?.[1]?.replace(/["`]/g, '');
+        whereClause = whereMatch?.[1];
+    }
+    if (!targetTable) {
+        throw new Error('Could not parse target table from SQL');
+    }
+    // Get estimated row count using EXPLAIN
+    let estimatedRowsAffected = 0;
+    try {
+        const explainResult = await dbManager.query(`EXPLAIN (FORMAT JSON) ${sql}`);
+        const plan = explainResult.rows[0]['QUERY PLAN'][0];
+        estimatedRowsAffected = plan?.Plan?.['Plan Rows'] || 0;
+    }
+    catch (error) {
+        // EXPLAIN might fail, continue with count query
     }
-    return statements.filter(s => s.length > 0);
+    // Build SELECT query to get sample of affected rows
+    let sampleRows = [];
+    try {
+        const selectSql = whereClause
+            ? `SELECT * FROM ${targetTable} WHERE ${whereClause} LIMIT ${sampleSize}`
+            : `SELECT * FROM ${targetTable} LIMIT ${sampleSize}`;
+        const sampleResult = await dbManager.query(selectSql);
+        sampleRows = sampleResult.rows;
+        // If EXPLAIN didn't work, get count
+        if (estimatedRowsAffected === 0) {
+            const countSql = whereClause
+                ? `SELECT COUNT(*) as cnt FROM ${targetTable} WHERE ${whereClause}`
+                : `SELECT COUNT(*) as cnt FROM ${targetTable}`;
+            const countResult = await dbManager.query(countSql);
+            estimatedRowsAffected = parseInt(countResult.rows[0]?.cnt || '0', 10);
+        }
+    }
+    catch (error) {
+        throw new Error(`Could not preview affected rows: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const result = {
+        mutationType,
+        estimatedRowsAffected,
+        sampleAffectedRows: sampleRows,
+        targetTable
+    };
+    if (whereClause) {
+        result.whereClause = whereClause;
+    }
+    else {
+        result.warning = 'No WHERE clause - ALL rows in the table will be affected!';
+    }
+    return result;
+}
+/**
+ * Execute multiple SQL queries in parallel.
+ * Returns results keyed by query name.
+ */
+export async function batchExecute(args) {
+    if (!args.queries || !Array.isArray(args.queries)) {
+        throw new Error('queries parameter is required and must be an array');
+    }
+    if (args.queries.length === 0) {
+        throw new Error('queries array cannot be empty');
+    }
+    if (args.queries.length > 20) {
+        throw new Error('Maximum 20 queries allowed in a batch');
+    }
+    // Validate each query
+    const seenNames = new Set();
+    for (const query of args.queries) {
+        if (!query.name || typeof query.name !== 'string') {
+            throw new Error('Each query must have a name');
+        }
+        if (!query.sql || typeof query.sql !== 'string') {
+            throw new Error(`Query "${query.name}" must have sql`);
+        }
+        if (seenNames.has(query.name)) {
+            throw new Error(`Duplicate query name: ${query.name}`);
+        }
+        seenNames.add(query.name);
+    }
+    const dbManager = getDbManager();
+    const stopOnError = args.stopOnError === true; // Default false
+    const startTime = process.hrtime.bigint();
+    const results = {};
+    let successCount = 0;
+    let failureCount = 0;
+    // Execute all queries in parallel
+    const promises = args.queries.map(async (query) => {
+        const queryStartTime = process.hrtime.bigint();
+        try {
+            const result = await dbManager.query(query.sql, query.params);
+            const queryEndTime = process.hrtime.bigint();
+            const executionTimeMs = Number(queryEndTime - queryStartTime) / 1_000_000;
+            return {
+                name: query.name,
+                result: {
+                    success: true,
+                    rows: result.rows,
+                    rowCount: result.rowCount ?? result.rows.length,
+                    executionTimeMs: Math.round(executionTimeMs * 100) / 100
+                }
+            };
+        }
+        catch (error) {
+            const queryEndTime = process.hrtime.bigint();
+            const executionTimeMs = Number(queryEndTime - queryStartTime) / 1_000_000;
+            return {
+                name: query.name,
+                result: {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    executionTimeMs: Math.round(executionTimeMs * 100) / 100
+                }
+            };
+        }
+    });
+    // Wait for all queries
+    const queryResults = await Promise.all(promises);
+    // Collect results
+    for (const { name, result } of queryResults) {
+        results[name] = result;
+        if (result.success) {
+            successCount++;
+        }
+        else {
+            failureCount++;
+            if (stopOnError) {
+                // Mark remaining as not executed
+                break;
+            }
+        }
+    }
+    const endTime = process.hrtime.bigint();
+    const totalExecutionTimeMs = Number(endTime - startTime) / 1_000_000;
+    return {
+        totalQueries: args.queries.length,
+        successCount,
+        failureCount,
+        totalExecutionTimeMs: Math.round(totalExecutionTimeMs * 100) / 100,
+        results
+    };
+}
+/**
+ * Begin a new transaction. Returns a transactionId to use with subsequent queries.
+ */
+export async function beginTransaction(args) {
+    const dbManager = getDbManager();
+    const info = await dbManager.beginTransaction(args?.name);
+    return {
+        transactionId: info.transactionId,
+        name: info.name,
+        status: 'started',
+        message: `Transaction${info.name ? ` "${info.name}"` : ''} started. Use transactionId "${info.transactionId}" with execute_sql or commit/rollback.`
+    };
+}
+/**
+ * Get information about an active transaction.
+ */
+export async function getTransactionInfo(args) {
+    if (!args.transactionId) {
+        throw new Error('transactionId parameter is required');
+    }
+    const dbManager = getDbManager();
+    const info = dbManager.getTransactionInfo(args.transactionId);
+    if (!info) {
+        return { error: `Transaction not found: ${args.transactionId}` };
+    }
+    return info;
+}
+/**
+ * List all active transactions.
+ */
+export async function listActiveTransactions() {
+    const dbManager = getDbManager();
+    const transactions = dbManager.listActiveTransactions();
+    return {
+        transactions,
+        count: transactions.length
+    };
+}
+/**
+ * Commit an active transaction.
+ */
+export async function commitTransaction(args) {
+    if (!args.transactionId || typeof args.transactionId !== 'string') {
+        throw new Error('transactionId is required');
+    }
+    const dbManager = getDbManager();
+    await dbManager.commitTransaction(args.transactionId);
+    return {
+        transactionId: args.transactionId,
+        status: 'committed',
+        message: 'Transaction committed successfully.'
+    };
+}
+/**
+ * Rollback an active transaction.
+ */
+export async function rollbackTransaction(args) {
+    if (!args.transactionId || typeof args.transactionId !== 'string') {
+        throw new Error('transactionId is required');
+    }
+    const dbManager = getDbManager();
+    await dbManager.rollbackTransaction(args.transactionId);
+    return {
+        transactionId: args.transactionId,
+        status: 'rolled_back',
+        message: 'Transaction rolled back successfully.'
+    };
+}
+/**
+ * Get connection context for including in tool responses
+ */
+export function getConnectionContext() {
+    const dbManager = getDbManager();
+    return dbManager.getConnectionContext();
 }
 //# sourceMappingURL=sql-tools.js.map