database-mcp/dist/src/utils/connection-manager.d.ts

Model Context Protocol server for multi-database access (PostgreSQL, MySQL, SQLite, Snowflake) with comprehensive introspection and analysis tools

/**
 * Database Connection Manager
 * Handles common connection concerns across all database types with proper SSL support
 */
import { DatabaseType, SSLConfig, DatabaseConnectionInfo } from '../types/database';
export interface ParsedConnection {
    type: DatabaseType;
    host?: string;
    port?: number;
    username?: string;
    password?: string;
    database: string;
    ssl: boolean;
    sslMode?: string;
}
export interface ConnectionConfig {
    [key: string]: any;
}
/**
 * Connection Manager for handling database connections with SSL/non-SSL support
 */
export declare class ConnectionManager {
    /**
     * Parse a connection string into structured components
     * @param connectionString - Database connection string
     * @returns ParsedConnection object
     */
    static parseConnectionString(connectionString: string): ParsedConnection;
    /**
     * Build SSL configuration based on database type and requirements
     * @param type - Database type
     * @param sslEnabled - Whether SSL is enabled
     * @param sslMode - SSL mode (for PostgreSQL)
     * @param options - Additional SSL options
     * @returns SSL configuration object or false/undefined
     */
    static buildSSLConfig(type: DatabaseType, sslEnabled: boolean, sslMode?: string, options?: {
        relaxedVerification?: boolean;
    }): SSLConfig | false | undefined;
    /**
     * Build database-specific connection configuration
     * @param parsed - Parsed connection information
     * @returns Database-specific connection config
     */
    static buildConnectionConfig(parsed: ParsedConnection): ConnectionConfig;
    /**
     * Detect cloud provider from hostname
     * @param hostname - Database hostname
     * @returns Cloud provider name or 'unknown'
     */
    static detectCloudProvider(hostname: string): string;
    /**
     * Check if hostname indicates a cloud database
     * @param hostname - Database hostname
     * @returns True if cloud database
     */
    static isCloudDatabase(hostname: string): boolean;
    /**
     * Get recommended SSL mode based on environment and database location
     * @param environment - Current environment (production, development, test)
     * @param isCloudDatabase - Whether this is a cloud database
     * @returns Recommended SSL mode
     */
    static getRecommendedSSLMode(environment: string, isCloudDatabase: boolean): string;
}
/**
 * SSL Configuration Manager
 * Handles SSL setup for cloud providers
 */
export declare class SSLConfigManager {
    /**
     * Check if connection string indicates a cloud provider
     * @param {string} connectionString - Database connection string
     * @returns {boolean} - True if cloud provider detected
     */
    static isCloudProvider(connectionString: string): boolean;
    /**
     * Get SSL configuration for cloud providers
     * @param {string} connectionString - Database connection string
     * @returns {Object|boolean} - SSL configuration or false
     */
    static getSSLConfig(connectionString: string): SSLConfig | false;
    /**
     * Log SSL configuration status
     * @param {string} databaseType - Type of database
     * @param {Object|boolean} sslConfig - SSL configuration
     */
    static logSSLStatus(databaseType: DatabaseType, sslConfig: SSLConfig | boolean): void;
}
/**
 * Connection Error Handler
 * Centralized error handling for database connections
 */
export declare class ConnectionErrorHandler {
    /**
     * Handle PostgreSQL connection errors
     * @param {Error} error - Connection error
     */
    static handlePostgreSQLError(error: Error): void;
    /**
     * Handle MySQL connection errors
     * @param {Error} error - Connection error
     */
    static handleMySQLError(error: any): void;
    /**
     * Handle SQLite connection errors
     * @param {Error} error - Connection error
     */
    static handleSQLiteError(error: any): void;
    /**
     * Handle connection error based on database type
     * @param {string} databaseType - Type of database
     * @param {Error} error - Connection error
     */
    static handleError(databaseType: DatabaseType, error: Error): void;
}
/**
 * Connection Logger
 * Centralized logging for database connections
 */
export declare class ConnectionLogger {
    /**
     * Log successful connection
     * @param {string} databaseType - Type of database
     * @param {Object} connectionInfo - Connection information
     */
    static logSuccess(databaseType: DatabaseType, connectionInfo: DatabaseConnectionInfo): void;
    /**
     * Log connection attempt
     * @param {string} databaseType - Type of database
     */
    static logAttempt(databaseType: DatabaseType): void;
    /**
     * Log connection failure
     * @param {string} databaseType - Type of database
     * @param {string} message - Error message
     */
    static logFailure(databaseType: DatabaseType, message: string): void;
}
//# sourceMappingURL=connection-manager.d.ts.map