claude-flow-novice 2.15.3 → 2.15.4

package/dist/lib/database-service/connection-pool-manager.js

@@ -0,0 +1,520 @@
+/**
+ * Connection Pool Manager
+ *
+ * Manages connection pools for database adapters with:
+ * - Automatic initialization on service startup
+ * - Connection health checks (ping every 30s)
+ * - Automatic reconnection with exponential backoff
+ * - Connection metrics (active, idle, pending)
+ * - Graceful degradation on connection failures
+ *
+ * Part of Bug Fix: Connection Pool Initialization
+ */ import sqlite3 from 'sqlite3';
+import { open } from 'sqlite';
+import { createClient } from 'redis';
+import { Pool } from 'pg';
+import { DatabaseErrorCode } from './types.js';
+import { createDatabaseError } from './errors.js';
+/**
+ * Connection Pool Manager
+ *
+ * Manages connection lifecycle, health checks, and automatic recovery
+ */ export class ConnectionPoolManager {
+    config;
+    options;
+    pool = null;
+    connections = new Set();
+    activeConnections = new Set();
+    pendingRequests = [];
+    healthCheckInterval;
+    lastHealthCheck;
+    healthCheckActive = false;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    failedAttempts = 0;
+    startTime;
+    isShuttingDown = false;
+    cacheFallbackEnabled = false;
+    cache = new Map();
+    constructor(config, options = {}){
+        this.config = config;
+        this.options = {
+            minConnections: options.minConnections ?? 2,
+            maxConnections: options.maxConnections ?? config.poolSize ?? 10,
+            acquireTimeout: options.acquireTimeout ?? config.timeout ?? 5000,
+            idleTimeout: options.idleTimeout ?? 30000,
+            healthCheckInterval: options.healthCheckInterval ?? 30000,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
+            reconnectBaseDelay: options.reconnectBaseDelay ?? 1000
+        };
+        this.maxReconnectAttempts = this.options.maxReconnectAttempts;
+        this.startTime = new Date();
+    }
+    /**
+   * Initialize connection pool
+   */ async initialize() {
+        try {
+            switch(this.config.type){
+                case 'sqlite':
+                    await this.initializeSQLitePool();
+                    break;
+                case 'redis':
+                    await this.initializeRedisPool();
+                    break;
+                case 'postgres':
+                    await this.initializePostgresPool();
+                    break;
+                default:
+                    throw new Error(`Unsupported database type: ${this.config.type}`);
+            }
+            // Initialize minimum connections
+            await this.warmUpPool();
+        } catch (err) {
+            this.failedAttempts++;
+            throw createDatabaseError(DatabaseErrorCode.CONNECTION_FAILED, `Failed to initialize ${this.config.type} connection pool`, err instanceof Error ? err : new Error(String(err)), {
+                config: this.config
+            });
+        }
+    }
+    /**
+   * Initialize SQLite connection pool
+   */ async initializeSQLitePool() {
+        const dbPath = this.config.database || this.config.connectionString || ':memory:';
+        if (!dbPath || dbPath === '') {
+            throw new Error('SQLite database path is required');
+        }
+        // Create connection pool for SQLite
+        for(let i = 0; i < this.options.minConnections; i++){
+            const db = await open({
+                filename: dbPath,
+                driver: sqlite3.Database
+            });
+            await db.run('PRAGMA foreign_keys = ON');
+            await db.run(`PRAGMA busy_timeout = ${this.config.timeout || 5000}`);
+            this.connections.add(db);
+        }
+    }
+    /**
+   * Initialize Redis connection pool
+   */ async initializeRedisPool() {
+        let url = this.config.connectionString;
+        if (!url) {
+            // Build connection string with optional authentication
+            const host = this.config.host || 'localhost';
+            const port = this.config.port || 6379;
+            if (this.config.password) {
+                // Include password in connection string: redis://:password@host:port
+                url = `redis://:${encodeURIComponent(this.config.password)}@${host}:${port}`;
+            } else {
+                url = `redis://${host}:${port}`;
+            }
+        }
+        this.pool = createClient({
+            url,
+            socket: {
+                connectTimeout: this.config.timeout || 5000,
+                reconnectStrategy: (retries)=>{
+                    if (retries > this.maxReconnectAttempts) {
+                        return false;
+                    }
+                    // Exponential backoff
+                    return Math.min(this.options.reconnectBaseDelay * Math.pow(2, retries), 30000);
+                }
+            }
+        });
+        // Set up event handlers
+        this.pool.on('error', (err)=>{
+            console.error('Redis connection error:', err);
+            this.failedAttempts++;
+        });
+        this.pool.on('reconnecting', ()=>{
+            this.reconnectAttempts++;
+        });
+        await this.pool.connect();
+    }
+    /**
+   * Initialize PostgreSQL connection pool
+   */ async initializePostgresPool() {
+        const connectionString = this.config.connectionString || `postgresql://${this.config.username}:${this.config.password}@${this.config.host}:${this.config.port}/${this.config.database}`;
+        this.pool = new Pool({
+            connectionString,
+            min: this.options.minConnections,
+            max: this.options.maxConnections,
+            idleTimeoutMillis: this.options.idleTimeout,
+            connectionTimeoutMillis: this.options.acquireTimeout
+        });
+        // Test connection
+        const client = await this.pool.connect();
+        await client.query('SELECT 1');
+        client.release();
+    }
+    /**
+   * Warm up pool by creating minimum connections
+   */ async warmUpPool() {
+        if (this.config.type === 'sqlite') {
+            // SQLite connections already created in initializeSQLitePool
+            return;
+        }
+        // For Redis and Postgres, connections are managed by their libraries
+        // We just need to verify connectivity
+        if (this.config.type === 'redis') {
+            await this.pool.ping();
+        } else if (this.config.type === 'postgres') {
+            const client = await this.pool.connect();
+            await client.query('SELECT 1');
+            client.release();
+        }
+    }
+    /**
+   * Acquire connection from pool
+   */ async acquire() {
+        if (this.isShuttingDown) {
+            throw createDatabaseError(DatabaseErrorCode.CONNECTION_FAILED, 'Connection pool is shutting down', undefined, {
+                type: this.config.type
+            });
+        }
+        const startTime = Date.now();
+        try {
+            switch(this.config.type){
+                case 'sqlite':
+                    return await this.acquireSQLiteConnection(startTime);
+                case 'redis':
+                    return this.pool;
+                case 'postgres':
+                    return await this.pool.connect();
+                default:
+                    throw new Error(`Unsupported database type: ${this.config.type}`);
+            }
+        } catch (err) {
+            throw createDatabaseError(DatabaseErrorCode.CONNECTION_FAILED, 'Failed to acquire connection', err instanceof Error ? err : new Error(String(err)), {
+                type: this.config.type
+            });
+        }
+    }
+    /**
+   * Acquire SQLite connection from pool
+   */ async acquireSQLiteConnection(startTime) {
+        // Check for available connection
+        const availableConnection = Array.from(this.connections).find((conn)=>!this.activeConnections.has(conn));
+        if (availableConnection) {
+            this.activeConnections.add(availableConnection);
+            return availableConnection;
+        }
+        // Check if we can create more connections
+        if (this.connections.size < this.options.maxConnections) {
+            const newConnection = await this.createSQLiteConnection();
+            this.connections.add(newConnection);
+            this.activeConnections.add(newConnection);
+            return newConnection;
+        }
+        // Queue request
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
+                const index = this.pendingRequests.findIndex((req)=>req.resolve === resolve);
+                if (index !== -1) {
+                    this.pendingRequests.splice(index, 1);
+                }
+                reject(createDatabaseError(DatabaseErrorCode.TIMEOUT, 'Connection acquisition timeout', undefined, {
+                    timeout: this.options.acquireTimeout
+                }));
+            }, this.options.acquireTimeout);
+            this.pendingRequests.push({
+                resolve: (conn)=>{
+                    clearTimeout(timeoutId);
+                    resolve(conn);
+                },
+                reject: (err)=>{
+                    clearTimeout(timeoutId);
+                    reject(err);
+                },
+                timestamp: startTime
+            });
+        });
+    }
+    /**
+   * Create new SQLite connection
+   */ async createSQLiteConnection() {
+        const dbPath = this.config.database || this.config.connectionString || ':memory:';
+        const db = await open({
+            filename: dbPath,
+            driver: sqlite3.Database
+        });
+        await db.run('PRAGMA foreign_keys = ON');
+        await db.run(`PRAGMA busy_timeout = ${this.config.timeout || 5000}`);
+        return db;
+    }
+    /**
+   * Release connection back to pool
+   */ async release(connection) {
+        if (!connection) {
+            return;
+        }
+        try {
+            switch(this.config.type){
+                case 'sqlite':
+                    this.releaseSQLiteConnection(connection);
+                    break;
+                case 'redis':
+                    break;
+                case 'postgres':
+                    if (connection && typeof connection.release === 'function') {
+                        connection.release();
+                    }
+                    break;
+            }
+        } catch (err) {
+            console.error('Failed to release connection:', err);
+        }
+    }
+    /**
+   * Release SQLite connection
+   */ releaseSQLiteConnection(connection) {
+        this.activeConnections.delete(connection);
+        // Process pending requests
+        if (this.pendingRequests.length > 0) {
+            const pending = this.pendingRequests.shift();
+            if (pending) {
+                this.activeConnections.add(connection);
+                pending.resolve(connection);
+            }
+        }
+    }
+    /**
+   * Start periodic health checks
+   */ startHealthChecks() {
+        if (this.healthCheckActive) {
+            return;
+        }
+        this.healthCheckActive = true;
+        this.healthCheckInterval = setInterval(async ()=>{
+            try {
+                const healthy = await this.performHealthCheck();
+                this.lastHealthCheck = new Date();
+                if (!healthy) {
+                    console.warn(`Health check failed for ${this.config.type} pool`);
+                    await this.attemptReconnection();
+                }
+            } catch (err) {
+                console.error('Health check error:', err);
+            }
+        }, this.options.healthCheckInterval);
+    }
+    /**
+   * Stop health checks
+   */ stopHealthChecks() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = undefined;
+        }
+        this.healthCheckActive = false;
+    }
+    /**
+   * Perform health check
+   */ async performHealthCheck() {
+        try {
+            switch(this.config.type){
+                case 'sqlite':
+                    {
+                        const connection = Array.from(this.connections)[0];
+                        if (connection) {
+                            await connection.get('SELECT 1');
+                            return true;
+                        }
+                        return false;
+                    }
+                case 'redis':
+                    if (this.pool) {
+                        await this.pool.ping();
+                        return true;
+                    }
+                    return false;
+                case 'postgres':
+                    if (this.pool) {
+                        const client = await this.pool.connect();
+                        await client.query('SELECT 1');
+                        client.release();
+                        return true;
+                    }
+                    return false;
+                default:
+                    return false;
+            }
+        } catch (err) {
+            return false;
+        }
+    }
+    /**
+   * Check if pool is healthy (exposed for testing)
+   */ async isHealthy() {
+        return this.performHealthCheck();
+    }
+    /**
+   * Attempt reconnection with exponential backoff
+   */ async attemptReconnection() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached for ${this.config.type}`);
+            return;
+        }
+        const delay = Math.min(this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts), 30000);
+        this.reconnectAttempts++;
+        await new Promise((resolve)=>setTimeout(resolve, delay));
+        try {
+            await this.initialize();
+            console.log(`Reconnection successful for ${this.config.type}`);
+            this.reconnectAttempts = 0;
+        } catch (err) {
+            console.error(`Reconnection failed for ${this.config.type}:`, err);
+        }
+    }
+    /**
+   * Get reconnection delays for testing
+   */ getReconnectDelays() {
+        const delays = [];
+        for(let i = 0; i < 5; i++){
+            delays.push(Math.min(this.options.reconnectBaseDelay * Math.pow(2, i), 30000));
+        }
+        return delays;
+    }
+    /**
+   * Simulate disconnection (for testing)
+   */ simulateDisconnection() {
+        if (this.config.type === 'redis' && this.pool) {
+            this.pool.disconnect();
+        } else if (this.config.type === 'postgres' && this.pool) {
+            this.pool.end();
+        }
+    }
+    /**
+   * Remove unhealthy connections (for testing)
+   */ removeUnhealthyConnections(count) {
+        if (this.config.type === 'sqlite') {
+            const connectionsToRemove = Array.from(this.connections).slice(0, count);
+            connectionsToRemove.forEach((conn)=>{
+                this.connections.delete(conn);
+                this.activeConnections.delete(conn);
+                conn.close();
+            });
+        }
+    }
+    /**
+   * Enable cache fallback for graceful degradation
+   */ enableCacheFallback(enabled) {
+        this.cacheFallbackEnabled = enabled;
+    }
+    /**
+   * Get data with cache fallback
+   */ async getWithFallback(key) {
+        try {
+            const connection = await this.acquire();
+            // Actual data retrieval would happen here
+            await this.release(connection);
+            return null;
+        } catch (err) {
+            if (this.cacheFallbackEnabled && this.cache.has(key)) {
+                console.warn(`Using cached data for key: ${key}`);
+                return this.cache.get(key);
+            }
+            throw err;
+        }
+    }
+    /**
+   * Get connection pool statistics
+   */ getStats() {
+        const now = Date.now();
+        const uptime = now - this.startTime.getTime();
+        switch(this.config.type){
+            case 'sqlite':
+                return {
+                    type: 'sqlite',
+                    total: this.connections.size,
+                    active: this.activeConnections.size,
+                    idle: this.connections.size - this.activeConnections.size,
+                    pending: this.pendingRequests.length,
+                    maxConnections: this.options.maxConnections,
+                    available: this.connections.size - this.activeConnections.size,
+                    healthy: this.connections.size > 0,
+                    lastHealthCheck: this.lastHealthCheck,
+                    healthCheckActive: this.healthCheckActive,
+                    reconnectAttempts: this.reconnectAttempts,
+                    failedAttempts: this.failedAttempts,
+                    uptime
+                };
+            case 'redis':
+                return {
+                    type: 'redis',
+                    total: this.pool ? 1 : 0,
+                    active: this.pool?.isOpen ? 1 : 0,
+                    idle: 0,
+                    pending: 0,
+                    maxConnections: 1,
+                    available: this.pool?.isOpen ? 1 : 0,
+                    healthy: this.pool?.isOpen ?? false,
+                    lastHealthCheck: this.lastHealthCheck,
+                    healthCheckActive: this.healthCheckActive,
+                    reconnectAttempts: this.reconnectAttempts,
+                    failedAttempts: this.failedAttempts,
+                    uptime
+                };
+            case 'postgres':
+                return {
+                    type: 'postgres',
+                    total: this.pool?.totalCount ?? 0,
+                    active: (this.pool?.totalCount ?? 0) - (this.pool?.idleCount ?? 0),
+                    idle: this.pool?.idleCount ?? 0,
+                    pending: this.pool?.waitingCount ?? 0,
+                    maxConnections: this.options.maxConnections,
+                    available: this.pool?.idleCount ?? 0,
+                    healthy: this.pool !== null,
+                    lastHealthCheck: this.lastHealthCheck,
+                    healthCheckActive: this.healthCheckActive,
+                    reconnectAttempts: this.reconnectAttempts,
+                    failedAttempts: this.failedAttempts,
+                    uptime
+                };
+            default:
+                throw new Error(`Unsupported database type: ${this.config.type}`);
+        }
+    }
+    /**
+   * Shutdown connection pool
+   */ async shutdown() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        this.isShuttingDown = true;
+        this.stopHealthChecks();
+        // Reject all pending requests
+        this.pendingRequests.forEach((req)=>{
+            req.reject(createDatabaseError(DatabaseErrorCode.CONNECTION_FAILED, 'Connection pool is shutting down', undefined, {
+                type: this.config.type
+            }));
+        });
+        this.pendingRequests = [];
+        // Close all connections
+        try {
+            switch(this.config.type){
+                case 'sqlite':
+                    await Promise.all(Array.from(this.connections).map((conn)=>conn.close()));
+                    this.connections.clear();
+                    this.activeConnections.clear();
+                    break;
+                case 'redis':
+                    if (this.pool) {
+                        await this.pool.quit();
+                        this.pool = null;
+                    }
+                    break;
+                case 'postgres':
+                    if (this.pool) {
+                        await this.pool.end();
+                        this.pool = null;
+                    }
+                    break;
+            }
+        } catch (err) {
+            console.error('Error during shutdown:', err);
+        }
+    }
+}
+
+//# sourceMappingURL=connection-pool-manager.js.map

package/dist/lib/database-service/connection-pool-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/database-service/connection-pool-manager.ts"],"sourcesContent":["/**\r\n * Connection Pool Manager\r\n *\r\n * Manages connection pools for database adapters with:\r\n * - Automatic initialization on service startup\r\n * - Connection health checks (ping every 30s)\r\n * - Automatic reconnection with exponential backoff\r\n * - Connection metrics (active, idle, pending)\r\n * - Graceful degradation on connection failures\r\n *\r\n * Part of Bug Fix: Connection Pool Initialization\r\n */\r\n\r\nimport sqlite3 from 'sqlite3';\r\nimport { open, Database } from 'sqlite';\r\nimport { createClient, RedisClientType } from 'redis';\r\nimport { Pool, PoolClient } from 'pg';\r\nimport {\r\n  DatabaseConfig,\r\n  DatabaseErrorCode,\r\n} from './types.js';\r\nimport { createDatabaseError } from './errors.js';\r\n\r\nexport interface ConnectionPoolStats {\r\n  type: 'redis' | 'sqlite' | 'postgres';\r\n  total: number;\r\n  active: number;\r\n  idle: number;\r\n  pending: number;\r\n  maxConnections: number;\r\n  available: number;\r\n  healthy: boolean;\r\n  lastHealthCheck?: Date;\r\n  healthCheckActive: boolean;\r\n  reconnectAttempts: number;\r\n  failedAttempts: number;\r\n  uptime: number;\r\n}\r\n\r\nexport interface PoolOptions {\r\n  minConnections?: number;\r\n  maxConnections?: number;\r\n  acquireTimeout?: number;\r\n  idleTimeout?: number;\r\n  healthCheckInterval?: number;\r\n  maxReconnectAttempts?: number;\r\n  reconnectBaseDelay?: number;\r\n}\r\n\r\n/**\r\n * Connection Pool Manager\r\n *\r\n * Manages connection lifecycle, health checks, and automatic recovery\r\n */\r\nexport class ConnectionPoolManager {\r\n  private config: DatabaseConfig;\r\n  private options: Required<PoolOptions>;\r\n  private pool: any = null;\r\n  private connections: Set<any> = new Set();\r\n  private activeConnections: Set<any> = new Set();\r\n  private pendingRequests: Array<{\r\n    resolve: (connection: any) => void;\r\n    reject: (error: Error) => void;\r\n    timestamp: number;\r\n  }> = [];\r\n  private healthCheckInterval?: NodeJS.Timeout;\r\n  private lastHealthCheck?: Date;\r\n  private healthCheckActive: boolean = false;\r\n  private reconnectAttempts: number = 0;\r\n  private maxReconnectAttempts: number = 10;\r\n  private failedAttempts: number = 0;\r\n  private startTime: Date;\r\n  private isShuttingDown: boolean = false;\r\n  private cacheFallbackEnabled: boolean = false;\r\n  private cache: Map<string, any> = new Map();\r\n\r\n  constructor(config: DatabaseConfig, options: PoolOptions = {}) {\r\n    this.config = config;\r\n    this.options = {\r\n      minConnections: options.minConnections ?? 2,\r\n      maxConnections: options.maxConnections ?? config.poolSize ?? 10,\r\n      acquireTimeout: options.acquireTimeout ?? config.timeout ?? 5000,\r\n      idleTimeout: options.idleTimeout ?? 30000,\r\n      healthCheckInterval: options.healthCheckInterval ?? 30000,\r\n      maxReconnectAttempts: options.maxReconnectAttempts ?? 10,\r\n      reconnectBaseDelay: options.reconnectBaseDelay ?? 1000,\r\n    };\r\n    this.maxReconnectAttempts = this.options.maxReconnectAttempts;\r\n    this.startTime = new Date();\r\n  }\r\n\r\n  /**\r\n   * Initialize connection pool\r\n   */\r\n  async initialize(): Promise<void> {\r\n    try {\r\n      switch (this.config.type) {\r\n        case 'sqlite':\r\n          await this.initializeSQLitePool();\r\n          break;\r\n        case 'redis':\r\n          await this.initializeRedisPool();\r\n          break;\r\n        case 'postgres':\r\n          await this.initializePostgresPool();\r\n          break;\r\n        default:\r\n          throw new Error(`Unsupported database type: ${this.config.type}`);\r\n      }\r\n\r\n      // Initialize minimum connections\r\n      await this.warmUpPool();\r\n    } catch (err) {\r\n      this.failedAttempts++;\r\n      throw createDatabaseError(\r\n        DatabaseErrorCode.CONNECTION_FAILED,\r\n        `Failed to initialize ${this.config.type} connection pool`,\r\n        err instanceof Error ? err : new Error(String(err)),\r\n        { config: this.config }\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Initialize SQLite connection pool\r\n   */\r\n  private async initializeSQLitePool(): Promise<void> {\r\n    const dbPath = this.config.database || this.config.connectionString || ':memory:';\r\n\r\n    if (!dbPath || dbPath === '') {\r\n      throw new Error('SQLite database path is required');\r\n    }\r\n\r\n    // Create connection pool for SQLite\r\n    for (let i = 0; i < this.options.minConnections; i++) {\r\n      const db = await open({\r\n        filename: dbPath,\r\n        driver: sqlite3.Database,\r\n      });\r\n\r\n      await db.run('PRAGMA foreign_keys = ON');\r\n      await db.run(`PRAGMA busy_timeout = ${this.config.timeout || 5000}`);\r\n\r\n      this.connections.add(db);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Initialize Redis connection pool\r\n   */\r\n  private async initializeRedisPool(): Promise<void> {\r\n    let url = this.config.connectionString;\r\n\r\n    if (!url) {\r\n      // Build connection string with optional authentication\r\n      const host = this.config.host || 'localhost';\r\n      const port = this.config.port || 6379;\r\n\r\n      if (this.config.password) {\r\n        // Include password in connection string: redis://:password@host:port\r\n        url = `redis://:${encodeURIComponent(this.config.password)}@${host}:${port}`;\r\n      } else {\r\n        url = `redis://${host}:${port}`;\r\n      }\r\n    }\r\n\r\n    this.pool = createClient({\r\n      url,\r\n      socket: {\r\n        connectTimeout: this.config.timeout || 5000,\r\n        reconnectStrategy: (retries) => {\r\n          if (retries > this.maxReconnectAttempts) {\r\n            return false;\r\n          }\r\n          // Exponential backoff\r\n          return Math.min(this.options.reconnectBaseDelay * Math.pow(2, retries), 30000);\r\n        },\r\n      },\r\n    });\r\n\r\n    // Set up event handlers\r\n    this.pool.on('error', (err: Error) => {\r\n      console.error('Redis connection error:', err);\r\n      this.failedAttempts++;\r\n    });\r\n\r\n    this.pool.on('reconnecting', () => {\r\n      this.reconnectAttempts++;\r\n    });\r\n\r\n    await this.pool.connect();\r\n  }\r\n\r\n  /**\r\n   * Initialize PostgreSQL connection pool\r\n   */\r\n  private async initializePostgresPool(): Promise<void> {\r\n    const connectionString = this.config.connectionString ||\r\n      `postgresql://${this.config.username}:${this.config.password}@${this.config.host}:${this.config.port}/${this.config.database}`;\r\n\r\n    this.pool = new Pool({\r\n      connectionString,\r\n      min: this.options.minConnections,\r\n      max: this.options.maxConnections,\r\n      idleTimeoutMillis: this.options.idleTimeout,\r\n      connectionTimeoutMillis: this.options.acquireTimeout,\r\n    });\r\n\r\n    // Test connection\r\n    const client = await this.pool.connect();\r\n    await client.query('SELECT 1');\r\n    client.release();\r\n  }\r\n\r\n  /**\r\n   * Warm up pool by creating minimum connections\r\n   */\r\n  private async warmUpPool(): Promise<void> {\r\n    if (this.config.type === 'sqlite') {\r\n      // SQLite connections already created in initializeSQLitePool\r\n      return;\r\n    }\r\n\r\n    // For Redis and Postgres, connections are managed by their libraries\r\n    // We just need to verify connectivity\r\n    if (this.config.type === 'redis') {\r\n      await this.pool.ping();\r\n    } else if (this.config.type === 'postgres') {\r\n      const client = await this.pool.connect();\r\n      await client.query('SELECT 1');\r\n      client.release();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Acquire connection from pool\r\n   */\r\n  async acquire(): Promise<any> {\r\n    if (this.isShuttingDown) {\r\n      throw createDatabaseError(\r\n        DatabaseErrorCode.CONNECTION_FAILED,\r\n        'Connection pool is shutting down',\r\n        undefined,\r\n        { type: this.config.type }\r\n      );\r\n    }\r\n\r\n    const startTime = Date.now();\r\n\r\n    try {\r\n      switch (this.config.type) {\r\n        case 'sqlite':\r\n          return await this.acquireSQLiteConnection(startTime);\r\n        case 'redis':\r\n          return this.pool;\r\n        case 'postgres':\r\n          return await this.pool.connect();\r\n        default:\r\n          throw new Error(`Unsupported database type: ${this.config.type}`);\r\n      }\r\n    } catch (err) {\r\n      throw createDatabaseError(\r\n        DatabaseErrorCode.CONNECTION_FAILED,\r\n        'Failed to acquire connection',\r\n        err instanceof Error ? err : new Error(String(err)),\r\n        { type: this.config.type }\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Acquire SQLite connection from pool\r\n   */\r\n  private async acquireSQLiteConnection(startTime: number): Promise<Database> {\r\n    // Check for available connection\r\n    const availableConnection = Array.from(this.connections).find(\r\n      conn => !this.activeConnections.has(conn)\r\n    );\r\n\r\n    if (availableConnection) {\r\n      this.activeConnections.add(availableConnection);\r\n      return availableConnection as Database;\r\n    }\r\n\r\n    // Check if we can create more connections\r\n    if (this.connections.size < this.options.maxConnections) {\r\n      const newConnection = await this.createSQLiteConnection();\r\n      this.connections.add(newConnection);\r\n      this.activeConnections.add(newConnection);\r\n      return newConnection;\r\n    }\r\n\r\n    // Queue request\r\n    return new Promise((resolve, reject) => {\r\n      const timeoutId = setTimeout(() => {\r\n        const index = this.pendingRequests.findIndex(req => req.resolve === resolve);\r\n        if (index !== -1) {\r\n          this.pendingRequests.splice(index, 1);\r\n        }\r\n        reject(createDatabaseError(\r\n          DatabaseErrorCode.TIMEOUT,\r\n          'Connection acquisition timeout',\r\n          undefined,\r\n          { timeout: this.options.acquireTimeout }\r\n        ));\r\n      }, this.options.acquireTimeout);\r\n\r\n      this.pendingRequests.push({\r\n        resolve: (conn) => {\r\n          clearTimeout(timeoutId);\r\n          resolve(conn);\r\n        },\r\n        reject: (err) => {\r\n          clearTimeout(timeoutId);\r\n          reject(err);\r\n        },\r\n        timestamp: startTime,\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Create new SQLite connection\r\n   */\r\n  private async createSQLiteConnection(): Promise<Database> {\r\n    const dbPath = this.config.database || this.config.connectionString || ':memory:';\r\n\r\n    const db = await open({\r\n      filename: dbPath,\r\n      driver: sqlite3.Database,\r\n    });\r\n\r\n    await db.run('PRAGMA foreign_keys = ON');\r\n    await db.run(`PRAGMA busy_timeout = ${this.config.timeout || 5000}`);\r\n\r\n    return db;\r\n  }\r\n\r\n  /**\r\n   * Release connection back to pool\r\n   */\r\n  async release(connection: any): Promise<void> {\r\n    if (!connection) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      switch (this.config.type) {\r\n        case 'sqlite':\r\n          this.releaseSQLiteConnection(connection);\r\n          break;\r\n        case 'redis':\r\n          // Redis client is shared, no release needed\r\n          break;\r\n        case 'postgres':\r\n          if (connection && typeof connection.release === 'function') {\r\n            connection.release();\r\n          }\r\n          break;\r\n      }\r\n    } catch (err) {\r\n      console.error('Failed to release connection:', err);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Release SQLite connection\r\n   */\r\n  private releaseSQLiteConnection(connection: Database): void {\r\n    this.activeConnections.delete(connection);\r\n\r\n    // Process pending requests\r\n    if (this.pendingRequests.length > 0) {\r\n      const pending = this.pendingRequests.shift();\r\n      if (pending) {\r\n        this.activeConnections.add(connection);\r\n        pending.resolve(connection);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start periodic health checks\r\n   */\r\n  startHealthChecks(): void {\r\n    if (this.healthCheckActive) {\r\n      return;\r\n    }\r\n\r\n    this.healthCheckActive = true;\r\n    this.healthCheckInterval = setInterval(async () => {\r\n      try {\r\n        const healthy = await this.performHealthCheck();\r\n        this.lastHealthCheck = new Date();\r\n\r\n        if (!healthy) {\r\n          console.warn(`Health check failed for ${this.config.type} pool`);\r\n          await this.attemptReconnection();\r\n        }\r\n      } catch (err) {\r\n        console.error('Health check error:', err);\r\n      }\r\n    }, this.options.healthCheckInterval);\r\n  }\r\n\r\n  /**\r\n   * Stop health checks\r\n   */\r\n  stopHealthChecks(): void {\r\n    if (this.healthCheckInterval) {\r\n      clearInterval(this.healthCheckInterval);\r\n      this.healthCheckInterval = undefined;\r\n    }\r\n    this.healthCheckActive = false;\r\n  }\r\n\r\n  /**\r\n   * Perform health check\r\n   */\r\n  private async performHealthCheck(): Promise<boolean> {\r\n    try {\r\n      switch (this.config.type) {\r\n        case 'sqlite': {\r\n          const connection = Array.from(this.connections)[0];\r\n          if (connection) {\r\n            await (connection as Database).get('SELECT 1');\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n        case 'redis':\r\n          if (this.pool) {\r\n            await this.pool.ping();\r\n            return true;\r\n          }\r\n          return false;\r\n        case 'postgres':\r\n          if (this.pool) {\r\n            const client = await this.pool.connect();\r\n            await client.query('SELECT 1');\r\n            client.release();\r\n            return true;\r\n          }\r\n          return false;\r\n        default:\r\n          return false;\r\n      }\r\n    } catch (err) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if pool is healthy (exposed for testing)\r\n   */\r\n  private async isHealthy(): Promise<boolean> {\r\n    return this.performHealthCheck();\r\n  }\r\n\r\n  /**\r\n   * Attempt reconnection with exponential backoff\r\n   */\r\n  private async attemptReconnection(): Promise<void> {\r\n    if (this.reconnectAttempts >= this.maxReconnectAttempts) {\r\n      console.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached for ${this.config.type}`);\r\n      return;\r\n    }\r\n\r\n    const delay = Math.min(\r\n      this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts),\r\n      30000\r\n    );\r\n\r\n    this.reconnectAttempts++;\r\n\r\n    await new Promise(resolve => setTimeout(resolve, delay));\r\n\r\n    try {\r\n      await this.initialize();\r\n      console.log(`Reconnection successful for ${this.config.type}`);\r\n      this.reconnectAttempts = 0;\r\n    } catch (err) {\r\n      console.error(`Reconnection failed for ${this.config.type}:`, err);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get reconnection delays for testing\r\n   */\r\n  private getReconnectDelays(): number[] {\r\n    const delays: number[] = [];\r\n    for (let i = 0; i < 5; i++) {\r\n      delays.push(\r\n        Math.min(this.options.reconnectBaseDelay * Math.pow(2, i), 30000)\r\n      );\r\n    }\r\n    return delays;\r\n  }\r\n\r\n  /**\r\n   * Simulate disconnection (for testing)\r\n   */\r\n  private simulateDisconnection(): void {\r\n    if (this.config.type === 'redis' && this.pool) {\r\n      this.pool.disconnect();\r\n    } else if (this.config.type === 'postgres' && this.pool) {\r\n      this.pool.end();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove unhealthy connections (for testing)\r\n   */\r\n  private removeUnhealthyConnections(count: number): void {\r\n    if (this.config.type === 'sqlite') {\r\n      const connectionsToRemove = Array.from(this.connections).slice(0, count);\r\n      connectionsToRemove.forEach(conn => {\r\n        this.connections.delete(conn);\r\n        this.activeConnections.delete(conn);\r\n        (conn as Database).close();\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Enable cache fallback for graceful degradation\r\n   */\r\n  enableCacheFallback(enabled: boolean): void {\r\n    this.cacheFallbackEnabled = enabled;\r\n  }\r\n\r\n  /**\r\n   * Get data with cache fallback\r\n   */\r\n  async getWithFallback(key: string): Promise<any> {\r\n    try {\r\n      const connection = await this.acquire();\r\n      // Actual data retrieval would happen here\r\n      await this.release(connection);\r\n      return null;\r\n    } catch (err) {\r\n      if (this.cacheFallbackEnabled && this.cache.has(key)) {\r\n        console.warn(`Using cached data for key: ${key}`);\r\n        return this.cache.get(key);\r\n      }\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get connection pool statistics\r\n   */\r\n  getStats(): ConnectionPoolStats {\r\n    const now = Date.now();\r\n    const uptime = now - this.startTime.getTime();\r\n\r\n    switch (this.config.type) {\r\n      case 'sqlite':\r\n        return {\r\n          type: 'sqlite',\r\n          total: this.connections.size,\r\n          active: this.activeConnections.size,\r\n          idle: this.connections.size - this.activeConnections.size,\r\n          pending: this.pendingRequests.length,\r\n          maxConnections: this.options.maxConnections,\r\n          available: this.connections.size - this.activeConnections.size,\r\n          healthy: this.connections.size > 0,\r\n          lastHealthCheck: this.lastHealthCheck,\r\n          healthCheckActive: this.healthCheckActive,\r\n          reconnectAttempts: this.reconnectAttempts,\r\n          failedAttempts: this.failedAttempts,\r\n          uptime,\r\n        };\r\n\r\n      case 'redis':\r\n        return {\r\n          type: 'redis',\r\n          total: this.pool ? 1 : 0,\r\n          active: this.pool?.isOpen ? 1 : 0,\r\n          idle: 0,\r\n          pending: 0,\r\n          maxConnections: 1,\r\n          available: this.pool?.isOpen ? 1 : 0,\r\n          healthy: this.pool?.isOpen ?? false,\r\n          lastHealthCheck: this.lastHealthCheck,\r\n          healthCheckActive: this.healthCheckActive,\r\n          reconnectAttempts: this.reconnectAttempts,\r\n          failedAttempts: this.failedAttempts,\r\n          uptime,\r\n        };\r\n\r\n      case 'postgres':\r\n        return {\r\n          type: 'postgres',\r\n          total: this.pool?.totalCount ?? 0,\r\n          active: (this.pool?.totalCount ?? 0) - (this.pool?.idleCount ?? 0),\r\n          idle: this.pool?.idleCount ?? 0,\r\n          pending: this.pool?.waitingCount ?? 0,\r\n          maxConnections: this.options.maxConnections,\r\n          available: this.pool?.idleCount ?? 0,\r\n          healthy: this.pool !== null,\r\n          lastHealthCheck: this.lastHealthCheck,\r\n          healthCheckActive: this.healthCheckActive,\r\n          reconnectAttempts: this.reconnectAttempts,\r\n          failedAttempts: this.failedAttempts,\r\n          uptime,\r\n        };\r\n\r\n      default:\r\n        throw new Error(`Unsupported database type: ${this.config.type}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shutdown connection pool\r\n   */\r\n  async shutdown(): Promise<void> {\r\n    if (this.isShuttingDown) {\r\n      return;\r\n    }\r\n\r\n    this.isShuttingDown = true;\r\n    this.stopHealthChecks();\r\n\r\n    // Reject all pending requests\r\n    this.pendingRequests.forEach(req => {\r\n      req.reject(createDatabaseError(\r\n        DatabaseErrorCode.CONNECTION_FAILED,\r\n        'Connection pool is shutting down',\r\n        undefined,\r\n        { type: this.config.type }\r\n      ));\r\n    });\r\n    this.pendingRequests = [];\r\n\r\n    // Close all connections\r\n    try {\r\n      switch (this.config.type) {\r\n        case 'sqlite':\r\n          await Promise.all(\r\n            Array.from(this.connections).map(conn => (conn as Database).close())\r\n          );\r\n          this.connections.clear();\r\n          this.activeConnections.clear();\r\n          break;\r\n\r\n        case 'redis':\r\n          if (this.pool) {\r\n            await this.pool.quit();\r\n            this.pool = null;\r\n          }\r\n          break;\r\n\r\n        case 'postgres':\r\n          if (this.pool) {\r\n            await this.pool.end();\r\n            this.pool = null;\r\n          }\r\n          break;\r\n      }\r\n    } catch (err) {\r\n      console.error('Error during shutdown:', err);\r\n    }\r\n  }\r\n}\r\n"],"names":["sqlite3","open","createClient","Pool","DatabaseErrorCode","createDatabaseError","ConnectionPoolManager","config","options","pool","connections","Set","activeConnections","pendingRequests","healthCheckInterval","lastHealthCheck","healthCheckActive","reconnectAttempts","maxReconnectAttempts","failedAttempts","startTime","isShuttingDown","cacheFallbackEnabled","cache","Map","minConnections","maxConnections","poolSize","acquireTimeout","timeout","idleTimeout","reconnectBaseDelay","Date","initialize","type","initializeSQLitePool","initializeRedisPool","initializePostgresPool","Error","warmUpPool","err","CONNECTION_FAILED","String","dbPath","database","connectionString","i","db","filename","driver","Database","run","add","url","host","port","password","encodeURIComponent","socket","connectTimeout","reconnectStrategy","retries","Math","min","pow","on","console","error","connect","username","max","idleTimeoutMillis","connectionTimeoutMillis","client","query","release","ping","acquire","undefined","now","acquireSQLiteConnection","availableConnection","Array","from","find","conn","has","size","newConnection","createSQLiteConnection","Promise","resolve","reject","timeoutId","setTimeout","index","findIndex","req","splice","TIMEOUT","push","clearTimeout","timestamp","connection","releaseSQLiteConnection","delete","length","pending","shift","startHealthChecks","setInterval","healthy","performHealthCheck","warn","attemptReconnection","stopHealthChecks","clearInterval","get","isHealthy","delay","log","getReconnectDelays","delays","simulateDisconnection","disconnect","end","removeUnhealthyConnections","count","connectionsToRemove","slice","forEach","close","enableCacheFallback","enabled","getWithFallback","key","getStats","uptime","getTime","total","active","idle","available","isOpen","totalCount","idleCount","waitingCount","shutdown","all","map","clear","quit"],"mappings":"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"}