@hechtcarmel/vertica-mcp/dist/config/database.js

MCP server for Vertica database operations with configurable readonly mode

import { z } from "zod";
import { DATABASE_CONSTANTS } from "../constants/index.js";
const booleanFromString = z
    .union([
    z.boolean(),
    z.string().transform((val) => {
        const lower = val.toLowerCase();
        if (lower === "true" || lower === "1")
            return true;
        if (lower === "false" || lower === "0")
            return false;
        throw new Error(`Invalid boolean value: ${val}`);
    }),
    z.undefined(),
])
    .transform((val) => val ?? true);
const ConfigSchema = z.object({
    host: z.string().min(1, "VERTICA_HOST is required"),
    port: z.coerce
        .number()
        .int()
        .min(1)
        .max(65535)
        .default(DATABASE_CONSTANTS.DEFAULT_PORT),
    database: z.string().min(1, "VERTICA_DATABASE is required"),
    user: z.string().min(1, "VERTICA_USER is required"),
    password: z.string().optional(),
    connectionLimit: z.coerce
        .number()
        .int()
        .min(1)
        .max(100)
        .default(DATABASE_CONSTANTS.DEFAULT_CONNECTION_LIMIT),
    queryTimeout: z.coerce
        .number()
        .int()
        .min(1000)
        .max(300000)
        .default(DATABASE_CONSTANTS.DEFAULT_QUERY_TIMEOUT),
    ssl: z.coerce.boolean().default(false),
    sslRejectUnauthorized: z.coerce.boolean().default(true),
    defaultSchema: z.string().default(DATABASE_CONSTANTS.DEFAULT_SCHEMA),
    readonlyMode: booleanFromString,
});
export function loadDatabaseConfig() {
    const rawConfig = {
        host: process.env.VERTICA_HOST,
        port: process.env.VERTICA_PORT,
        database: process.env.VERTICA_DATABASE,
        user: process.env.VERTICA_USER,
        password: process.env.VERTICA_PASSWORD,
        connectionLimit: process.env.VERTICA_CONNECTION_LIMIT,
        queryTimeout: process.env.VERTICA_QUERY_TIMEOUT,
        ssl: process.env.VERTICA_SSL,
        sslRejectUnauthorized: process.env.VERTICA_SSL_REJECT_UNAUTHORIZED,
        defaultSchema: process.env.VERTICA_DEFAULT_SCHEMA,
        readonlyMode: process.env.VERTICA_READONLY_MODE,
    };
    try {
        const validatedConfig = ConfigSchema.parse(rawConfig);
        if (process.env.DEBUG === "true" || process.env.VERTICA_DEBUG === "true") {
            const logConfig = {
                ...validatedConfig,
                password: validatedConfig.password ? "***" : undefined,
            };
            console.error("Database configuration loaded:", logConfig);
        }
        return validatedConfig;
    }
    catch (error) {
        if (error instanceof z.ZodError) {
            const missingFields = error.errors
                .map((err) => `${err.path.join(".")}: ${err.message}`)
                .join(", ");
            throw new Error(`Invalid database configuration: ${missingFields}`);
        }
        throw error;
    }
}
export function validateRequiredEnvVars() {
    const required = ["VERTICA_HOST", "VERTICA_DATABASE", "VERTICA_USER"];
    const missing = required.filter((key) => !process.env[key]);
    if (missing.length > 0) {
        throw new Error(`Missing required environment variables: ${missing.join(", ")}`);
    }
}
export function getDatabaseConfig() {
    validateRequiredEnvVars();
    return loadDatabaseConfig();
}
//# sourceMappingURL=database.js.map