@pipeline-builder/pipeline-data 3.1.0

package/lib/database/postgres-connection.js

@@ -0,0 +1,456 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = exports.Connection = void 0;
+exports.getConnection = getConnection;
+exports.closeConnection = closeConnection;
+exports.testConnection = testConnection;
+exports.initializeDatabase = initializeDatabase;
+const api_core_1 = require("@pipeline-builder/api-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const node_postgres_1 = require("drizzle-orm/node-postgres");
+const pg_1 = require("pg");
+const drizzle_schema_1 = require("./drizzle-schema");
+const retry_strategy_1 = require("./retry-strategy");
+const logger = (0, api_core_1.createLogger)('Database');
+/**
+ * Get database configuration from environment variables
+ * Note: Uses environment variables directly to avoid circular dependency with pipeline-core
+ */
+function parseIntEnv(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = parseInt(value, 10);
+    return Number.isNaN(parsed) ? fallback : parsed;
+}
+/** Detect Lambda environment for pool-size tuning */
+const isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;
+function getDatabaseConfig() {
+    // Lambda: small pool (each invocation is short-lived, many concurrent instances)
+    // ECS/long-running: larger pool for sustained concurrency
+    const defaultPoolSize = isLambda ? 2 : 20;
+    const defaultIdleTimeout = isLambda ? 10000 : 30000;
+    return {
+        host: process.env.DB_HOST || 'postgres',
+        port: parseIntEnv(process.env.DB_PORT, 5432),
+        database: process.env.DATABASE || 'pipeline_builder',
+        user: process.env.DB_USER || 'postgres',
+        password: process.env.DB_PASSWORD || (process.env.NODE_ENV === 'production' ? (() => { throw new Error('DB_PASSWORD is required in production'); })() : ''),
+        maxPoolSize: parseIntEnv(process.env.DRIZZLE_MAX_POOL_SIZE, defaultPoolSize),
+        idleTimeoutMillis: parseIntEnv(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS, defaultIdleTimeout),
+        connectionTimeoutMillis: parseIntEnv(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS, 5000),
+    };
+}
+/**
+ * Singleton database connection class.
+ * Manages PostgreSQL connection pooling and Drizzle ORM instance.
+ *
+ * Features:
+ * - Singleton pattern for single connection pool
+ * - Automatic connection retry with backoff
+ * - Connection health monitoring
+ * - Graceful shutdown handling
+ * - Comprehensive error handling
+ * - Connection statistics tracking
+ *
+ * @example
+ * ```typescript
+ * import { Connection } from './connection';
+ *
+ * const connection = Connection.getInstance();
+ * const plugins = await connection.db.select().from(schema.plugin);
+ *
+ * // During shutdown
+ * await connection.close();
+ * ```
+ */
+class Connection {
+    static instance = null;
+    /**
+     * Drizzle ORM database instance with schema
+     */
+    db;
+    pool;
+    options;
+    retryStrategy;
+    isShuttingDown = false;
+    /**
+     * Private constructor to enforce singleton pattern.
+     * Initializes PostgreSQL connection pool and Drizzle ORM instance.
+     *
+     * @param options - Optional configuration for the connection
+     * @throws {Error} If database initialization fails after all retries
+     */
+    constructor(options = {}) {
+        this.options = {
+            enableLogging: options.enableLogging ?? true,
+            enableAutoRetry: options.enableAutoRetry ?? true,
+            maxRetries: options.maxRetries ?? parseInt(process.env.DB_MAX_RETRIES || '3', 10),
+            retryDelay: options.retryDelay ?? parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10),
+            ssl: options.ssl ?? false,
+        };
+        // Initialize retry strategy
+        this.retryStrategy = new retry_strategy_1.ConnectionRetryStrategy({
+            maxRetries: this.options.maxRetries,
+            baseDelay: this.options.retryDelay,
+        });
+        try {
+            const config = getDatabaseConfig();
+            const poolConfig = {
+                host: config.host,
+                port: config.port,
+                database: config.database,
+                user: config.user,
+                password: config.password,
+                max: config.maxPoolSize,
+                idleTimeoutMillis: config.idleTimeoutMillis,
+                connectionTimeoutMillis: config.connectionTimeoutMillis,
+                ssl: this.options.ssl,
+                allowExitOnIdle: true,
+            };
+            this.pool = new pg_1.Pool(poolConfig);
+            this.setupEventHandlers();
+            this.db = (0, node_postgres_1.drizzle)(this.pool, { schema: drizzle_schema_1.schema });
+            if (this.options.enableLogging) {
+                logger.info('Database connection initialized successfully');
+                this.logConnectionConfig(poolConfig);
+            }
+        }
+        catch (error) {
+            logger.error('Failed to initialize database connection:', error);
+            throw new Error('Database initialization failed');
+        }
+    }
+    /**
+     * Gets the singleton instance of the Connection class.
+     * Creates a new instance if one doesn't exist.
+     *
+     * @param options - Optional configuration (only used on first call)
+     * @returns The singleton Connection instance
+     */
+    static getInstance(options) {
+        if (!Connection.instance) {
+            Connection.instance = new Connection(options);
+        }
+        return Connection.instance;
+    }
+    /**
+     * Resets the singleton instance.
+     * Useful for testing or reconfiguring the connection.
+     *
+     * @param closeExisting - Whether to close existing connection before reset
+     */
+    static async reset(closeExisting = true) {
+        if (Connection.instance && closeExisting) {
+            await Connection.instance.close();
+        }
+        Connection.instance = null;
+    }
+    /**
+     * Tests the database connection
+     *
+     * @returns Promise that resolves to true if connection is healthy
+     */
+    async testConnection() {
+        try {
+            const client = await this.pool.connect();
+            const result = await client.query('SELECT 1');
+            client.release();
+            if (this.options.enableLogging) {
+                logger.info('Database connection test successful');
+            }
+            return result.rows.length > 0;
+        }
+        catch (error) {
+            logger.error('Database connection test failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Gets connection pool statistics
+     *
+     * @returns Current connection pool statistics
+     */
+    getStats() {
+        return {
+            totalCount: this.pool.totalCount,
+            idleCount: this.pool.idleCount,
+            waitingCount: this.pool.waitingCount,
+        };
+    }
+    /**
+     * Executes a database transaction
+     *
+     * @param callback - Function to execute within the transaction
+     * @returns Result of the transaction
+     *
+     * @example
+     * ```typescript
+     * const result = await connection.transaction(async (tx) => {
+     *   await tx.insert(schema.plugin).values({ ... });
+     *   await tx.insert(schema.metadata).values({ ... });
+     *   return { success: true };
+     * });
+     * ```
+     */
+    async transaction(callback, timeoutMs = parseIntEnv(process.env.DB_TRANSACTION_TIMEOUT_MS, 30000)) {
+        let timer;
+        // Wrap callback to set PostgreSQL statement_timeout as a server-side guard.
+        // The Promise.race timeout below handles the JS side, but statement_timeout
+        // ensures the DB itself cancels long-running queries if the JS timeout fires
+        // but the connection isn't cleaned up.
+        const wrappedCallback = async (tx) => {
+            await tx.execute((0, drizzle_orm_1.sql) `SET LOCAL statement_timeout = ${String(timeoutMs)}`);
+            return callback(tx);
+        };
+        const txPromise = this.db.transaction(wrappedCallback);
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`Transaction timeout after ${timeoutMs}ms`)), timeoutMs);
+        });
+        try {
+            return await Promise.race([txPromise, timeoutPromise]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Acquires a client from the pool for manual query execution
+     * Remember to release the client when done
+     *
+     * @returns PostgreSQL client from the pool
+     *
+     * @example
+     * ```typescript
+     * const client = await connection.getClient();
+     * try {
+     *   await client.query('BEGIN');
+     *   await client.query('INSERT INTO ...');
+     *   await client.query('COMMIT');
+     * } finally {
+     *   client.release();
+     * }
+     * ```
+     */
+    async getClient() {
+        return this.pool.connect();
+    }
+    /**
+     * Closes the database connection pool gracefully.
+     * Should be called during application shutdown.
+     *
+     * @param timeout - Maximum time to wait for connections to close (ms)
+     * @returns Promise that resolves when pool is closed
+     */
+    async close(timeout = parseIntEnv(process.env.DB_CLOSE_TIMEOUT_MS, 5000)) {
+        if (this.isShuttingDown) {
+            logger.warn('Connection is already shutting down');
+            return;
+        }
+        this.isShuttingDown = true;
+        try {
+            if (this.options.enableLogging) {
+                logger.info('Closing database connection pool...');
+                const stats = this.getStats();
+                logger.info(`Pool stats - Total: ${stats.totalCount}, Idle: ${stats.idleCount}, Waiting: ${stats.waitingCount}`);
+            }
+            // Set a timeout for graceful shutdown
+            const closePromise = this.pool.end();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Connection close timeout')), timeout));
+            await Promise.race([closePromise, timeoutPromise]);
+            if (this.options.enableLogging) {
+                logger.info('Database connection closed successfully');
+            }
+        }
+        catch (error) {
+            logger.error('Error closing database connection:', error);
+            throw error;
+        }
+        finally {
+            this.isShuttingDown = false;
+        }
+    }
+    /**
+     * Checks if the connection is shutting down
+     *
+     * @returns true if connection is in shutdown state
+     */
+    isClosing() {
+        return this.isShuttingDown;
+    }
+    /**
+     * Sets up event handlers for the connection pool
+     */
+    setupEventHandlers() {
+        this.pool.on('error', (err) => {
+            logger.error('Unexpected error on idle client:', err);
+            if (this.options.enableAutoRetry && this.retryStrategy.getAttempts() < this.options.maxRetries) {
+                void this.retryStrategy.handleConnectionError(err, () => this.testConnection()).catch((retryErr) => {
+                    logger.error('Connection retry error:', retryErr);
+                });
+            }
+        });
+        this.pool.on('connect', () => {
+            this.retryStrategy.reset(); // Reset on successful connection
+            if (this.options.enableLogging) {
+                logger.debug('New database connection established');
+            }
+        });
+        this.pool.on('remove', () => {
+            if (this.options.enableLogging) {
+                logger.debug('Client removed from pool');
+            }
+        });
+    }
+    /**
+     * Logs connection configuration (sanitized)
+     */
+    logConnectionConfig(config) {
+        logger.info('Database Configuration:', {
+            host: `${config.host}:${config.port}`,
+            database: config.database,
+            user: config.user,
+            maxPoolSize: config.max,
+            idleTimeoutMs: config.idleTimeoutMillis,
+            connectionTimeoutMs: config.connectionTimeoutMillis,
+            ssl: config.ssl ? 'enabled' : 'disabled',
+        });
+    }
+}
+exports.Connection = Connection;
+/**
+ * Singleton database instance for use throughout the application.
+ *
+ * @example
+ * ```typescript
+ * import { db } from './connection';
+ *
+ * // Select queries
+ * const plugins = await db.select().from(schema.plugin);
+ *
+ * // Insert queries
+ * await db.insert(schema.plugin).values({ name: 'my-plugin' });
+ *
+ * // Transactions
+ * await db.transaction(async (tx) => {
+ *   await tx.insert(schema.plugin).values({ ... });
+ *   await tx.update(schema.plugin).set({ ... });
+ * });
+ * ```
+ */
+// Lazy initialization to avoid race condition on module load
+let _dbInstance = null;
+/**
+ * Get the database instance with lazy initialization
+ * This avoids the race condition where the module is loaded before environment is configured
+ */
+function getDbInstance() {
+    if (!_dbInstance) {
+        _dbInstance = Connection.getInstance().db;
+    }
+    return _dbInstance;
+}
+/**
+ * Proxy-based lazy database instance
+ * The actual connection is only created when first accessed
+ *
+ * @example
+ * ```typescript
+ * import { db } from './connection';
+ *
+ * // Connection is created here on first use, not on import
+ * const plugins = await db.select().from(schema.plugin);
+ * ```
+ */
+exports.db = new Proxy({}, {
+    get(_, prop) {
+        const instance = getDbInstance();
+        const value = instance[prop];
+        // Bind methods to the instance to preserve 'this' context
+        if (typeof value === 'function') {
+            return value.bind(instance);
+        }
+        return value;
+    },
+});
+/**
+ * Gets the Connection instance for advanced operations
+ *
+ * @example
+ * ```typescript
+ * import { getConnection } from './connection';
+ *
+ * const connection = getConnection();
+ * const stats = connection.getStats();
+ * console.log(`Active connections: ${stats.totalCount}`);
+ * ```
+ */
+function getConnection() {
+    return Connection.getInstance();
+}
+/**
+ * Closes the database connection
+ * Should be called during application shutdown
+ *
+ * @example
+ * ```typescript
+ * import { closeConnection } from './connection';
+ *
+ * process.on('SIGTERM', async () => {
+ *   await closeConnection();
+ *   process.exit(0);
+ * });
+ * ```
+ */
+async function closeConnection() {
+    const connection = Connection.getInstance();
+    await connection.close();
+    _dbInstance = null; // Reset lazy instance
+}
+/**
+ * Tests the database connection
+ *
+ * @returns Promise that resolves to true if connection is healthy
+ *
+ * @example
+ * ```typescript
+ * import { testConnection } from './connection';
+ *
+ * if (await testConnection()) {
+ *   console.log('Database is ready');
+ * } else {
+ *   console.error('Database connection failed');
+ *   process.exit(1);
+ * }
+ * ```
+ */
+async function testConnection() {
+    const connection = Connection.getInstance();
+    return connection.testConnection();
+}
+/**
+ * Initialize the database connection explicitly
+ * Call this during application startup after environment is configured
+ *
+ * @example
+ * ```typescript
+ * import { initializeDatabase } from './connection';
+ *
+ * async function bootstrap() {
+ *   // Load environment variables first
+ *   dotenv.config();
+ *
+ *   // Then initialize database
+ *   await initializeDatabase();
+ * }
+ * ```
+ */
+async function initializeDatabase() {
+    const connection = Connection.getInstance();
+    const healthy = await connection.testConnection();
+    if (!healthy) {
+        throw new Error('Database connection failed during initialization');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postgres-connection.js","sourceRoot":"","sources":["../../src/database/postgres-connection.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { Pool, PoolConfig, PoolClient } from 'pg';\nimport { schema } from './drizzle-schema';\nimport { ConnectionRetryStrategy } from './retry-strategy';\n\nconst logger = createLogger('Database');\n\n/**\n * Get database configuration from environment variables\n * Note: Uses environment variables directly to avoid circular dependency with pipeline-core\n */\nfunction parseIntEnv(value: string | undefined, fallback: number): number {\n  if (!value) return fallback;\n  const parsed = parseInt(value, 10);\n  return Number.isNaN(parsed) ? fallback : parsed;\n}\n\n/** Detect Lambda environment for pool-size tuning */\nconst isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;\n\nfunction getDatabaseConfig() {\n  // Lambda: small pool (each invocation is short-lived, many concurrent instances)\n  // ECS/long-running: larger pool for sustained concurrency\n  const defaultPoolSize = isLambda ? 2 : 20;\n  const defaultIdleTimeout = isLambda ? 10000 : 30000;\n\n  return {\n    host: process.env.DB_HOST || 'postgres',\n    port: parseIntEnv(process.env.DB_PORT, 5432),\n    database: process.env.DATABASE || 'pipeline_builder',\n    user: process.env.DB_USER || 'postgres',\n    password: process.env.DB_PASSWORD || (process.env.NODE_ENV === 'production' ? (() => { throw new Error('DB_PASSWORD is required in production'); })() as string : ''),\n    maxPoolSize: parseIntEnv(process.env.DRIZZLE_MAX_POOL_SIZE, defaultPoolSize),\n    idleTimeoutMillis: parseIntEnv(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS, defaultIdleTimeout),\n    connectionTimeoutMillis: parseIntEnv(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS, 5000),\n  };\n}\n\n/**\n * Database connection statistics for monitoring\n */\nexport interface ConnectionStats {\n  totalCount: number;\n  idleCount: number;\n  waitingCount: number;\n}\n\n/**\n * Options for configuring the database connection\n */\nexport interface ConnectionOptions {\n  /** Whether to enable connection logging */\n  enableLogging?: boolean;\n\n  /** Whether to automatically retry failed connections */\n  enableAutoRetry?: boolean;\n\n  /** Maximum number of connection retry attempts */\n  maxRetries?: number;\n\n  /** Delay between retry attempts in milliseconds */\n  retryDelay?: number;\n\n  /** SSL configuration */\n  ssl?: boolean | { rejectUnauthorized: boolean };\n}\n\n/**\n * Singleton database connection class.\n * Manages PostgreSQL connection pooling and Drizzle ORM instance.\n *\n * Features:\n * - Singleton pattern for single connection pool\n * - Automatic connection retry with backoff\n * - Connection health monitoring\n * - Graceful shutdown handling\n * - Comprehensive error handling\n * - Connection statistics tracking\n *\n * @example\n * ```typescript\n * import { Connection } from './connection';\n *\n * const connection = Connection.getInstance();\n * const plugins = await connection.db.select().from(schema.plugin);\n *\n * // During shutdown\n * await connection.close();\n * ```\n */\nexport class Connection {\n  private static instance: Connection | null = null;\n\n  /**\n   * Drizzle ORM database instance with schema\n   */\n  public readonly db: ReturnType<typeof drizzle>;\n\n  private readonly pool: Pool;\n  private readonly options: Required<ConnectionOptions>;\n  private readonly retryStrategy: ConnectionRetryStrategy;\n  private isShuttingDown = false;\n\n  /**\n   * Private constructor to enforce singleton pattern.\n   * Initializes PostgreSQL connection pool and Drizzle ORM instance.\n   *\n   * @param options - Optional configuration for the connection\n   * @throws {Error} If database initialization fails after all retries\n   */\n  private constructor(options: ConnectionOptions = {}) {\n    this.options = {\n      enableLogging: options.enableLogging ?? true,\n      enableAutoRetry: options.enableAutoRetry ?? true,\n      maxRetries: options.maxRetries ?? parseInt(process.env.DB_MAX_RETRIES || '3', 10),\n      retryDelay: options.retryDelay ?? parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10),\n      ssl: options.ssl ?? false,\n    };\n\n    // Initialize retry strategy\n    this.retryStrategy = new ConnectionRetryStrategy({\n      maxRetries: this.options.maxRetries,\n      baseDelay: this.options.retryDelay,\n    });\n\n    try {\n      const config = getDatabaseConfig();\n\n      const poolConfig: PoolConfig = {\n        host: config.host,\n        port: config.port,\n        database: config.database,\n        user: config.user,\n        password: config.password,\n        max: config.maxPoolSize,\n        idleTimeoutMillis: config.idleTimeoutMillis,\n        connectionTimeoutMillis: config.connectionTimeoutMillis,\n        ssl: this.options.ssl,\n        allowExitOnIdle: true,\n      };\n\n      this.pool = new Pool(poolConfig);\n      this.setupEventHandlers();\n\n      this.db = drizzle(this.pool, { schema });\n\n      if (this.options.enableLogging) {\n        logger.info('Database connection initialized successfully');\n        this.logConnectionConfig(poolConfig);\n      }\n    } catch (error) {\n      logger.error('Failed to initialize database connection:', error);\n      throw new Error('Database initialization failed');\n    }\n  }\n\n  /**\n   * Gets the singleton instance of the Connection class.\n   * Creates a new instance if one doesn't exist.\n   *\n   * @param options - Optional configuration (only used on first call)\n   * @returns The singleton Connection instance\n   */\n  public static getInstance(options?: ConnectionOptions): Connection {\n    if (!Connection.instance) {\n      Connection.instance = new Connection(options);\n    }\n    return Connection.instance;\n  }\n\n  /**\n   * Resets the singleton instance.\n   * Useful for testing or reconfiguring the connection.\n   *\n   * @param closeExisting - Whether to close existing connection before reset\n   */\n  public static async reset(closeExisting: boolean = true): Promise<void> {\n    if (Connection.instance && closeExisting) {\n      await Connection.instance.close();\n    }\n    Connection.instance = null;\n  }\n\n  /**\n   * Tests the database connection\n   *\n   * @returns Promise that resolves to true if connection is healthy\n   */\n  public async testConnection(): Promise<boolean> {\n    try {\n      const client = await this.pool.connect();\n      const result = await client.query('SELECT 1');\n      client.release();\n\n      if (this.options.enableLogging) {\n        logger.info('Database connection test successful');\n      }\n\n      return result.rows.length > 0;\n    } catch (error) {\n      logger.error('Database connection test failed:', error);\n      return false;\n    }\n  }\n\n  /**\n   * Gets connection pool statistics\n   *\n   * @returns Current connection pool statistics\n   */\n  public getStats(): ConnectionStats {\n    return {\n      totalCount: this.pool.totalCount,\n      idleCount: this.pool.idleCount,\n      waitingCount: this.pool.waitingCount,\n    };\n  }\n\n  /**\n   * Executes a database transaction\n   *\n   * @param callback - Function to execute within the transaction\n   * @returns Result of the transaction\n   *\n   * @example\n   * ```typescript\n   * const result = await connection.transaction(async (tx) => {\n   *   await tx.insert(schema.plugin).values({ ... });\n   *   await tx.insert(schema.metadata).values({ ... });\n   *   return { success: true };\n   * });\n   * ```\n   */\n  public async transaction<T>(\n    callback: Parameters<typeof this.db.transaction>[0],\n    timeoutMs: number = parseIntEnv(process.env.DB_TRANSACTION_TIMEOUT_MS, 30000),\n  ): Promise<T> {\n    let timer: ReturnType<typeof setTimeout>;\n    // Wrap callback to set PostgreSQL statement_timeout as a server-side guard.\n    // The Promise.race timeout below handles the JS side, but statement_timeout\n    // ensures the DB itself cancels long-running queries if the JS timeout fires\n    // but the connection isn't cleaned up.\n    const wrappedCallback: typeof callback = async (tx) => {\n      await tx.execute(sql`SET LOCAL statement_timeout = ${String(timeoutMs)}`);\n      return callback(tx);\n    };\n    const txPromise = this.db.transaction(wrappedCallback) as Promise<T>;\n    const timeoutPromise = new Promise<never>((_, reject) => {\n      timer = setTimeout(() => reject(new Error(`Transaction timeout after ${timeoutMs}ms`)), timeoutMs);\n    });\n    try {\n      return await Promise.race([txPromise, timeoutPromise]);\n    } finally {\n      clearTimeout(timer!);\n    }\n  }\n\n  /**\n   * Acquires a client from the pool for manual query execution\n   * Remember to release the client when done\n   *\n   * @returns PostgreSQL client from the pool\n   *\n   * @example\n   * ```typescript\n   * const client = await connection.getClient();\n   * try {\n   *   await client.query('BEGIN');\n   *   await client.query('INSERT INTO ...');\n   *   await client.query('COMMIT');\n   * } finally {\n   *   client.release();\n   * }\n   * ```\n   */\n  public async getClient(): Promise<PoolClient> {\n    return this.pool.connect();\n  }\n\n  /**\n   * Closes the database connection pool gracefully.\n   * Should be called during application shutdown.\n   *\n   * @param timeout - Maximum time to wait for connections to close (ms)\n   * @returns Promise that resolves when pool is closed\n   */\n  public async close(timeout: number = parseIntEnv(process.env.DB_CLOSE_TIMEOUT_MS, 5000)): Promise<void> {\n    if (this.isShuttingDown) {\n      logger.warn('Connection is already shutting down');\n      return;\n    }\n\n    this.isShuttingDown = true;\n\n    try {\n      if (this.options.enableLogging) {\n        logger.info('Closing database connection pool...');\n        const stats = this.getStats();\n        logger.info(`Pool stats - Total: ${stats.totalCount}, Idle: ${stats.idleCount}, Waiting: ${stats.waitingCount}`);\n      }\n\n      // Set a timeout for graceful shutdown\n      const closePromise = this.pool.end();\n      const timeoutPromise = new Promise((_, reject) =>\n        setTimeout(() => reject(new Error('Connection close timeout')), timeout),\n      );\n\n      await Promise.race([closePromise, timeoutPromise]);\n\n      if (this.options.enableLogging) {\n        logger.info('Database connection closed successfully');\n      }\n    } catch (error) {\n      logger.error('Error closing database connection:', error);\n      throw error;\n    } finally {\n      this.isShuttingDown = false;\n    }\n  }\n\n  /**\n   * Checks if the connection is shutting down\n   *\n   * @returns true if connection is in shutdown state\n   */\n  public isClosing(): boolean {\n    return this.isShuttingDown;\n  }\n\n  /**\n   * Sets up event handlers for the connection pool\n   */\n  private setupEventHandlers(): void {\n    this.pool.on('error', (err) => {\n      logger.error('Unexpected error on idle client:', err);\n\n      if (this.options.enableAutoRetry && this.retryStrategy.getAttempts() < this.options.maxRetries) {\n        void this.retryStrategy.handleConnectionError(err, () => this.testConnection()).catch((retryErr) => {\n          logger.error('Connection retry error:', retryErr);\n        });\n      }\n    });\n\n    this.pool.on('connect', () => {\n      this.retryStrategy.reset(); // Reset on successful connection\n\n      if (this.options.enableLogging) {\n        logger.debug('New database connection established');\n      }\n    });\n\n    this.pool.on('remove', () => {\n      if (this.options.enableLogging) {\n        logger.debug('Client removed from pool');\n      }\n    });\n  }\n\n  /**\n   * Logs connection configuration (sanitized)\n   */\n  private logConnectionConfig(config: PoolConfig): void {\n    logger.info('Database Configuration:', {\n      host: `${config.host}:${config.port}`,\n      database: config.database,\n      user: config.user,\n      maxPoolSize: config.max,\n      idleTimeoutMs: config.idleTimeoutMillis,\n      connectionTimeoutMs: config.connectionTimeoutMillis,\n      ssl: config.ssl ? 'enabled' : 'disabled',\n    });\n  }\n}\n\n/**\n * Singleton database instance for use throughout the application.\n *\n * @example\n * ```typescript\n * import { db } from './connection';\n *\n * // Select queries\n * const plugins = await db.select().from(schema.plugin);\n *\n * // Insert queries\n * await db.insert(schema.plugin).values({ name: 'my-plugin' });\n *\n * // Transactions\n * await db.transaction(async (tx) => {\n *   await tx.insert(schema.plugin).values({ ... });\n *   await tx.update(schema.plugin).set({ ... });\n * });\n * ```\n */\n\n// Lazy initialization to avoid race condition on module load\nlet _dbInstance: ReturnType<typeof drizzle> | null = null;\n\n/**\n * Get the database instance with lazy initialization\n * This avoids the race condition where the module is loaded before environment is configured\n */\nfunction getDbInstance(): ReturnType<typeof drizzle> {\n  if (!_dbInstance) {\n    _dbInstance = Connection.getInstance().db;\n  }\n  return _dbInstance;\n}\n\n/**\n * Proxy-based lazy database instance\n * The actual connection is only created when first accessed\n *\n * @example\n * ```typescript\n * import { db } from './connection';\n *\n * // Connection is created here on first use, not on import\n * const plugins = await db.select().from(schema.plugin);\n * ```\n */\nexport const db = new Proxy({} as ReturnType<typeof drizzle>, {\n  get(_, prop: string | symbol) {\n    const instance = getDbInstance();\n    const value = instance[prop as keyof typeof instance];\n    // Bind methods to the instance to preserve 'this' context\n    if (typeof value === 'function') {\n      return value.bind(instance);\n    }\n    return value;\n  },\n});\n\n/**\n * Gets the Connection instance for advanced operations\n *\n * @example\n * ```typescript\n * import { getConnection } from './connection';\n *\n * const connection = getConnection();\n * const stats = connection.getStats();\n * console.log(`Active connections: ${stats.totalCount}`);\n * ```\n */\nexport function getConnection(): Connection {\n  return Connection.getInstance();\n}\n\n/**\n * Closes the database connection\n * Should be called during application shutdown\n *\n * @example\n * ```typescript\n * import { closeConnection } from './connection';\n *\n * process.on('SIGTERM', async () => {\n *   await closeConnection();\n *   process.exit(0);\n * });\n * ```\n */\nexport async function closeConnection(): Promise<void> {\n  const connection = Connection.getInstance();\n  await connection.close();\n  _dbInstance = null; // Reset lazy instance\n}\n\n/**\n * Tests the database connection\n *\n * @returns Promise that resolves to true if connection is healthy\n *\n * @example\n * ```typescript\n * import { testConnection } from './connection';\n *\n * if (await testConnection()) {\n *   console.log('Database is ready');\n * } else {\n *   console.error('Database connection failed');\n *   process.exit(1);\n * }\n * ```\n */\nexport async function testConnection(): Promise<boolean> {\n  const connection = Connection.getInstance();\n  return connection.testConnection();\n}\n\n/**\n * Initialize the database connection explicitly\n * Call this during application startup after environment is configured\n *\n * @example\n * ```typescript\n * import { initializeDatabase } from './connection';\n *\n * async function bootstrap() {\n *   // Load environment variables first\n *   dotenv.config();\n *\n *   // Then initialize database\n *   await initializeDatabase();\n * }\n * ```\n */\nexport async function initializeDatabase(): Promise<void> {\n  const connection = Connection.getInstance();\n  const healthy = await connection.testConnection();\n  if (!healthy) {\n    throw new Error('Database connection failed during initialization');\n  }\n}"]}

package/lib/database/retry-strategy.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Configuration for connection retry strategy
+ */
+export interface RetryConfig {
+    /** Maximum number of retry attempts */
+    maxRetries: number;
+    /** Base delay between retries in milliseconds */
+    baseDelay: number;
+}
+/**
+ * Implements exponential backoff retry strategy for database connections.
+ *
+ * Features:
+ * - Exponential backoff with configurable base delay
+ * - Attempt tracking and logging
+ * - Graceful failure after max retries
+ *
+ * @example
+ * ```typescript
+ * const strategy = new ConnectionRetryStrategy({ maxRetries: 3, baseDelay: 1000 });
+ *
+ * const result = await strategy.execute(async () => {
+ *   return await db.query('SELECT 1');
+ * });
+ * ```
+ */
+export declare class ConnectionRetryStrategy {
+    private readonly config;
+    private attempts;
+    constructor(config: RetryConfig);
+    /**
+     * Executes an operation with retry logic
+     *
+     * @param operation - Async function to execute with retries
+     * @returns Promise resolving to operation result
+     * @throws Error if all retry attempts fail
+     */
+    execute<T>(operation: () => Promise<T>): Promise<T>;
+    /**
+     * Handles connection errors with retry tracking
+     *
+     * @param error - Error that occurred
+     * @param testConnection - Function to test if connection is restored
+     */
+    handleConnectionError(error: Error, testConnection: () => Promise<boolean>): Promise<void>;
+    /**
+     * Resets the attempt counter
+     * Call this after a successful operation
+     */
+    reset(): void;
+    /**
+     * Gets the current attempt count
+     */
+    getAttempts(): number;
+    /**
+     * Calculates exponential backoff delay
+     *
+     * @param attempt - Current attempt number (1-indexed)
+     * @returns Delay in milliseconds
+     */
+    private calculateBackoff;
+    /**
+     * Sleeps for the specified duration
+     *
+     * @param ms - Milliseconds to sleep
+     */
+    private sleep;
+}