@pipeline-builder/pipeline-data 0.0.1

package/lib/database/postgres-connection.js

@@ -0,0 +1,413 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger } from '@pipeline-builder/api-core';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { schema } from './drizzle-schema.js';
+import { ConnectionRetryStrategy } from './retry-strategy.js';
+const logger = 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;
+/**
+ * Resolve the pg TLS/SSL config from an explicit option or the environment,
+ * following the same env-tunable pattern as the pool sizing above.
+ *
+ * Precedence:
+ *   1. An explicit `options.ssl` (constructor arg) always wins — including an
+ *      explicit `false` to force plaintext.
+ *   2. `DB_SSL` (`true`/`1` on, `false`/`0` off) or Postgres' standard
+ *      `PGSSLMODE` (`disable` = off, any other mode = on).
+ *   3. Default: ON in production (RDS connections must be encrypted in transit),
+ *      OFF everywhere else so a local Postgres without TLS keeps working.
+ *
+ * When enabled, `rejectUnauthorized` follows `DB_SSL_REJECT_UNAUTHORIZED`
+ * (default `false`): AWS RDS presents a cert signed by the RDS CA, which is not
+ * in Node's default trust store unless the CA bundle is mounted, so certificate
+ * VERIFICATION is opt-in to avoid breaking a stock RDS deploy — the channel is
+ * still ENCRYPTED. Set `DB_SSL_REJECT_UNAUTHORIZED=true` once the RDS CA bundle
+ * is wired to get full verification.
+ */
+export function getSslConfig(explicit) {
+    if (explicit !== undefined)
+        return explicit;
+    const dbSsl = process.env.DB_SSL?.toLowerCase();
+    const sslMode = process.env.PGSSLMODE?.toLowerCase();
+    let enabled;
+    if (dbSsl === 'true' || dbSsl === '1')
+        enabled = true;
+    else if (dbSsl === 'false' || dbSsl === '0')
+        enabled = false;
+    else if (sslMode)
+        enabled = sslMode !== 'disable';
+    else
+        enabled = process.env.NODE_ENV === 'production';
+    if (!enabled)
+        return false;
+    return { rejectUnauthorized: process.env.DB_SSL_REJECT_UNAUTHORIZED === 'true' };
+}
+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();
+ * ```
+ */
+export 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),
+            // Env-driven TLS: on-by-default in production, env-enableable elsewhere.
+            // getInstance() is normally called with no options, so this is the only
+            // place production RDS connections pick up SSL (formerly hard-coded off).
+            ssl: getSslConfig(options.ssl),
+        };
+        // Initialize retry strategy
+        this.retryStrategy = new 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 Pool(poolConfig);
+            this.setupEventHandlers();
+            this.db = drizzle(this.pool, { 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();
+            // Release even if the probe query throws — otherwise a flaky DB (the exact
+            // case this check exists for) leaks a pooled client each failure and can
+            // exhaust the pool on the retry path.
+            try {
+                const result = await client.query('SELECT 1');
+                if (this.options.enableLogging) {
+                    logger.info('Database connection test successful');
+                }
+                return result.rows.length > 0;
+            }
+            finally {
+                client.release();
+            }
+        }
+        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,
+        };
+    }
+    /**
+     * 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',
+        });
+    }
+}
+/**
+ * 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);
+ * ```
+ */
+export const 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}`);
+ * ```
+ */
+export 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);
+ * });
+ * ```
+ */
+export 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);
+ * }
+ * ```
+ */
+export async function testConnection() {
+    const connection = Connection.getInstance();
+    return connection.testConnection();
+}
+//# 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 { drizzle } from 'drizzle-orm/node-postgres';\nimport { Pool, type PoolConfig } from 'pg';\nimport { schema } from './drizzle-schema.js';\nimport { ConnectionRetryStrategy } from './retry-strategy.js';\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\n/**\n * Resolve the pg TLS/SSL config from an explicit option or the environment,\n * following the same env-tunable pattern as the pool sizing above.\n *\n * Precedence:\n *   1. An explicit `options.ssl` (constructor arg) always wins — including an\n *      explicit `false` to force plaintext.\n *   2. `DB_SSL` (`true`/`1` on, `false`/`0` off) or Postgres' standard\n *      `PGSSLMODE` (`disable` = off, any other mode = on).\n *   3. Default: ON in production (RDS connections must be encrypted in transit),\n *      OFF everywhere else so a local Postgres without TLS keeps working.\n *\n * When enabled, `rejectUnauthorized` follows `DB_SSL_REJECT_UNAUTHORIZED`\n * (default `false`): AWS RDS presents a cert signed by the RDS CA, which is not\n * in Node's default trust store unless the CA bundle is mounted, so certificate\n * VERIFICATION is opt-in to avoid breaking a stock RDS deploy — the channel is\n * still ENCRYPTED. Set `DB_SSL_REJECT_UNAUTHORIZED=true` once the RDS CA bundle\n * is wired to get full verification.\n */\nexport function getSslConfig(explicit?: ConnectionOptions['ssl']): boolean | { rejectUnauthorized: boolean } {\n  if (explicit !== undefined) return explicit;\n\n  const dbSsl = process.env.DB_SSL?.toLowerCase();\n  const sslMode = process.env.PGSSLMODE?.toLowerCase();\n\n  let enabled: boolean;\n  if (dbSsl === 'true' || dbSsl === '1') enabled = true;\n  else if (dbSsl === 'false' || dbSsl === '0') enabled = false;\n  else if (sslMode) enabled = sslMode !== 'disable';\n  else enabled = process.env.NODE_ENV === 'production';\n\n  if (!enabled) return false;\n  return { rejectUnauthorized: process.env.DB_SSL_REJECT_UNAUTHORIZED === 'true' };\n}\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      // Env-driven TLS: on-by-default in production, env-enableable elsewhere.\n      // getInstance() is normally called with no options, so this is the only\n      // place production RDS connections pick up SSL (formerly hard-coded off).\n      ssl: getSslConfig(options.ssl),\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      // Release even if the probe query throws — otherwise a flaky DB (the exact\n      // case this check exists for) leaks a pooled client each failure and can\n      // exhaust the pool on the retry path.\n      try {\n        const result = await client.query('SELECT 1');\n        if (this.options.enableLogging) {\n          logger.info('Database connection test successful');\n        }\n        return result.rows.length > 0;\n      } finally {\n        client.release();\n      }\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   * 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"]}

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;
+}