claude-flow-novice 2.16.0 → 2.16.1

package/dist/lib/connection-pool.js

@@ -0,0 +1,390 @@
+/**
+ * Connection Pool Manager - Phase 6 Performance Optimization
+ *
+ * Implements enterprise-grade connection pooling for PostgreSQL and Redis
+ * to achieve 3-5x throughput improvement over direct connections.
+ *
+ * Performance targets:
+ * - Direct connection: ~50ms overhead per query
+ * - Pooled connection: ~5ms overhead per query
+ * - 3-5x throughput improvement
+ *
+ * Features:
+ * - PostgreSQL pg-pool with configurable max connections (default 20)
+ * - Redis ioredis with connection pooling
+ * - Connection health checks
+ * - Graceful shutdown handlers
+ * - Error recovery with reconnection logic
+ * - Prometheus metrics exposure
+ * - TypeScript strict mode (no any types)
+ */ import { Pool } from 'pg';
+import Redis from 'ioredis';
+/**
+ * PostgreSQL connection pool singleton
+ */ export let pgPool = null;
+/**
+ * Redis connection pool singleton
+ */ export let redisPool = null;
+/**
+ * Initialization state tracking
+ */ let isInitialized = false;
+let isShuttingDown = false;
+let initializationPromise = null;
+/**
+ * Metrics tracking
+ */ let postgresCommandsProcessed = 0;
+let redisCommandsProcessed = 0;
+/**
+ * Initialize connection pools
+ * Thread-safe initialization with promise-based mutex
+ */ export async function initializePools(config) {
+    // Return if already initialized
+    if (isInitialized && pgPool && redisPool) {
+        console.log('Connection pools already initialized');
+        return;
+    }
+    // Wait for in-progress initialization
+    if (initializationPromise) {
+        console.log('Waiting for in-progress initialization...');
+        return initializationPromise;
+    }
+    // Atomic initialization with promise-based mutex
+    initializationPromise = (async ()=>{
+        try {
+            console.log('Initializing connection pools...');
+            // Validate configuration
+            validatePoolConfig(config);
+            // Initialize PostgreSQL pool
+            await initializePostgresPool(config.postgres);
+            // Initialize Redis pool
+            await initializeRedisPool(config.redis);
+            // Register shutdown handlers
+            registerShutdownHandlers();
+            isInitialized = true;
+            console.log('Connection pools initialized successfully');
+        } catch (error) {
+            console.error('Failed to initialize connection pools:', error);
+            // Cleanup on failure
+            await shutdownPools();
+            throw error;
+        } finally{
+            // Clear lock after initialization completes or fails
+            initializationPromise = null;
+        }
+    })();
+    return initializationPromise;
+}
+/**
+ * Validate pool configuration
+ */ function validatePoolConfig(config) {
+    // Validate PostgreSQL config
+    if (config.postgres.max < 4) {
+        throw new Error(`Invalid PostgreSQL max connections: ${config.postgres.max}. Minimum allowed is 4.`);
+    }
+    if (config.postgres.max > 100) {
+        throw new Error(`Invalid PostgreSQL max connections: ${config.postgres.max}. Maximum allowed is 100.`);
+    }
+    if (config.postgres.idleTimeoutMillis < 1000) {
+        throw new Error(`Invalid idle timeout: ${config.postgres.idleTimeoutMillis}ms. Minimum allowed is 1000ms.`);
+    }
+    if (config.postgres.connectionTimeoutMillis < 1000) {
+        throw new Error(`Invalid connection timeout: ${config.postgres.connectionTimeoutMillis}ms. Minimum allowed is 1000ms.`);
+    }
+    // Validate Redis config
+    if (config.redis.maxRetriesPerRequest < 0) {
+        throw new Error(`Invalid max retries: ${config.redis.maxRetriesPerRequest}. Must be >= 0.`);
+    }
+}
+/**
+ * Initialize PostgreSQL connection pool
+ */ async function initializePostgresPool(config) {
+    const poolConfig = {
+        host: config.host,
+        port: config.port,
+        database: config.database,
+        user: config.user,
+        password: config.password,
+        max: config.max,
+        idleTimeoutMillis: config.idleTimeoutMillis,
+        connectionTimeoutMillis: config.connectionTimeoutMillis,
+        // Additional pool settings for production
+        allowExitOnIdle: false,
+        application_name: 'cfn-connection-pool'
+    };
+    pgPool = new Pool(poolConfig);
+    // Handle pool errors with reconnection logic
+    pgPool.on('error', (err, client)=>{
+        console.error('Unexpected error on idle PostgreSQL client:', err.message);
+    // Error will trigger reconnection on next query
+    });
+    // Connection event tracking
+    pgPool.on('connect', (client)=>{
+        console.log('New PostgreSQL client connected to pool');
+    });
+    pgPool.on('acquire', (client)=>{
+    // Connection acquired from pool
+    });
+    pgPool.on('remove', (client)=>{
+        console.log('PostgreSQL client removed from pool');
+    });
+    // Test connection with timeout
+    try {
+        const client = await pgPool.connect();
+        try {
+            await client.query('SELECT 1 AS health_check');
+            console.log('PostgreSQL connection pool health check passed');
+        } finally{
+            client.release();
+        }
+    } catch (err) {
+        const error = err;
+        console.error('Failed to initialize PostgreSQL connection pool:', error.message);
+        throw new Error(`PostgreSQL pool initialization failed: ${error.message}`);
+    }
+}
+/**
+ * Initialize Redis connection pool
+ */ async function initializeRedisPool(config) {
+    const redisOptions = {
+        host: config.host,
+        port: config.port,
+        password: config.password,
+        maxRetriesPerRequest: config.maxRetriesPerRequest,
+        // Connection pooling settings
+        lazyConnect: false,
+        keepAlive: 30000,
+        connectTimeout: 10000,
+        retryStrategy: (times)=>{
+            if (times > 10) {
+                console.error('Redis connection retry limit exceeded');
+                return undefined; // Stop retrying
+            }
+            // Exponential backoff: 100ms, 200ms, 400ms, 800ms, ...
+            const delay = Math.min(100 * Math.pow(2, times), 3000);
+            console.log(`Redis reconnection attempt ${times} in ${delay}ms`);
+            return delay;
+        },
+        reconnectOnError: (err)=>{
+            // Reconnect on specific errors
+            const targetErrors = [
+                'READONLY',
+                'ECONNREFUSED',
+                'ETIMEDOUT'
+            ];
+            return targetErrors.some((target)=>err.message.includes(target));
+        },
+        enableReadyCheck: true,
+        enableOfflineQueue: true
+    };
+    redisPool = new Redis(redisOptions);
+    // Handle Redis events
+    redisPool.on('error', (err)=>{
+        console.error('Redis connection error:', err.message);
+    });
+    redisPool.on('ready', ()=>{
+        console.log('Redis connection ready');
+    });
+    redisPool.on('connect', ()=>{
+        console.log('Redis client connected');
+    });
+    redisPool.on('reconnecting', (delay)=>{
+        console.log(`Redis reconnecting in ${delay}ms`);
+    });
+    redisPool.on('close', ()=>{
+        console.log('Redis connection closed');
+    });
+    // Test connection with timeout
+    try {
+        const result = await redisPool.ping();
+        if (result !== 'PONG') {
+            throw new Error(`Unexpected ping response: ${result}`);
+        }
+        console.log('Redis connection pool health check passed');
+    } catch (err) {
+        const error = err;
+        console.error('Failed to initialize Redis connection pool:', error.message);
+        throw new Error(`Redis pool initialization failed: ${error.message}`);
+    }
+}
+/**
+ * Register graceful shutdown handlers
+ */ function registerShutdownHandlers() {
+    const shutdownHandler = async (signal)=>{
+        if (isShuttingDown) {
+            return;
+        }
+        console.log(`Received ${signal}, shutting down connection pools...`);
+        await shutdownPools();
+        process.exit(0);
+    };
+    process.on('SIGTERM', ()=>shutdownHandler('SIGTERM'));
+    process.on('SIGINT', ()=>shutdownHandler('SIGINT'));
+    // Handle uncaught errors
+    process.on('uncaughtException', async (err)=>{
+        console.error('Uncaught exception:', err);
+        await shutdownPools();
+        process.exit(1);
+    });
+    process.on('unhandledRejection', async (reason)=>{
+        console.error('Unhandled rejection:', reason);
+        await shutdownPools();
+        process.exit(1);
+    });
+}
+/**
+ * Gracefully shutdown all connection pools
+ */ export async function shutdownPools() {
+    if (isShuttingDown) {
+        console.log('Shutdown already in progress');
+        return;
+    }
+    console.log('Initiating graceful connection pool shutdown...');
+    isShuttingDown = true;
+    const shutdownPromises = [];
+    // Shutdown PostgreSQL pool
+    if (pgPool) {
+        shutdownPromises.push(pgPool.end().then(()=>{
+            console.log('PostgreSQL connection pool closed');
+            pgPool = null;
+        }).catch((err)=>{
+            console.error('Error closing PostgreSQL pool:', err.message);
+        }));
+    }
+    // Shutdown Redis pool
+    if (redisPool) {
+        shutdownPromises.push(redisPool.quit().then(()=>{
+            console.log('Redis connection pool closed');
+            redisPool = null;
+        }).catch((err)=>{
+            console.error('Error closing Redis pool:', err.message);
+        }));
+    }
+    await Promise.all(shutdownPromises);
+    isInitialized = false;
+    isShuttingDown = false;
+    console.log('Connection pool shutdown complete');
+}
+/**
+ * Get pool metrics for Prometheus monitoring
+ */ export function getPoolMetrics() {
+    if (!pgPool || !redisPool) {
+        throw new Error('Connection pools not initialized. Call initializePools first.');
+    }
+    return {
+        postgres: {
+            totalConnections: pgPool.totalCount,
+            idleConnections: pgPool.idleCount,
+            waitingRequests: pgPool.waitingCount,
+            activeConnections: pgPool.totalCount - pgPool.idleCount
+        },
+        redis: {
+            status: redisPool.status,
+            connectedClients: 1,
+            commandsProcessed: redisCommandsProcessed
+        },
+        timestamp: new Date().toISOString()
+    };
+}
+/**
+ * Execute PostgreSQL query with pooled connection
+ * Automatically handles connection acquisition and release
+ */ export async function executePostgresQuery(query, params) {
+    if (!pgPool) {
+        throw new Error('PostgreSQL pool not initialized. Call initializePools first.');
+    }
+    if (isShuttingDown) {
+        throw new Error('Connection pool is shutting down');
+    }
+    let client = null;
+    try {
+        client = await pgPool.connect();
+        const result = await client.query(query, params);
+        postgresCommandsProcessed++;
+        return result.rows;
+    } catch (err) {
+        const error = err;
+        console.error('PostgreSQL query error:', error.message);
+        throw new Error(`PostgreSQL query failed: ${error.message}`);
+    } finally{
+        if (client) {
+            client.release();
+        }
+    }
+}
+/**
+ * Execute Redis command with pooled connection
+ * Automatically handles reconnection on failure
+ */ export async function executeRedisCommand(command, ...args) {
+    if (!redisPool) {
+        throw new Error('Redis pool not initialized. Call initializePools first.');
+    }
+    if (isShuttingDown) {
+        throw new Error('Connection pool is shutting down');
+    }
+    try {
+        // Type-safe command execution using unknown cast
+        const redisClient = redisPool;
+        const result = await redisClient[command](...args);
+        redisCommandsProcessed++;
+        return result;
+    } catch (err) {
+        const error = err;
+        console.error(`Redis ${command} command error:`, error.message);
+        throw new Error(`Redis command failed: ${error.message}`);
+    }
+}
+/**
+ * Health check for all connection pools
+ */ export async function healthCheck() {
+    const health = {
+        postgres: false,
+        redis: false,
+        details: {
+            postgres: 'not initialized',
+            redis: 'not initialized'
+        }
+    };
+    // Check PostgreSQL
+    if (pgPool) {
+        try {
+            await executePostgresQuery('SELECT 1 AS health_check');
+            health.postgres = true;
+            health.details.postgres = 'healthy';
+        } catch (err) {
+            const error = err;
+            health.details.postgres = error.message;
+        }
+    }
+    // Check Redis
+    if (redisPool) {
+        try {
+            await redisPool.ping();
+            health.redis = true;
+            health.details.redis = 'healthy';
+        } catch (err) {
+            const error = err;
+            health.details.redis = error.message;
+        }
+    }
+    return health;
+}
+/**
+ * Get PostgreSQL pool instance (for advanced use cases)
+ * Most code should use executePostgresQuery instead
+ */ export function getPostgresPool() {
+    if (!pgPool) {
+        throw new Error('PostgreSQL pool not initialized. Call initializePools first.');
+    }
+    return pgPool;
+}
+/**
+ * Get Redis pool instance (for advanced use cases)
+ * Most code should use executeRedisCommand instead
+ */ export function getRedisPool() {
+    if (!redisPool) {
+        throw new Error('Redis pool not initialized. Call initializePools first.');
+    }
+    return redisPool;
+}
+
+//# sourceMappingURL=connection-pool.js.map

package/dist/lib/connection-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/connection-pool.ts"],"sourcesContent":["/**\r\n * Connection Pool Manager - Phase 6 Performance Optimization\r\n *\r\n * Implements enterprise-grade connection pooling for PostgreSQL and Redis\r\n * to achieve 3-5x throughput improvement over direct connections.\r\n *\r\n * Performance targets:\r\n * - Direct connection: ~50ms overhead per query\r\n * - Pooled connection: ~5ms overhead per query\r\n * - 3-5x throughput improvement\r\n *\r\n * Features:\r\n * - PostgreSQL pg-pool with configurable max connections (default 20)\r\n * - Redis ioredis with connection pooling\r\n * - Connection health checks\r\n * - Graceful shutdown handlers\r\n * - Error recovery with reconnection logic\r\n * - Prometheus metrics exposure\r\n * - TypeScript strict mode (no any types)\r\n */\r\n\r\nimport { Pool, PoolClient, PoolConfig as PgPoolConfig } from 'pg';\r\nimport Redis, { RedisOptions } from 'ioredis';\r\n\r\n/**\r\n * Pool configuration interface\r\n */\r\nexport interface PoolConfig {\r\n  postgres: {\r\n    host: string;\r\n    port: number;\r\n    database: string;\r\n    user: string;\r\n    password: string;\r\n    max: number; // Maximum pool size\r\n    idleTimeoutMillis: number; // Idle connection timeout\r\n    connectionTimeoutMillis: number; // Connection acquisition timeout\r\n  };\r\n  redis: {\r\n    host: string;\r\n    port: number;\r\n    password?: string;\r\n    maxRetriesPerRequest: number; // Max retry attempts per request\r\n  };\r\n}\r\n\r\n/**\r\n * Pool metrics for Prometheus monitoring\r\n */\r\nexport interface PoolMetrics {\r\n  postgres: {\r\n    totalConnections: number;\r\n    idleConnections: number;\r\n    waitingRequests: number;\r\n    activeConnections: number;\r\n  };\r\n  redis: {\r\n    status: string;\r\n    connectedClients: number;\r\n    commandsProcessed: number;\r\n  };\r\n  timestamp: string;\r\n}\r\n\r\n/**\r\n * Health check result\r\n */\r\ninterface HealthCheckResult {\r\n  postgres: boolean;\r\n  redis: boolean;\r\n  details: {\r\n    postgres: string;\r\n    redis: string;\r\n  };\r\n}\r\n\r\n/**\r\n * PostgreSQL connection pool singleton\r\n */\r\nexport let pgPool: Pool | null = null;\r\n\r\n/**\r\n * Redis connection pool singleton\r\n */\r\nexport let redisPool: Redis | null = null;\r\n\r\n/**\r\n * Initialization state tracking\r\n */\r\nlet isInitialized = false;\r\nlet isShuttingDown = false;\r\nlet initializationPromise: Promise<void> | null = null;\r\n\r\n/**\r\n * Metrics tracking\r\n */\r\nlet postgresCommandsProcessed = 0;\r\nlet redisCommandsProcessed = 0;\r\n\r\n/**\r\n * Initialize connection pools\r\n * Thread-safe initialization with promise-based mutex\r\n */\r\nexport async function initializePools(config: PoolConfig): Promise<void> {\r\n  // Return if already initialized\r\n  if (isInitialized && pgPool && redisPool) {\r\n    console.log('Connection pools already initialized');\r\n    return;\r\n  }\r\n\r\n  // Wait for in-progress initialization\r\n  if (initializationPromise) {\r\n    console.log('Waiting for in-progress initialization...');\r\n    return initializationPromise;\r\n  }\r\n\r\n  // Atomic initialization with promise-based mutex\r\n  initializationPromise = (async () => {\r\n    try {\r\n      console.log('Initializing connection pools...');\r\n\r\n      // Validate configuration\r\n      validatePoolConfig(config);\r\n\r\n      // Initialize PostgreSQL pool\r\n      await initializePostgresPool(config.postgres);\r\n\r\n      // Initialize Redis pool\r\n      await initializeRedisPool(config.redis);\r\n\r\n      // Register shutdown handlers\r\n      registerShutdownHandlers();\r\n\r\n      isInitialized = true;\r\n      console.log('Connection pools initialized successfully');\r\n    } catch (error) {\r\n      console.error('Failed to initialize connection pools:', error);\r\n      // Cleanup on failure\r\n      await shutdownPools();\r\n      throw error;\r\n    } finally {\r\n      // Clear lock after initialization completes or fails\r\n      initializationPromise = null;\r\n    }\r\n  })();\r\n\r\n  return initializationPromise;\r\n}\r\n\r\n/**\r\n * Validate pool configuration\r\n */\r\nfunction validatePoolConfig(config: PoolConfig): void {\r\n  // Validate PostgreSQL config\r\n  if (config.postgres.max < 4) {\r\n    throw new Error(\r\n      `Invalid PostgreSQL max connections: ${config.postgres.max}. Minimum allowed is 4.`\r\n    );\r\n  }\r\n  if (config.postgres.max > 100) {\r\n    throw new Error(\r\n      `Invalid PostgreSQL max connections: ${config.postgres.max}. Maximum allowed is 100.`\r\n    );\r\n  }\r\n  if (config.postgres.idleTimeoutMillis < 1000) {\r\n    throw new Error(\r\n      `Invalid idle timeout: ${config.postgres.idleTimeoutMillis}ms. Minimum allowed is 1000ms.`\r\n    );\r\n  }\r\n  if (config.postgres.connectionTimeoutMillis < 1000) {\r\n    throw new Error(\r\n      `Invalid connection timeout: ${config.postgres.connectionTimeoutMillis}ms. Minimum allowed is 1000ms.`\r\n    );\r\n  }\r\n\r\n  // Validate Redis config\r\n  if (config.redis.maxRetriesPerRequest < 0) {\r\n    throw new Error(\r\n      `Invalid max retries: ${config.redis.maxRetriesPerRequest}. Must be >= 0.`\r\n    );\r\n  }\r\n}\r\n\r\n/**\r\n * Initialize PostgreSQL connection pool\r\n */\r\nasync function initializePostgresPool(\r\n  config: PoolConfig['postgres']\r\n): Promise<void> {\r\n  const poolConfig: PgPoolConfig = {\r\n    host: config.host,\r\n    port: config.port,\r\n    database: config.database,\r\n    user: config.user,\r\n    password: config.password,\r\n    max: config.max,\r\n    idleTimeoutMillis: config.idleTimeoutMillis,\r\n    connectionTimeoutMillis: config.connectionTimeoutMillis,\r\n    // Additional pool settings for production\r\n    allowExitOnIdle: false,\r\n    application_name: 'cfn-connection-pool',\r\n  };\r\n\r\n  pgPool = new Pool(poolConfig);\r\n\r\n  // Handle pool errors with reconnection logic\r\n  pgPool.on('error', (err: Error, client: PoolClient) => {\r\n    console.error('Unexpected error on idle PostgreSQL client:', err.message);\r\n    // Error will trigger reconnection on next query\r\n  });\r\n\r\n  // Connection event tracking\r\n  pgPool.on('connect', (client: PoolClient) => {\r\n    console.log('New PostgreSQL client connected to pool');\r\n  });\r\n\r\n  pgPool.on('acquire', (client: PoolClient) => {\r\n    // Connection acquired from pool\r\n  });\r\n\r\n  pgPool.on('remove', (client: PoolClient) => {\r\n    console.log('PostgreSQL client removed from pool');\r\n  });\r\n\r\n  // Test connection with timeout\r\n  try {\r\n    const client = await pgPool.connect();\r\n    try {\r\n      await client.query('SELECT 1 AS health_check');\r\n      console.log('PostgreSQL connection pool health check passed');\r\n    } finally {\r\n      client.release();\r\n    }\r\n  } catch (err) {\r\n    const error = err as Error;\r\n    console.error('Failed to initialize PostgreSQL connection pool:', error.message);\r\n    throw new Error(`PostgreSQL pool initialization failed: ${error.message}`);\r\n  }\r\n}\r\n\r\n/**\r\n * Initialize Redis connection pool\r\n */\r\nasync function initializeRedisPool(config: PoolConfig['redis']): Promise<void> {\r\n  const redisOptions: RedisOptions = {\r\n    host: config.host,\r\n    port: config.port,\r\n    password: config.password,\r\n    maxRetriesPerRequest: config.maxRetriesPerRequest,\r\n    // Connection pooling settings\r\n    lazyConnect: false,\r\n    keepAlive: 30000, // Keep connections alive\r\n    connectTimeout: 10000, // 10s connection timeout\r\n    retryStrategy: (times: number): number | void => {\r\n      if (times > 10) {\r\n        console.error('Redis connection retry limit exceeded');\r\n        return undefined; // Stop retrying\r\n      }\r\n      // Exponential backoff: 100ms, 200ms, 400ms, 800ms, ...\r\n      const delay = Math.min(100 * Math.pow(2, times), 3000);\r\n      console.log(`Redis reconnection attempt ${times} in ${delay}ms`);\r\n      return delay;\r\n    },\r\n    reconnectOnError: (err: Error): boolean => {\r\n      // Reconnect on specific errors\r\n      const targetErrors = ['READONLY', 'ECONNREFUSED', 'ETIMEDOUT'];\r\n      return targetErrors.some((target) => err.message.includes(target));\r\n    },\r\n    enableReadyCheck: true,\r\n    enableOfflineQueue: true,\r\n  };\r\n\r\n  redisPool = new Redis(redisOptions);\r\n\r\n  // Handle Redis events\r\n  redisPool.on('error', (err: Error) => {\r\n    console.error('Redis connection error:', err.message);\r\n  });\r\n\r\n  redisPool.on('ready', () => {\r\n    console.log('Redis connection ready');\r\n  });\r\n\r\n  redisPool.on('connect', () => {\r\n    console.log('Redis client connected');\r\n  });\r\n\r\n  redisPool.on('reconnecting', (delay: number) => {\r\n    console.log(`Redis reconnecting in ${delay}ms`);\r\n  });\r\n\r\n  redisPool.on('close', () => {\r\n    console.log('Redis connection closed');\r\n  });\r\n\r\n  // Test connection with timeout\r\n  try {\r\n    const result = await redisPool.ping();\r\n    if (result !== 'PONG') {\r\n      throw new Error(`Unexpected ping response: ${result}`);\r\n    }\r\n    console.log('Redis connection pool health check passed');\r\n  } catch (err) {\r\n    const error = err as Error;\r\n    console.error('Failed to initialize Redis connection pool:', error.message);\r\n    throw new Error(`Redis pool initialization failed: ${error.message}`);\r\n  }\r\n}\r\n\r\n/**\r\n * Register graceful shutdown handlers\r\n */\r\nfunction registerShutdownHandlers(): void {\r\n  const shutdownHandler = async (signal: string): Promise<void> => {\r\n    if (isShuttingDown) {\r\n      return;\r\n    }\r\n    console.log(`Received ${signal}, shutting down connection pools...`);\r\n    await shutdownPools();\r\n    process.exit(0);\r\n  };\r\n\r\n  process.on('SIGTERM', () => shutdownHandler('SIGTERM'));\r\n  process.on('SIGINT', () => shutdownHandler('SIGINT'));\r\n\r\n  // Handle uncaught errors\r\n  process.on('uncaughtException', async (err: Error) => {\r\n    console.error('Uncaught exception:', err);\r\n    await shutdownPools();\r\n    process.exit(1);\r\n  });\r\n\r\n  process.on('unhandledRejection', async (reason: unknown) => {\r\n    console.error('Unhandled rejection:', reason);\r\n    await shutdownPools();\r\n    process.exit(1);\r\n  });\r\n}\r\n\r\n/**\r\n * Gracefully shutdown all connection pools\r\n */\r\nexport async function shutdownPools(): Promise<void> {\r\n  if (isShuttingDown) {\r\n    console.log('Shutdown already in progress');\r\n    return;\r\n  }\r\n\r\n  console.log('Initiating graceful connection pool shutdown...');\r\n  isShuttingDown = true;\r\n\r\n  const shutdownPromises: Promise<void>[] = [];\r\n\r\n  // Shutdown PostgreSQL pool\r\n  if (pgPool) {\r\n    shutdownPromises.push(\r\n      pgPool\r\n        .end()\r\n        .then(() => {\r\n          console.log('PostgreSQL connection pool closed');\r\n          pgPool = null;\r\n        })\r\n        .catch((err: Error) => {\r\n          console.error('Error closing PostgreSQL pool:', err.message);\r\n        })\r\n    );\r\n  }\r\n\r\n  // Shutdown Redis pool\r\n  if (redisPool) {\r\n    shutdownPromises.push(\r\n      redisPool\r\n        .quit()\r\n        .then(() => {\r\n          console.log('Redis connection pool closed');\r\n          redisPool = null;\r\n        })\r\n        .catch((err: Error) => {\r\n          console.error('Error closing Redis pool:', err.message);\r\n        })\r\n    );\r\n  }\r\n\r\n  await Promise.all(shutdownPromises);\r\n\r\n  isInitialized = false;\r\n  isShuttingDown = false;\r\n  console.log('Connection pool shutdown complete');\r\n}\r\n\r\n/**\r\n * Get pool metrics for Prometheus monitoring\r\n */\r\nexport function getPoolMetrics(): PoolMetrics {\r\n  if (!pgPool || !redisPool) {\r\n    throw new Error('Connection pools not initialized. Call initializePools first.');\r\n  }\r\n\r\n  return {\r\n    postgres: {\r\n      totalConnections: pgPool.totalCount,\r\n      idleConnections: pgPool.idleCount,\r\n      waitingRequests: pgPool.waitingCount,\r\n      activeConnections: pgPool.totalCount - pgPool.idleCount,\r\n    },\r\n    redis: {\r\n      status: redisPool.status,\r\n      connectedClients: 1, // Single connection per pool\r\n      commandsProcessed: redisCommandsProcessed,\r\n    },\r\n    timestamp: new Date().toISOString(),\r\n  };\r\n}\r\n\r\n/**\r\n * Execute PostgreSQL query with pooled connection\r\n * Automatically handles connection acquisition and release\r\n */\r\nexport async function executePostgresQuery<T = Record<string, unknown>>(\r\n  query: string,\r\n  params?: unknown[]\r\n): Promise<T[]> {\r\n  if (!pgPool) {\r\n    throw new Error('PostgreSQL pool not initialized. Call initializePools first.');\r\n  }\r\n\r\n  if (isShuttingDown) {\r\n    throw new Error('Connection pool is shutting down');\r\n  }\r\n\r\n  let client: PoolClient | null = null;\r\n  try {\r\n    client = await pgPool.connect();\r\n    const result = await client.query(query, params);\r\n    postgresCommandsProcessed++;\r\n    return result.rows as T[];\r\n  } catch (err) {\r\n    const error = err as Error;\r\n    console.error('PostgreSQL query error:', error.message);\r\n    throw new Error(`PostgreSQL query failed: ${error.message}`);\r\n  } finally {\r\n    if (client) {\r\n      client.release();\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Execute Redis command with pooled connection\r\n * Automatically handles reconnection on failure\r\n */\r\nexport async function executeRedisCommand<T = unknown>(\r\n  command: string,\r\n  ...args: unknown[]\r\n): Promise<T> {\r\n  if (!redisPool) {\r\n    throw new Error('Redis pool not initialized. Call initializePools first.');\r\n  }\r\n\r\n  if (isShuttingDown) {\r\n    throw new Error('Connection pool is shutting down');\r\n  }\r\n\r\n  try {\r\n    // Type-safe command execution using unknown cast\r\n    const redisClient = redisPool as unknown as Record<\r\n      string,\r\n      (...args: unknown[]) => Promise<T>\r\n    >;\r\n    const result = await redisClient[command](...args);\r\n    redisCommandsProcessed++;\r\n    return result;\r\n  } catch (err) {\r\n    const error = err as Error;\r\n    console.error(`Redis ${command} command error:`, error.message);\r\n    throw new Error(`Redis command failed: ${error.message}`);\r\n  }\r\n}\r\n\r\n/**\r\n * Health check for all connection pools\r\n */\r\nexport async function healthCheck(): Promise<HealthCheckResult> {\r\n  const health: HealthCheckResult = {\r\n    postgres: false,\r\n    redis: false,\r\n    details: {\r\n      postgres: 'not initialized',\r\n      redis: 'not initialized',\r\n    },\r\n  };\r\n\r\n  // Check PostgreSQL\r\n  if (pgPool) {\r\n    try {\r\n      await executePostgresQuery('SELECT 1 AS health_check');\r\n      health.postgres = true;\r\n      health.details.postgres = 'healthy';\r\n    } catch (err) {\r\n      const error = err as Error;\r\n      health.details.postgres = error.message;\r\n    }\r\n  }\r\n\r\n  // Check Redis\r\n  if (redisPool) {\r\n    try {\r\n      await redisPool.ping();\r\n      health.redis = true;\r\n      health.details.redis = 'healthy';\r\n    } catch (err) {\r\n      const error = err as Error;\r\n      health.details.redis = error.message;\r\n    }\r\n  }\r\n\r\n  return health;\r\n}\r\n\r\n/**\r\n * Get PostgreSQL pool instance (for advanced use cases)\r\n * Most code should use executePostgresQuery instead\r\n */\r\nexport function getPostgresPool(): Pool {\r\n  if (!pgPool) {\r\n    throw new Error('PostgreSQL pool not initialized. Call initializePools first.');\r\n  }\r\n  return pgPool;\r\n}\r\n\r\n/**\r\n * Get Redis pool instance (for advanced use cases)\r\n * Most code should use executeRedisCommand instead\r\n */\r\nexport function getRedisPool(): Redis {\r\n  if (!redisPool) {\r\n    throw new Error('Redis pool not initialized. Call initializePools first.');\r\n  }\r\n  return redisPool;\r\n}\r\n"],"names":["Pool","Redis","pgPool","redisPool","isInitialized","isShuttingDown","initializationPromise","postgresCommandsProcessed","redisCommandsProcessed","initializePools","config","console","log","validatePoolConfig","initializePostgresPool","postgres","initializeRedisPool","redis","registerShutdownHandlers","error","shutdownPools","max","Error","idleTimeoutMillis","connectionTimeoutMillis","maxRetriesPerRequest","poolConfig","host","port","database","user","password","allowExitOnIdle","application_name","on","err","client","message","connect","query","release","redisOptions","lazyConnect","keepAlive","connectTimeout","retryStrategy","times","undefined","delay","Math","min","pow","reconnectOnError","targetErrors","some","target","includes","enableReadyCheck","enableOfflineQueue","result","ping","shutdownHandler","signal","process","exit","reason","shutdownPromises","push","end","then","catch","quit","Promise","all","getPoolMetrics","totalConnections","totalCount","idleConnections","idleCount","waitingRequests","waitingCount","activeConnections","status","connectedClients","commandsProcessed","timestamp","Date","toISOString","executePostgresQuery","params","rows","executeRedisCommand","command","args","redisClient","healthCheck","health","details","getPostgresPool","getRedisPool"],"mappings":"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"}