@pipeline-builder/pipeline-data 4.1.46 → 4.1.47

package/lib/database/postgres-connection.js

@@ -378,6 +378,13 @@ export async function closeConnection() {
     const connection = Connection.getInstance();
     await connection.close();
     _dbInstance = null; // Reset lazy instance
+    // Close the read-replica pool too. A half-closed process keeps server
+    // connections open on the standby and its replication slot busy, which on the
+    // primary means retained WAL — the failure mode that fills the data volume.
+    // Imported lazily so this module does not depend on the read connection at
+    // load time (it has no replica on most deploys).
+    const { closeReadConnection } = await import('./read-connection.js');
+    await closeReadConnection();
 }
 /**
  * Tests the database connection
@@ -400,4 +407,4 @@ 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, envBool, envInt, envStr } 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/** 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: envBool('DB_SSL_REJECT_UNAUTHORIZED', false) };\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: envStr('DB_HOST', 'postgres'),\n    port: envInt('DB_PORT', 5432),\n    database: envStr('DATABASE', 'pipeline_builder'),\n    user: envStr('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: envInt('DRIZZLE_MAX_POOL_SIZE', defaultPoolSize),\n    idleTimeoutMillis: envInt('DRIZZLE_IDLE_TIMEOUT_MILLIS', defaultIdleTimeout),\n    connectionTimeoutMillis: envInt('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 ?? envInt('DB_MAX_RETRIES', 3, { min: 0 }),\n      retryDelay: options.retryDelay ?? envInt('DB_RETRY_DELAY_MS', 1000, { min: 0 }),\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.\n      ssl: getSslConfig(options.ssl),\n    };\n\n    // Initialize retry strategy\n    this.retryStrategy = new ConnectionRetryStrategy({\n      maxRetries: this.options.maxRetries,\n      retryDelayMs: 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 = envInt('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"]}
+//# 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, envBool, envInt, envStr } 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/** 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: envBool('DB_SSL_REJECT_UNAUTHORIZED', false) };\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: envStr('DB_HOST', 'postgres'),\n    port: envInt('DB_PORT', 5432),\n    database: envStr('DATABASE', 'pipeline_builder'),\n    user: envStr('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: envInt('DRIZZLE_MAX_POOL_SIZE', defaultPoolSize),\n    idleTimeoutMillis: envInt('DRIZZLE_IDLE_TIMEOUT_MILLIS', defaultIdleTimeout),\n    connectionTimeoutMillis: envInt('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 ?? envInt('DB_MAX_RETRIES', 3, { min: 0 }),\n      retryDelay: options.retryDelay ?? envInt('DB_RETRY_DELAY_MS', 1000, { min: 0 }),\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.\n      ssl: getSslConfig(options.ssl),\n    };\n\n    // Initialize retry strategy\n    this.retryStrategy = new ConnectionRetryStrategy({\n      maxRetries: this.options.maxRetries,\n      retryDelayMs: 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 = envInt('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  // Close the read-replica pool too. A half-closed process keeps server\n  // connections open on the standby and its replication slot busy, which on the\n  // primary means retained WAL — the failure mode that fills the data volume.\n  // Imported lazily so this module does not depend on the read connection at\n  // load time (it has no replica on most deploys).\n  const { closeReadConnection } = await import('./read-connection.js');\n  await closeReadConnection();\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/read-connection.d.ts

@@ -0,0 +1,19 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+/**
+ * The replica pool, or null when no replica is configured.
+ *
+ * Lazily created so importing this module costs nothing on a deploy that has no
+ * replica — which, until Phase 1 lands, is all of them.
+ */
+export declare function getReadPool(): Pool | null;
+/** The replica's drizzle instance, or null when no replica is configured. */
+export declare function getReadDb(): ReturnType<typeof drizzle> | null;
+/**
+ * Close the replica pool. Called from `closeConnection()` so a shutdown closes
+ * BOTH pools — a half-closed process holds server connections open on the
+ * standby and keeps its replication slot busy.
+ */
+export declare function closeReadConnection(): Promise<void>;
+/** Test seam: forget the memoized pool without closing it. */
+export declare function resetReadConnectionForTests(): void;

package/lib/database/read-connection.js

@@ -0,0 +1,122 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The read-replica connection — a second pool pointed at a streaming standby.
+ *
+ * Shaped after {@link ./public-reader.ts}: a separate, smaller pool that
+ * connects like every other client (through pgbouncer), rather than a second
+ * target bolted onto the primary pool. As with the public reader, what selects
+ * the backend is the pgbouncer DATABASE name — `pipeline_builder_read`, whose
+ * `[databases]` entry points at the `postgres-read` Service — not the host.
+ * `DB_READ_HOST` is pgbouncer on every target, exactly like `DB_HOST`. It carries the SAME application role and
+ * the SAME RLS policies — a physical standby replicates `pg_authid` and every
+ * policy — so `withTenantTxRead` sets the identical GUCs here that
+ * `withTenantTx` sets on the primary.
+ *
+ * NOT CONFIGURED IS THE NORMAL STATE UNTIL A REPLICA EXISTS. With `DB_READ_HOST`
+ * unset, {@link getReadPool} returns null and every caller falls back to the
+ * primary. That is what lets this module ship before any infrastructure does,
+ * and it is also the degraded path the kill switch and (later) the lag circuit
+ * fall back to — so it has to keep working and be tested deliberately, not only
+ * exercised by accident on a laptop.
+ *
+ * WHY A SEPARATE MODULE rather than a flag on `Connection`: a global whose
+ * target can change is how a write reaches a standby. `Connection` stays the
+ * primary, unconditionally, and callers that want a replica have to ask for one
+ * by name.
+ */
+import { createLogger, envInt, envStr, isReadReplicaConfigured } from '@pipeline-builder/api-core';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { schema } from './drizzle-schema.js';
+import { getSslConfig } from './postgres-connection.js';
+const logger = createLogger('database-read');
+let pool = null;
+let readDb = null;
+/** Set once so a misconfigured deploy does not log on every query. */
+let warned = false;
+/**
+ * The replica pool, or null when no replica is configured.
+ *
+ * Lazily created so importing this module costs nothing on a deploy that has no
+ * replica — which, until Phase 1 lands, is all of them.
+ */
+export function getReadPool() {
+    if (!isReadReplicaConfigured())
+        return null;
+    if (pool)
+        return pool;
+    const host = envStr('DB_READ_HOST', '');
+    const config = {
+        host,
+        port: envInt('DB_READ_PORT', envInt('DB_PORT', 5432)),
+        // A DIFFERENT pgbouncer database than the write path, and that is the whole
+        // point: reads go to `pipeline_builder_read`, whose `[databases]` entry
+        // names `host=postgres-read` — the Service in front of the standbys. The
+        // primary's pool (`pipeline_builder`) names `host=postgres`.
+        //
+        // So the thing that decides whether a read reaches a replica is the
+        // DATABASE NAME, not the host: DB_READ_HOST is pgbouncer on every target,
+        // the same pooler the write path uses. Defaulting this to `DATABASE` would
+        // send every "read" straight back to the primary's pool through a second
+        // connection pool — all of the complexity, none of the offload, and no
+        // error anywhere to say so.
+        database: envStr('DB_READ_DATABASE', 'pipeline_builder_read'),
+        // The SAME application role as the primary. A standby replicates the role
+        // catalog, so a second credential would be a second thing to rotate for no
+        // benefit — and a role that existed only on the replica would vanish the
+        // moment the standby was re-seeded from a base backup.
+        user: envStr('DB_USER', 'postgres'),
+        password: process.env.DB_PASSWORD ?? '',
+        // Deliberately smaller than the primary's. Read traffic must not be able to
+        // exhaust connections the write path needs, and the replica has its own
+        // max_connections budget which is NOT the primary's.
+        max: envInt('DB_READ_MAX_POOL_SIZE', 10),
+        idleTimeoutMillis: envInt('DRIZZLE_IDLE_TIMEOUT_MILLIS', 30_000),
+        connectionTimeoutMillis: envInt('DRIZZLE_CONNECTION_TIMEOUT_MILLIS', 5000),
+        ssl: getSslConfig(),
+        allowExitOnIdle: true,
+    };
+    pool = new Pool(config);
+    pool.on('error', (err) => {
+        // Never throw from here: an idle-client error on the REPLICA must not take
+        // the process down, because every read can be served by the primary.
+        logger.error('Read-replica pool error (reads fall back to the primary)', err);
+    });
+    readDb = drizzle(pool, { schema });
+    logger.info('Read-replica connection initialized', { host, max: config.max });
+    return pool;
+}
+/** The replica's drizzle instance, or null when no replica is configured. */
+export function getReadDb() {
+    if (!getReadPool()) {
+        if (!warned && envStr('DB_READ_HOST', '').trim().length > 0) {
+            warned = true;
+            logger.info('Read replica is configured but disabled (DB_READ_ENABLED=false); reads use the primary');
+        }
+        return null;
+    }
+    return readDb;
+}
+/**
+ * Close the replica pool. Called from `closeConnection()` so a shutdown closes
+ * BOTH pools — a half-closed process holds server connections open on the
+ * standby and keeps its replication slot busy.
+ */
+export async function closeReadConnection() {
+    if (!pool)
+        return;
+    const p = pool;
+    pool = null;
+    readDb = null;
+    warned = false;
+    await p.end();
+    logger.info('Read-replica connection closed');
+}
+/** Test seam: forget the memoized pool without closing it. */
+export function resetReadConnectionForTests() {
+    pool = null;
+    readDb = null;
+    warned = false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"read-connection.js","sourceRoot":"","sources":["../../src/database/read-connection.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The read-replica connection — a second pool pointed at a streaming standby.\n *\n * Shaped after {@link ./public-reader.ts}: a separate, smaller pool that\n * connects like every other client (through pgbouncer), rather than a second\n * target bolted onto the primary pool. As with the public reader, what selects\n * the backend is the pgbouncer DATABASE name — `pipeline_builder_read`, whose\n * `[databases]` entry points at the `postgres-read` Service — not the host.\n * `DB_READ_HOST` is pgbouncer on every target, exactly like `DB_HOST`. It carries the SAME application role and\n * the SAME RLS policies — a physical standby replicates `pg_authid` and every\n * policy — so `withTenantTxRead` sets the identical GUCs here that\n * `withTenantTx` sets on the primary.\n *\n * NOT CONFIGURED IS THE NORMAL STATE UNTIL A REPLICA EXISTS. With `DB_READ_HOST`\n * unset, {@link getReadPool} returns null and every caller falls back to the\n * primary. That is what lets this module ship before any infrastructure does,\n * and it is also the degraded path the kill switch and (later) the lag circuit\n * fall back to — so it has to keep working and be tested deliberately, not only\n * exercised by accident on a laptop.\n *\n * WHY A SEPARATE MODULE rather than a flag on `Connection`: a global whose\n * target can change is how a write reaches a standby. `Connection` stays the\n * primary, unconditionally, and callers that want a replica have to ask for one\n * by name.\n */\n\nimport { createLogger, envInt, envStr, isReadReplicaConfigured } from '@pipeline-builder/api-core';\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { Pool, type PoolConfig } from 'pg';\n\nimport { schema } from './drizzle-schema.js';\nimport { getSslConfig } from './postgres-connection.js';\n\nconst logger = createLogger('database-read');\n\nlet pool: Pool | null = null;\nlet readDb: ReturnType<typeof drizzle> | null = null;\n/** Set once so a misconfigured deploy does not log on every query. */\nlet warned = false;\n\n/**\n * The replica pool, or null when no replica is configured.\n *\n * Lazily created so importing this module costs nothing on a deploy that has no\n * replica — which, until Phase 1 lands, is all of them.\n */\nexport function getReadPool(): Pool | null {\n  if (!isReadReplicaConfigured()) return null;\n  if (pool) return pool;\n\n  const host = envStr('DB_READ_HOST', '');\n  const config: PoolConfig = {\n    host,\n    port: envInt('DB_READ_PORT', envInt('DB_PORT', 5432)),\n    // A DIFFERENT pgbouncer database than the write path, and that is the whole\n    // point: reads go to `pipeline_builder_read`, whose `[databases]` entry\n    // names `host=postgres-read` — the Service in front of the standbys. The\n    // primary's pool (`pipeline_builder`) names `host=postgres`.\n    //\n    // So the thing that decides whether a read reaches a replica is the\n    // DATABASE NAME, not the host: DB_READ_HOST is pgbouncer on every target,\n    // the same pooler the write path uses. Defaulting this to `DATABASE` would\n    // send every \"read\" straight back to the primary's pool through a second\n    // connection pool — all of the complexity, none of the offload, and no\n    // error anywhere to say so.\n    database: envStr('DB_READ_DATABASE', 'pipeline_builder_read'),\n    // The SAME application role as the primary. A standby replicates the role\n    // catalog, so a second credential would be a second thing to rotate for no\n    // benefit — and a role that existed only on the replica would vanish the\n    // moment the standby was re-seeded from a base backup.\n    user: envStr('DB_USER', 'postgres'),\n    password: process.env.DB_PASSWORD ?? '',\n    // Deliberately smaller than the primary's. Read traffic must not be able to\n    // exhaust connections the write path needs, and the replica has its own\n    // max_connections budget which is NOT the primary's.\n    max: envInt('DB_READ_MAX_POOL_SIZE', 10),\n    idleTimeoutMillis: envInt('DRIZZLE_IDLE_TIMEOUT_MILLIS', 30_000),\n    connectionTimeoutMillis: envInt('DRIZZLE_CONNECTION_TIMEOUT_MILLIS', 5000),\n    ssl: getSslConfig(),\n    allowExitOnIdle: true,\n  };\n\n  pool = new Pool(config);\n  pool.on('error', (err) => {\n    // Never throw from here: an idle-client error on the REPLICA must not take\n    // the process down, because every read can be served by the primary.\n    logger.error('Read-replica pool error (reads fall back to the primary)', err);\n  });\n  readDb = drizzle(pool, { schema });\n\n  logger.info('Read-replica connection initialized', { host, max: config.max });\n  return pool;\n}\n\n/** The replica's drizzle instance, or null when no replica is configured. */\nexport function getReadDb(): ReturnType<typeof drizzle> | null {\n  if (!getReadPool()) {\n    if (!warned && envStr('DB_READ_HOST', '').trim().length > 0) {\n      warned = true;\n      logger.info('Read replica is configured but disabled (DB_READ_ENABLED=false); reads use the primary');\n    }\n    return null;\n  }\n  return readDb;\n}\n\n/**\n * Close the replica pool. Called from `closeConnection()` so a shutdown closes\n * BOTH pools — a half-closed process holds server connections open on the\n * standby and keeps its replication slot busy.\n */\nexport async function closeReadConnection(): Promise<void> {\n  if (!pool) return;\n  const p = pool;\n  pool = null;\n  readDb = null;\n  warned = false;\n  await p.end();\n  logger.info('Read-replica connection closed');\n}\n\n/** Test seam: forget the memoized pool without closing it. */\nexport function resetReadConnectionForTests(): void {\n  pool = null;\n  readDb = null;\n  warned = false;\n}\n"]}

package/lib/database/read-lag.d.ts

@@ -0,0 +1,31 @@
+import type { Pool } from 'pg';
+export type LagVerdict = 
+/** No sample yet, or the last one is stale/failed. Reads use the primary. */
+'unknown'
+/** Replay lag is within the threshold. */
+ | 'ok'
+/** Replay lag is beyond the threshold. Reads use the primary. */
+ | 'lagging';
+/**
+ * The circuit's current state, read synchronously by the routing decision.
+ *
+ * Returns `unknown` rather than throwing or guessing when there is nothing
+ * trustworthy to report, and every caller treats `unknown` as "use the
+ * primary".
+ */
+export declare function lagVerdict(now?: number): LagVerdict;
+/**
+ * Refresh the sample if it is due. Fire-and-forget: never throws, never
+ * returns a rejected promise, and resolves as soon as a sample is not needed.
+ *
+ * `pg_is_in_recovery() = false` means this pool is pointed at a PRIMARY, which
+ * is a misconfiguration worth surfacing rather than a lag of zero — but it is
+ * reported as lag 0 anyway, because the alternative is refusing to serve reads
+ * from a server that is, in fact, able to serve them correctly. The warning is
+ * logged once per transition instead.
+ */
+export declare function maybeSampleLag(pool: Pool): Promise<void>;
+/** Test seam: forget the cached sample and failure state. */
+export declare function resetLagStateForTests(): void;
+/** Test seam: install a sample directly, without a database. */
+export declare function setLagSampleForTests(lagSeconds: number, atMs?: number): void;

package/lib/database/read-lag.js

@@ -0,0 +1,202 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The read-replica lag circuit.
+ *
+ * A standby that has fallen behind does not fail reads — it answers them with
+ * old data, confidently and quickly. That is the whole hazard of read-splitting
+ * and the reason this module gates the feature: `DB_READ_HOST` must not be
+ * configured on any target until this exists.
+ *
+ * SHAPE: a cached sample, not a per-query check. Asking the standby how far
+ * behind it is costs a round-trip, so doing it per read would spend most of the
+ * benefit on the measurement. Instead a sample is refreshed at most every
+ * `DB_READ_LAG_SAMPLE_MS` in the background, and the routing decision reads the
+ * cache synchronously.
+ *
+ * FAIL CLOSED, THREE WAYS. An unknown lag is treated as unacceptable, so:
+ *   - before the first sample completes, reads go to the primary;
+ *   - if the sample query errors, reads go to the primary;
+ *   - if the cached sample has gone STALE — the sampler stopped running, the
+ *     pool is wedged — reads go to the primary.
+ * The last one matters most: a cache that merely stops updating would otherwise
+ * freeze the circuit in whatever state it was last in, which for a healthy
+ * reading means "keep using a replica nobody is checking any more".
+ *
+ * WHY NOT A TIMER: pipeline-data has no scheduler and no leader lock, and a
+ * `setInterval` in a library keeps the event loop alive and leaks across tests.
+ * Sampling is kicked off opportunistically from the read path instead
+ * (fire-and-forget, debounced), so a process that never reads never samples —
+ * which is correct, and costs nothing.
+ */
+import { createLogger, emitGauge, envInt } from '@pipeline-builder/api-core';
+const logger = createLogger('database-read-lag');
+/**
+ * How far behind a standby may be and still serve reads.
+ *
+ * Five seconds is a deliberately loose default: this circuit exists to catch a
+ * standby that is BROKEN or badly behind, not to provide read-your-writes.
+ * Read-after-write is handled separately and exactly, by the write watermark in
+ * `tenancy.ts` — a lag threshold cannot do that job at any value, because a
+ * replica 200ms behind still has not replayed a commit from 100ms ago.
+ * Confusing the two is how a lag threshold ends up tuned to a number that
+ * neither protects correctness nor permits any offload.
+ */
+const maxLagSeconds = () => envInt('DB_READ_MAX_LAG_SECONDS', 5);
+const sampleIntervalMs = () => envInt('DB_READ_LAG_SAMPLE_MS', 5000);
+/**
+ * How long one sample may take before it is abandoned.
+ *
+ * THIS IS NOT A PERFORMANCE KNOB, it is what makes the sampler recoverable.
+ * Nothing else bounds a running query on this pool — `connectionTimeoutMillis`
+ * bounds ACQUIRING a connection and `idleTimeoutMillis` evicts idle ones;
+ * neither touches a query already executing. So a wedged connection left
+ * `inFlight` true forever, the `finally` never ran, every later call returned
+ * at the guard, and no further sample was taken FOR THE LIFE OF THE PROCESS.
+ * The cached reading then went stale, the verdict became `unknown`, and every
+ * read fell back to the primary permanently — safe, but unrecoverable without
+ * a restart, and visible only as PostgresReadCircuitOpen 30 minutes later.
+ */
+const sampleTimeoutMs = () => envInt('DB_READ_LAG_SAMPLE_TIMEOUT_MS', 5000);
+/**
+ * Race a query against a timer so the caller always regains control.
+ *
+ * The abandoned query is left to the pool — Postgres keeps running it, and the
+ * pool's own idle handling reclaims the connection. That is deliberate: the
+ * alternative is cancelling server-side, which needs a second connection and a
+ * PID, and this is a 1-row read whose cost is bounded anyway. What matters is
+ * that `inFlight` is released, so the next read retries.
+ *
+ * `clearTimeout` in `finally` is not tidiness: an un-cleared timer keeps the
+ * Node event loop alive, which hangs a test run and, in a short-lived process,
+ * delays exit.
+ */
+async function withTimeout(work, ms, what) {
+    let timer;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`${what} timed out after ${ms}ms`)), ms);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+/** A sample older than this many intervals is treated as no sample at all. */
+const STALE_INTERVALS = 3;
+let sample = null;
+let inFlight = false;
+let consecutiveFailures = 0;
+/**
+ * The circuit's current state, read synchronously by the routing decision.
+ *
+ * Returns `unknown` rather than throwing or guessing when there is nothing
+ * trustworthy to report, and every caller treats `unknown` as "use the
+ * primary".
+ */
+export function lagVerdict(now = Date.now()) {
+    if (!sample)
+        return 'unknown';
+    if (now - sample.atMs > sampleIntervalMs() * STALE_INTERVALS)
+        return 'unknown';
+    return sample.lagSeconds > maxLagSeconds() ? 'lagging' : 'ok';
+}
+/**
+ * The lag query, and the one subtlety in this whole module.
+ *
+ * `now() - pg_last_xact_replay_timestamp()` is the usual lag expression and it
+ * is WRONG ON ITS OWN: that timestamp is the commit time of the last replayed
+ * transaction, so on an idle primary it simply gets older and older. A standby
+ * that is perfectly caught up on a quiet system would report minutes of "lag"
+ * and this circuit would send every read back to the primary — permanently,
+ * and most visibly at night when nothing is happening.
+ *
+ * The guard is the LSN comparison first: when everything received has been
+ * replayed, the standby is current by definition, whatever the clock says.
+ * Only when there is unreplayed WAL does the timestamp mean anything.
+ */
+const LAG_SQL = `
+  SELECT CASE
+    WHEN NOT pg_is_in_recovery() THEN 0
+    WHEN pg_last_wal_receive_lsn() IS NULL THEN NULL
+    WHEN pg_last_wal_receive_lsn() = pg_last_wal_replay_lsn() THEN 0
+    ELSE GREATEST(0, EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())))
+  END AS lag_seconds
+`;
+/**
+ * Refresh the sample if it is due. Fire-and-forget: never throws, never
+ * returns a rejected promise, and resolves as soon as a sample is not needed.
+ *
+ * `pg_is_in_recovery() = false` means this pool is pointed at a PRIMARY, which
+ * is a misconfiguration worth surfacing rather than a lag of zero — but it is
+ * reported as lag 0 anyway, because the alternative is refusing to serve reads
+ * from a server that is, in fact, able to serve them correctly. The warning is
+ * logged once per transition instead.
+ */
+export async function maybeSampleLag(pool) {
+    const now = Date.now();
+    if (inFlight)
+        return;
+    if (sample && now - sample.atMs < sampleIntervalMs())
+        return;
+    inFlight = true;
+    try {
+        const res = await withTimeout(pool.query(LAG_SQL), sampleTimeoutMs(), 'read-replica lag sample');
+        const raw = res.rows[0]?.lag_seconds;
+        if (raw === null || raw === undefined) {
+            // A standby that has never received WAL. Not an error, but not a usable
+            // reading either — it must not be recorded as "caught up".
+            recordFailure('no WAL received yet');
+            return;
+        }
+        const lagSeconds = Number(raw);
+        if (!Number.isFinite(lagSeconds)) {
+            recordFailure(`non-numeric lag value: ${String(raw)}`);
+            return;
+        }
+        if (consecutiveFailures > 0) {
+            logger.info('Read-replica lag sampling recovered', { afterFailures: consecutiveFailures, lagSeconds });
+            consecutiveFailures = 0;
+        }
+        sample = { lagSeconds, atMs: Date.now() };
+        emitGauge('postgres_replica_lag_seconds', {}, lagSeconds);
+        emitGauge('postgres_read_circuit_open', {}, lagVerdict() === 'ok' ? 0 : 1);
+    }
+    catch (err) {
+        recordFailure(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        inFlight = false;
+    }
+}
+function recordFailure(reason) {
+    consecutiveFailures += 1;
+    // Discard the previous sample rather than keeping a stale "ok": a sampler
+    // that cannot reach the standby is exactly when reads must not go there.
+    sample = null;
+    emitGauge('postgres_read_circuit_open', {}, 1);
+    // Log the first failure and then back off, so an unreachable standby does not
+    // produce a line per read.
+    if (consecutiveFailures === 1 || consecutiveFailures % 100 === 0) {
+        logger.warn('Read-replica lag sample failed; reads fall back to the primary', {
+            reason,
+            consecutiveFailures,
+        });
+    }
+}
+/** Test seam: forget the cached sample and failure state. */
+export function resetLagStateForTests() {
+    sample = null;
+    inFlight = false;
+    consecutiveFailures = 0;
+}
+/** Test seam: install a sample directly, without a database. */
+export function setLagSampleForTests(lagSeconds, atMs = Date.now()) {
+    sample = { lagSeconds, atMs };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"read-lag.js","sourceRoot":"","sources":["../../src/database/read-lag.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The read-replica lag circuit.\n *\n * A standby that has fallen behind does not fail reads — it answers them with\n * old data, confidently and quickly. That is the whole hazard of read-splitting\n * and the reason this module gates the feature: `DB_READ_HOST` must not be\n * configured on any target until this exists.\n *\n * SHAPE: a cached sample, not a per-query check. Asking the standby how far\n * behind it is costs a round-trip, so doing it per read would spend most of the\n * benefit on the measurement. Instead a sample is refreshed at most every\n * `DB_READ_LAG_SAMPLE_MS` in the background, and the routing decision reads the\n * cache synchronously.\n *\n * FAIL CLOSED, THREE WAYS. An unknown lag is treated as unacceptable, so:\n *   - before the first sample completes, reads go to the primary;\n *   - if the sample query errors, reads go to the primary;\n *   - if the cached sample has gone STALE — the sampler stopped running, the\n *     pool is wedged — reads go to the primary.\n * The last one matters most: a cache that merely stops updating would otherwise\n * freeze the circuit in whatever state it was last in, which for a healthy\n * reading means \"keep using a replica nobody is checking any more\".\n *\n * WHY NOT A TIMER: pipeline-data has no scheduler and no leader lock, and a\n * `setInterval` in a library keeps the event loop alive and leaks across tests.\n * Sampling is kicked off opportunistically from the read path instead\n * (fire-and-forget, debounced), so a process that never reads never samples —\n * which is correct, and costs nothing.\n */\n\nimport { createLogger, emitGauge, envInt } from '@pipeline-builder/api-core';\nimport type { Pool } from 'pg';\n\nconst logger = createLogger('database-read-lag');\n\n/**\n * How far behind a standby may be and still serve reads.\n *\n * Five seconds is a deliberately loose default: this circuit exists to catch a\n * standby that is BROKEN or badly behind, not to provide read-your-writes.\n * Read-after-write is handled separately and exactly, by the write watermark in\n * `tenancy.ts` — a lag threshold cannot do that job at any value, because a\n * replica 200ms behind still has not replayed a commit from 100ms ago.\n * Confusing the two is how a lag threshold ends up tuned to a number that\n * neither protects correctness nor permits any offload.\n */\nconst maxLagSeconds = () => envInt('DB_READ_MAX_LAG_SECONDS', 5);\nconst sampleIntervalMs = () => envInt('DB_READ_LAG_SAMPLE_MS', 5000);\n/**\n * How long one sample may take before it is abandoned.\n *\n * THIS IS NOT A PERFORMANCE KNOB, it is what makes the sampler recoverable.\n * Nothing else bounds a running query on this pool — `connectionTimeoutMillis`\n * bounds ACQUIRING a connection and `idleTimeoutMillis` evicts idle ones;\n * neither touches a query already executing. So a wedged connection left\n * `inFlight` true forever, the `finally` never ran, every later call returned\n * at the guard, and no further sample was taken FOR THE LIFE OF THE PROCESS.\n * The cached reading then went stale, the verdict became `unknown`, and every\n * read fell back to the primary permanently — safe, but unrecoverable without\n * a restart, and visible only as PostgresReadCircuitOpen 30 minutes later.\n */\nconst sampleTimeoutMs = () => envInt('DB_READ_LAG_SAMPLE_TIMEOUT_MS', 5000);\n\n/**\n * Race a query against a timer so the caller always regains control.\n *\n * The abandoned query is left to the pool — Postgres keeps running it, and the\n * pool's own idle handling reclaims the connection. That is deliberate: the\n * alternative is cancelling server-side, which needs a second connection and a\n * PID, and this is a 1-row read whose cost is bounded anyway. What matters is\n * that `inFlight` is released, so the next read retries.\n *\n * `clearTimeout` in `finally` is not tidiness: an un-cleared timer keeps the\n * Node event loop alive, which hangs a test run and, in a short-lived process,\n * delays exit.\n */\nasync function withTimeout<T>(work: Promise<T>, ms: number, what: string): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  try {\n    return await Promise.race([\n      work,\n      new Promise<never>((_resolve, reject) => {\n        timer = setTimeout(() => reject(new Error(`${what} timed out after ${ms}ms`)), ms);\n        timer.unref?.();\n      }),\n    ]);\n  } finally {\n    if (timer) clearTimeout(timer);\n  }\n}\n\n/** A sample older than this many intervals is treated as no sample at all. */\nconst STALE_INTERVALS = 3;\n\ninterface Sample {\n  lagSeconds: number;\n  atMs: number;\n}\n\nlet sample: Sample | null = null;\nlet inFlight = false;\nlet consecutiveFailures = 0;\n\nexport type LagVerdict =\n  /** No sample yet, or the last one is stale/failed. Reads use the primary. */\n  | 'unknown'\n  /** Replay lag is within the threshold. */\n  | 'ok'\n  /** Replay lag is beyond the threshold. Reads use the primary. */\n  | 'lagging';\n\n/**\n * The circuit's current state, read synchronously by the routing decision.\n *\n * Returns `unknown` rather than throwing or guessing when there is nothing\n * trustworthy to report, and every caller treats `unknown` as \"use the\n * primary\".\n */\nexport function lagVerdict(now = Date.now()): LagVerdict {\n  if (!sample) return 'unknown';\n  if (now - sample.atMs > sampleIntervalMs() * STALE_INTERVALS) return 'unknown';\n  return sample.lagSeconds > maxLagSeconds() ? 'lagging' : 'ok';\n}\n\n/**\n * The lag query, and the one subtlety in this whole module.\n *\n * `now() - pg_last_xact_replay_timestamp()` is the usual lag expression and it\n * is WRONG ON ITS OWN: that timestamp is the commit time of the last replayed\n * transaction, so on an idle primary it simply gets older and older. A standby\n * that is perfectly caught up on a quiet system would report minutes of \"lag\"\n * and this circuit would send every read back to the primary — permanently,\n * and most visibly at night when nothing is happening.\n *\n * The guard is the LSN comparison first: when everything received has been\n * replayed, the standby is current by definition, whatever the clock says.\n * Only when there is unreplayed WAL does the timestamp mean anything.\n */\nconst LAG_SQL = `\n  SELECT CASE\n    WHEN NOT pg_is_in_recovery() THEN 0\n    WHEN pg_last_wal_receive_lsn() IS NULL THEN NULL\n    WHEN pg_last_wal_receive_lsn() = pg_last_wal_replay_lsn() THEN 0\n    ELSE GREATEST(0, EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())))\n  END AS lag_seconds\n`;\n\n/**\n * Refresh the sample if it is due. Fire-and-forget: never throws, never\n * returns a rejected promise, and resolves as soon as a sample is not needed.\n *\n * `pg_is_in_recovery() = false` means this pool is pointed at a PRIMARY, which\n * is a misconfiguration worth surfacing rather than a lag of zero — but it is\n * reported as lag 0 anyway, because the alternative is refusing to serve reads\n * from a server that is, in fact, able to serve them correctly. The warning is\n * logged once per transition instead.\n */\nexport async function maybeSampleLag(pool: Pool): Promise<void> {\n  const now = Date.now();\n  if (inFlight) return;\n  if (sample && now - sample.atMs < sampleIntervalMs()) return;\n  inFlight = true;\n  try {\n    const res = await withTimeout(\n      pool.query<{ lag_seconds: string | number | null }>(LAG_SQL),\n      sampleTimeoutMs(),\n      'read-replica lag sample',\n    );\n    const raw = res.rows[0]?.lag_seconds;\n    if (raw === null || raw === undefined) {\n      // A standby that has never received WAL. Not an error, but not a usable\n      // reading either — it must not be recorded as \"caught up\".\n      recordFailure('no WAL received yet');\n      return;\n    }\n    const lagSeconds = Number(raw);\n    if (!Number.isFinite(lagSeconds)) {\n      recordFailure(`non-numeric lag value: ${String(raw)}`);\n      return;\n    }\n    if (consecutiveFailures > 0) {\n      logger.info('Read-replica lag sampling recovered', { afterFailures: consecutiveFailures, lagSeconds });\n      consecutiveFailures = 0;\n    }\n    sample = { lagSeconds, atMs: Date.now() };\n    emitGauge('postgres_replica_lag_seconds', {}, lagSeconds);\n    emitGauge('postgres_read_circuit_open', {}, lagVerdict() === 'ok' ? 0 : 1);\n  } catch (err) {\n    recordFailure(err instanceof Error ? err.message : String(err));\n  } finally {\n    inFlight = false;\n  }\n}\n\nfunction recordFailure(reason: string): void {\n  consecutiveFailures += 1;\n  // Discard the previous sample rather than keeping a stale \"ok\": a sampler\n  // that cannot reach the standby is exactly when reads must not go there.\n  sample = null;\n  emitGauge('postgres_read_circuit_open', {}, 1);\n  // Log the first failure and then back off, so an unreachable standby does not\n  // produce a line per read.\n  if (consecutiveFailures === 1 || consecutiveFailures % 100 === 0) {\n    logger.warn('Read-replica lag sample failed; reads fall back to the primary', {\n      reason,\n      consecutiveFailures,\n    });\n  }\n}\n\n/** Test seam: forget the cached sample and failure state. */\nexport function resetLagStateForTests(): void {\n  sample = null;\n  inFlight = false;\n  consecutiveFailures = 0;\n}\n\n/** Test seam: install a sample directly, without a database. */\nexport function setLagSampleForTests(lagSeconds: number, atMs = Date.now()): void {\n  sample = { lagSeconds, atMs };\n}\n"]}