codecrucible-synth/dist/database/production-database-manager.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Production Database Manager with PostgreSQL, Connection Pooling, and Migrations
 * Replaces the SQLite-based DatabaseManager with enterprise-grade database support
 */
import { QueryResult, QueryResultRow } from 'pg';
import { Knex } from 'knex';
export interface ProductionDatabaseConfig {
    type: 'postgresql' | 'mysql' | 'sqlite';
    host?: string;
    port?: number;
    database: string;
    username?: string;
    password?: string;
    ssl?: boolean | object;
    pool?: {
        min: number;
        max: number;
        idleTimeoutMillis: number;
        createTimeoutMillis: number;
        destroyTimeoutMillis: number;
        reapIntervalMillis: number;
        createRetryIntervalMillis: number;
    };
    redis?: {
        host: string;
        port: number;
        password?: string;
        db: number;
    };
    readReplicas?: Array<{
        host: string;
        port?: number;
        database: string;
        username?: string;
        password?: string;
    }>;
    migrations?: {
        directory: string;
        tableName: string;
        schemaName?: string;
    };
}
export interface DatabaseTransaction {
    query<T extends QueryResultRow = QueryResultRow>(sql: string, params?: any[]): Promise<QueryResult<T>>;
    commit(): Promise<void>;
    rollback(): Promise<void>;
}
export interface QueryOptions {
    timeout?: number;
    cache?: boolean;
    cacheTTL?: number;
    readReplica?: boolean;
}
export declare class ProductionDatabaseManager {
    private config;
    private masterPool?;
    private replicaPools;
    private knexInstance?;
    private redisClient?;
    private queryMetrics;
    private healthCheckInterval?;
    constructor(config: ProductionDatabaseConfig);
    /**
     * Initialize database connections
     */
    initialize(): Promise<void>;
    /**
     * Initialize primary database connection
     */
    private initializePrimaryConnection;
    /**
     * Initialize read replica connections
     */
    private initializeReadReplicas;
    /**
     * Initialize Redis cache
     */
    private initializeRedisCache;
    /**
     * Run database migrations
     */
    private runMigrations;
    /**
     * Execute query with performance tracking and caching
     */
    query<T extends QueryResultRow = QueryResultRow>(sql: string, params?: any[], options?: QueryOptions): Promise<QueryResult<T>>;
    /**
     * Begin database transaction
     */
    beginTransaction(): Promise<DatabaseTransaction>;
    /**
     * Execute multiple queries in a transaction
     */
    transaction<T>(callback: (trx: DatabaseTransaction) => Promise<T>): Promise<T>;
    /**
     * Knex query builder access
     */
    get knex(): Knex;
    /**
     * Store voice interaction with optimized query
     */
    storeVoiceInteraction(interaction: {
        sessionId: string;
        voiceName: string;
        prompt: string;
        response: string;
        confidence: number;
        tokensUsed: number;
    }): Promise<number>;
    /**
     * Store code analysis with JSONB support
     */
    storeCodeAnalysis(analysis: {
        projectId: number;
        filePath: string;
        analysisType: string;
        results: any;
        qualityScore?: number;
    }): Promise<number>;
    /**
     * Get session history with pagination
     */
    getSessionHistory(sessionId: string, limit?: number, offset?: number): Promise<any[]>;
    /**
     * Get aggregated statistics with caching
     */
    getStats(): Promise<any>;
    /**
     * Bulk insert with batch processing
     */
    bulkInsert(table: string, data: any[], batchSize?: number): Promise<void>;
    /**
     * Health check for all connections
     */
    healthCheck(): Promise<{
        master: boolean;
        replicas: boolean[];
        redis: boolean;
        metrics: any;
    }>;
    /**
     * Get connection pool status
     */
    getPoolStatus(): any;
    /**
     * Private helper methods
     */
    private getRandomReplica;
    private generateQueryId;
    private getCachedResult;
    private setCachedResult;
    private trackQueryMetrics;
    private getQueryMetrics;
    private createBatches;
    private startHealthChecks;
    /**
     * Close all connections
     */
    close(): Promise<void>;
    /**
     * Check if database manager is initialized
     */
    isInitialized(): boolean;
    /**
     * Get raw database instance for migrations
     * Returns knex instance for raw SQL operations
     */
    getRawDb(): any;
    /**
     * Backup database (stub for backup manager)
     */
    backup(options?: any): Promise<string>;
}
export default ProductionDatabaseManager;
//# sourceMappingURL=production-database-manager.d.ts.map