@tejasanik/postgres-mcp-server 2.1.1 → 2.2.1

package/dist/tools/sql/utils/dry-run-utils.js

@@ -0,0 +1,173 @@
+/**
+ * Dry-Run Utilities
+ *
+ * Helper functions for transaction-based dry-run operations.
+ * Handles error extraction and detection of non-rollbackable operations.
+ */
+/**
+ * Non-rollbackable operation patterns.
+ * Operations that cannot run inside a transaction or have permanent side effects.
+ */
+const NON_ROLLBACKABLE_PATTERNS = [
+    // Operations that cannot run inside a transaction at all
+    {
+        pattern: /\bVACUUM\b/,
+        operation: 'VACUUM',
+        message: 'VACUUM cannot run inside a transaction block. Statement skipped.',
+        mustSkip: true,
+    },
+    {
+        pattern: /\bCLUSTER\b(?!.*CREATE)/,
+        operation: 'CLUSTER',
+        message: 'CLUSTER cannot run inside a transaction block. Statement skipped.',
+        mustSkip: true,
+    },
+    {
+        pattern: /\bREINDEX\b.*\bCONCURRENTLY\b/,
+        operation: 'REINDEX_CONCURRENTLY',
+        message: 'REINDEX CONCURRENTLY cannot run inside a transaction block. Statement skipped.',
+        mustSkip: true,
+    },
+    {
+        pattern: /\bCREATE\s+INDEX\b.*\bCONCURRENTLY\b/,
+        operation: 'CREATE_INDEX_CONCURRENTLY',
+        message: 'CREATE INDEX CONCURRENTLY cannot run inside a transaction block. Statement skipped.',
+        mustSkip: true,
+    },
+    {
+        pattern: /\bCREATE\s+DATABASE\b/,
+        operation: 'CREATE_DATABASE',
+        message: 'CREATE DATABASE cannot run inside a transaction block. Statement skipped.',
+        mustSkip: true,
+    },
+    {
+        pattern: /\bDROP\s+DATABASE\b/,
+        operation: 'DROP_DATABASE',
+        message: 'DROP DATABASE cannot run inside a transaction block. Statement skipped.',
+        mustSkip: true,
+    },
+    // Operations with permanent side effects
+    {
+        pattern: /\bNEXTVAL\s*\(/,
+        operation: 'SEQUENCE',
+        message: 'NEXTVAL increments sequence even when transaction is rolled back. Statement skipped to prevent sequence consumption.',
+        mustSkip: true,
+    },
+    {
+        pattern: /\bSETVAL\s*\(/,
+        operation: 'SEQUENCE',
+        message: 'SETVAL modifies sequence. Statement skipped to prevent side effects.',
+        mustSkip: true,
+    },
+    // Warning-only operations (still executed)
+    {
+        pattern: /\bINSERT\s+INTO\b/,
+        operation: 'SEQUENCE',
+        message: 'INSERT may consume sequence values (for SERIAL/BIGSERIAL columns) even when rolled back.',
+        mustSkip: false,
+    },
+    {
+        pattern: /\bNOTIFY\b/,
+        operation: 'NOTIFY',
+        message: 'NOTIFY sends notifications on commit. Since dry-run rolls back, notifications will NOT be sent.',
+        mustSkip: false,
+    },
+];
+/**
+ * Extract detailed error information from a PostgreSQL error.
+ * Captures all available fields to help AI quickly identify and fix issues.
+ */
+export function extractDryRunError(error) {
+    // Extract message - prioritize Error.message, then object.message, then String conversion
+    let message;
+    if (error instanceof Error) {
+        message = error.message;
+    }
+    else if (error && typeof error === 'object' && 'message' in error) {
+        message = String(error.message);
+    }
+    else {
+        message = String(error);
+    }
+    const result = { message };
+    if (error && typeof error === 'object') {
+        const pgError = error;
+        // Extract string fields
+        if (pgError.code)
+            result.code = String(pgError.code);
+        if (pgError.severity)
+            result.severity = String(pgError.severity);
+        if (pgError.detail)
+            result.detail = String(pgError.detail);
+        if (pgError.hint)
+            result.hint = String(pgError.hint);
+        if (pgError.internalQuery)
+            result.internalQuery = String(pgError.internalQuery);
+        if (pgError.where)
+            result.where = String(pgError.where);
+        if (pgError.schema)
+            result.schema = String(pgError.schema);
+        if (pgError.table)
+            result.table = String(pgError.table);
+        if (pgError.column)
+            result.column = String(pgError.column);
+        if (pgError.dataType)
+            result.dataType = String(pgError.dataType);
+        if (pgError.constraint)
+            result.constraint = String(pgError.constraint);
+        if (pgError.file)
+            result.file = String(pgError.file);
+        if (pgError.line)
+            result.line = String(pgError.line);
+        if (pgError.routine)
+            result.routine = String(pgError.routine);
+        // Extract number fields
+        if (pgError.position !== undefined)
+            result.position = Number(pgError.position);
+        if (pgError.internalPosition !== undefined)
+            result.internalPosition = Number(pgError.internalPosition);
+    }
+    return result;
+}
+/**
+ * Check if a SQL statement contains operations that cannot be fully rolled back
+ * or have side effects even within a transaction.
+ *
+ * @param sql - The SQL statement to check
+ * @param statementIndex - Optional statement index for error reporting
+ * @param lineNumber - Optional line number for error reporting
+ * @returns Array of warnings about non-rollbackable operations
+ */
+export function detectNonRollbackableOperations(sql, statementIndex, lineNumber) {
+    const warnings = [];
+    const upperSql = sql.toUpperCase().trim();
+    const clusterPattern = /\bCLUSTER\b/;
+    for (const { pattern, operation, message, mustSkip } of NON_ROLLBACKABLE_PATTERNS) {
+        // Special handling for CLUSTER (must not be part of CREATE)
+        if (operation === 'CLUSTER') {
+            if (clusterPattern.test(upperSql) && !upperSql.includes('CREATE')) {
+                warnings.push({ operation, message, statementIndex, lineNumber, mustSkip });
+            }
+        }
+        else if (pattern.test(upperSql)) {
+            warnings.push({ operation, message, statementIndex, lineNumber, mustSkip });
+        }
+    }
+    return warnings;
+}
+/**
+ * Check if any warning requires skipping the statement.
+ */
+export function hasMustSkipWarning(warnings) {
+    return warnings.some((w) => w.mustSkip);
+}
+/**
+ * Get skip reason from must-skip warnings.
+ */
+export function getSkipReason(warnings) {
+    return warnings
+        .filter((w) => w.mustSkip)
+        .map((w) => w.message)
+        .join('; ');
+}
+//# sourceMappingURL=dry-run-utils.js.map

package/dist/tools/sql/utils/file-handler.js

@@ -0,0 +1,150 @@
+/**
+ * File Handler Utilities
+ *
+ * Functions for validating and processing SQL files.
+ * Handles file validation, reading, and preprocessing.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { MAX_SQL_FILE_SIZE } from './constants.js';
+/**
+ * Validates a SQL file path and returns file information.
+ *
+ * @param filePath - Path to the SQL file
+ * @returns Validation result with resolved path and file size
+ */
+export function validateSqlFile(filePath) {
+    // Check file extension
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext !== '.sql') {
+        return {
+            isValid: false,
+            resolvedPath: '',
+            fileSize: 0,
+            error: 'Only .sql files are allowed. Received file extension: ' + ext,
+        };
+    }
+    // Resolve path
+    const resolvedPath = path.resolve(filePath);
+    // Check file exists
+    if (!fs.existsSync(resolvedPath)) {
+        return {
+            isValid: false,
+            resolvedPath,
+            fileSize: 0,
+            error: `File not found: ${filePath}`,
+        };
+    }
+    // Get file stats
+    const stats = fs.statSync(resolvedPath);
+    // Check it's a file
+    if (!stats.isFile()) {
+        return {
+            isValid: false,
+            resolvedPath,
+            fileSize: 0,
+            error: `Not a file: ${filePath}`,
+        };
+    }
+    // Check file size
+    if (stats.size > MAX_SQL_FILE_SIZE) {
+        return {
+            isValid: false,
+            resolvedPath,
+            fileSize: stats.size,
+            error: `File too large: ${formatFileSize(stats.size)}. Maximum allowed: ${formatFileSize(MAX_SQL_FILE_SIZE)}`,
+        };
+    }
+    // Check file not empty
+    if (stats.size === 0) {
+        return {
+            isValid: false,
+            resolvedPath,
+            fileSize: 0,
+            error: 'File is empty',
+        };
+    }
+    return {
+        isValid: true,
+        resolvedPath,
+        fileSize: stats.size,
+    };
+}
+/**
+ * Reads a SQL file and optionally preprocesses it.
+ *
+ * @param resolvedPath - Resolved path to the SQL file
+ * @param stripPatterns - Optional patterns to remove from content
+ * @param stripAsRegex - If true, patterns are regex; if false, literal strings
+ * @returns Preprocessed SQL content
+ */
+export function readSqlFile(resolvedPath, stripPatterns, stripAsRegex = false) {
+    let content = fs.readFileSync(resolvedPath, 'utf-8');
+    if (stripPatterns && stripPatterns.length > 0) {
+        content = preprocessSqlContent(content, stripPatterns, stripAsRegex);
+    }
+    return content;
+}
+/**
+ * Preprocess SQL content by removing patterns.
+ * Supports both literal string matching and regex patterns.
+ *
+ * @param sql - The SQL content to preprocess
+ * @param patterns - Array of patterns to remove from SQL content
+ * @param isRegex - If true, patterns are treated as regex; if false, as literal strings
+ * @returns Preprocessed SQL content
+ */
+export function preprocessSqlContent(sql, patterns, isRegex = false) {
+    let result = sql;
+    for (const pattern of patterns) {
+        try {
+            if (isRegex) {
+                // Treat as regex pattern (multiline by default)
+                const regex = new RegExp(pattern, 'gm');
+                result = result.replace(regex, '');
+            }
+            else {
+                // Treat as literal string - escape and match on its own line
+                const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const regex = new RegExp(`^\\s*${escapedPattern}\\s*$`, 'gm');
+                result = result.replace(regex, '');
+            }
+        }
+        catch (error) {
+            // Invalid regex - skip this pattern silently in production
+            // Log only in non-production for debugging
+            if (process.env.NODE_ENV !== 'production') {
+                console.error(`Warning: Invalid pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Format file size in human-readable format.
+ *
+ * @param bytes - File size in bytes
+ * @returns Human-readable file size (e.g., "1.5 MB")
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB'];
+    const base = 1024;
+    const unitIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1);
+    const size = bytes / Math.pow(base, unitIndex);
+    return `${size.toFixed(unitIndex > 0 ? 1 : 0)} ${units[unitIndex]}`;
+}
+/**
+ * Ensure a file path is safe (no path traversal attacks).
+ *
+ * @param basePath - Base directory path
+ * @param filePath - File path to validate
+ * @returns True if the file path is within the base path
+ */
+export function isPathSafe(basePath, filePath) {
+    const resolvedBase = path.resolve(basePath);
+    const resolvedFile = path.resolve(filePath);
+    return resolvedFile.startsWith(resolvedBase);
+}
+//# sourceMappingURL=file-handler.js.map

package/dist/tools/sql/utils/index.js

@@ -0,0 +1,12 @@
+/**
+ * SQL Tools Utilities
+ *
+ * Re-exports all utility modules for convenient importing.
+ */
+export * from './constants.js';
+export * from './connection-utils.js';
+export * from './dry-run-utils.js';
+export * from './file-handler.js';
+export * from './result-formatter.js';
+export * from './sql-parser.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/sql/utils/result-formatter.js

@@ -0,0 +1,154 @@
+/**
+ * Result Formatter Utilities
+ *
+ * Functions for formatting query results, handling large outputs,
+ * and timing measurements.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { MAX_OUTPUT_CHARS } from './constants.js';
+/**
+ * Calculate execution time from hrtime bigints.
+ *
+ * @param startTime - Start time from process.hrtime.bigint()
+ * @param endTime - End time from process.hrtime.bigint()
+ * @returns Execution time in milliseconds (rounded to 2 decimal places)
+ */
+export function calculateExecutionTime(startTime, endTime) {
+    return Math.round((Number(endTime - startTime) / 1_000_000) * 100) / 100;
+}
+/**
+ * Get current time for timing measurements.
+ *
+ * @returns Current high-resolution time as bigint
+ */
+export function getStartTime() {
+    return process.hrtime.bigint();
+}
+/**
+ * Handle potentially large output by writing to file if necessary.
+ *
+ * @param rows - Result rows to check
+ * @param maxChars - Maximum characters before writing to file
+ * @returns Object with truncated flag, optional file path, and rows
+ */
+export function handleLargeOutput(rows, maxChars = MAX_OUTPUT_CHARS) {
+    const output = JSON.stringify(rows);
+    if (output.length <= maxChars) {
+        return { truncated: false, rows };
+    }
+    // Write to temp file
+    const tempDir = os.tmpdir();
+    const fileName = `sql-result-${uuidv4()}.json`;
+    const filePath = path.join(tempDir, fileName);
+    fs.writeFileSync(filePath, output, { mode: 0o600 });
+    return {
+        truncated: true,
+        outputFile: filePath,
+        rows: [], // Return empty rows since output is in file
+    };
+}
+/**
+ * Paginate result rows.
+ *
+ * @param rows - All result rows
+ * @param offset - Number of rows to skip
+ * @param maxRows - Maximum rows to return
+ * @returns Paginated rows and metadata
+ */
+export function paginateRows(rows, offset, maxRows) {
+    const totalCount = rows.length;
+    const paginatedRows = rows.slice(offset, offset + maxRows);
+    const hasMore = offset + paginatedRows.length < totalCount;
+    return {
+        rows: paginatedRows,
+        offset,
+        hasMore,
+        totalCount,
+    };
+}
+/**
+ * Truncate SQL for display in error messages or previews.
+ *
+ * @param sql - SQL string to truncate
+ * @param maxLength - Maximum length (default: 200)
+ * @returns Truncated SQL with ellipsis if needed
+ */
+export function truncateSql(sql, maxLength = 200) {
+    const trimmed = sql.trim();
+    if (trimmed.length <= maxLength) {
+        return trimmed;
+    }
+    return trimmed.substring(0, maxLength) + '...';
+}
+/**
+ * Format field names from query result.
+ *
+ * @param fields - Array of field objects from pg result
+ * @returns Array of field names
+ */
+export function formatFieldNames(fields) {
+    return fields.map((f) => f.name);
+}
+/**
+ * Create a summary message for statement execution.
+ *
+ * @param totalStatements - Total number of statements
+ * @param successCount - Number of successful statements
+ * @param failureCount - Number of failed statements
+ * @param skippedCount - Number of skipped statements
+ * @param rolledBack - Whether changes were rolled back
+ * @returns Summary message string
+ */
+export function createExecutionSummary(totalStatements, successCount, failureCount, skippedCount, rolledBack) {
+    const parts = [];
+    if (rolledBack) {
+        parts.push(`Dry-run of ${totalStatements} statements:`);
+    }
+    else {
+        parts.push(`Executed ${totalStatements} statements:`);
+    }
+    if (successCount > 0) {
+        parts.push(`${successCount} succeeded`);
+    }
+    if (failureCount > 0) {
+        parts.push(`${failureCount} failed`);
+    }
+    if (skippedCount > 0) {
+        parts.push(`${skippedCount} skipped (non-rollbackable)`);
+    }
+    if (rolledBack) {
+        parts.push('All changes rolled back.');
+    }
+    return parts.join(', ').replace('statements:,', 'statements:');
+}
+/**
+ * Count statements by type.
+ *
+ * @param types - Array of statement types
+ * @returns Object with counts by type
+ */
+export function countStatementsByType(types) {
+    const counts = {};
+    for (const type of types) {
+        counts[type] = (counts[type] || 0) + 1;
+    }
+    return counts;
+}
+/**
+ * Create a human-readable file summary.
+ *
+ * @param statementsByType - Statement counts by type
+ * @param totalStatements - Total statement count
+ * @returns Summary string
+ */
+export function createFileSummary(statementsByType, totalStatements) {
+    const parts = Object.entries(statementsByType)
+        .sort(([, a], [, b]) => b - a)
+        .map(([type, count]) => `${count} ${type}`)
+        .join(', ');
+    return `File contains ${totalStatements} statements: ${parts}`;
+}
+//# sourceMappingURL=result-formatter.js.map