@hechtcarmel/vertica-mcp/dist/tools/execute-query.js

MCP server for Vertica database operations with configurable readonly mode

import { z } from "zod";
import { VerticaService } from "../services/vertica-service.js";
import { getDatabaseConfig } from "../config/database.js";
import { formatQueryResult, safeJsonStringify } from "../utils/response-formatter.js";
export default class ExecuteQueryTool {
    name = "execute_query";
    get description() {
        try {
            const config = getDatabaseConfig();
            const isReadonly = config.readonlyMode ?? true;
            if (isReadonly) {
                return "Execute readonly SQL queries against the Vertica database. Only SELECT, SHOW, DESCRIBE, EXPLAIN, and WITH queries are allowed.";
            }
            else {
                return "Execute SQL queries against the Vertica database. All SQL operations are allowed including INSERT, UPDATE, DELETE, CREATE, DROP, etc.";
            }
        }
        catch {
            return "Execute SQL queries against the Vertica database. Query restrictions depend on configuration.";
        }
    }
    get inputSchema() {
        try {
            const config = getDatabaseConfig();
            const isReadonly = config.readonlyMode ?? true;
            const sqlDescription = isReadonly
                ? "SQL query to execute. Only readonly queries are allowed: SELECT, SHOW, DESCRIBE, EXPLAIN, and WITH."
                : "SQL query to execute. All SQL operations are allowed including INSERT, UPDATE, DELETE, CREATE, DROP, etc.";
            return {
                type: "object",
                properties: {
                    sql: {
                        type: "string",
                        description: sqlDescription,
                    },
                    params: {
                        type: "array",
                        items: {},
                        description: "Optional parameters for parameterized queries.",
                    },
                },
                required: ["sql"],
            };
        }
        catch {
            return {
                type: "object",
                properties: {
                    sql: {
                        type: "string",
                        description: "SQL query to execute. Query restrictions depend on configuration.",
                    },
                    params: {
                        type: "array",
                        items: {},
                        description: "Optional parameters for parameterized queries.",
                    },
                },
                required: ["sql"],
            };
        }
    }
    async execute(input) {
        const parsed = this.parseInput(input);
        let service = null;
        try {
            const config = getDatabaseConfig();
            service = new VerticaService(config);
            const result = await service.executeQuery(parsed.sql, parsed.params || []);
            const formatted = formatQueryResult({
                ...result,
                query: parsed.sql,
            });
            return safeJsonStringify({
                success: true,
                ...formatted,
                query: parsed.sql,
                executedAt: new Date().toISOString(),
            }, 2);
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            return safeJsonStringify({
                success: false,
                error: errorMessage,
                query: parsed.sql,
                executedAt: new Date().toISOString(),
            }, 2);
        }
        finally {
            if (service) {
                try {
                    await service.disconnect();
                }
                catch (error) {
                    console.error("Warning during service cleanup:", error instanceof Error ? error.message : String(error));
                }
            }
        }
    }
    parseInput(input) {
        const schema = z.object({
            sql: z.string(),
            params: z.array(z.unknown()).optional(),
        });
        return schema.parse(input);
    }
}
//# sourceMappingURL=execute-query.js.map