@pipeline-builder/pipeline-data 3.4.36 → 3.4.38

package/lib/database/index.d.ts

@@ -1,4 +1,5 @@
 export * from './drizzle-schema';
 export * from './postgres-connection';
 export * from './retry-strategy';
+export * from './tenancy';
 export { runMigrations, type MigrateOptions } from './migrator';

package/lib/database/index.js

@@ -20,6 +20,7 @@ exports.runMigrations = void 0;
 __exportStar(require("./drizzle-schema"), exports);
 __exportStar(require("./postgres-connection"), exports);
 __exportStar(require("./retry-strategy"), exports);
+__exportStar(require("./tenancy"), exports);
 var migrator_1 = require("./migrator");
 Object.defineProperty(exports, "runMigrations", { enumerable: true, get: function () { return migrator_1.runMigrations; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YWJhc2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRXRDLG1EQUFpQztBQUNqQyx3REFBc0M7QUFDdEMsbURBQWlDO0FBQ2pDLHVDQUFnRTtBQUF2RCx5R0FBQSxhQUFhLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9kcml6emxlLXNjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL3Bvc3RncmVzLWNvbm5lY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9yZXRyeS1zdHJhdGVneSc7XG5leHBvcnQgeyBydW5NaWdyYXRpb25zLCB0eXBlIE1pZ3JhdGVPcHRpb25zIH0gZnJvbSAnLi9taWdyYXRvcic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YWJhc2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRXRDLG1EQUFpQztBQUNqQyx3REFBc0M7QUFDdEMsbURBQWlDO0FBQ2pDLDRDQUEwQjtBQUMxQix1Q0FBZ0U7QUFBdkQseUdBQUEsYUFBYSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vZHJpenpsZS1zY2hlbWEnO1xuZXhwb3J0ICogZnJvbSAnLi9wb3N0Z3Jlcy1jb25uZWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vcmV0cnktc3RyYXRlZ3knO1xuZXhwb3J0ICogZnJvbSAnLi90ZW5hbmN5JztcbmV4cG9ydCB7IHJ1bk1pZ3JhdGlvbnMsIHR5cGUgTWlncmF0ZU9wdGlvbnMgfSBmcm9tICcuL21pZ3JhdG9yJztcbiJdfQ==

package/lib/database/postgres-connection.d.ts

@@ -230,3 +230,16 @@ export declare function testConnection(): Promise<boolean>;
  * ```
  */
 export declare function initializeDatabase(): Promise<void>;
+/**
+ * Proxy that resolves to the read-replica `db` when `DB_REPLICA_HOST` is
+ * set, and to the primary `db` otherwise. Use for read-only queries that
+ * tolerate replica lag (typically tens of ms). Writes and transactions
+ * MUST stay on the primary `db`.
+ *
+ * Same lazy-initialization pattern as `db` — the replica pool is built on
+ * first use, not on module import.
+ */
+export declare const dbReplica: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+    $client: Pool;
+};
+export declare function closeAllConnections(): Promise<void>;

package/lib/database/postgres-connection.js

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

package/lib/database/retry-strategy.js

@@ -4,7 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionRetryStrategy = void 0;
 const api_core_1 = require("@pipeline-builder/api-core");
-const logger = (0, api_core_1.createLogger)('RetryStrategy');
+const logger = (0, api_core_1.createLogger)('retry-strategy');
 /**
  * Implements exponential backoff retry strategy for database connections.
  *
@@ -123,4 +123,4 @@ class ConnectionRetryStrategy {
     }
 }
 exports.ConnectionRetryStrategy = ConnectionRetryStrategy;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry-strategy.js","sourceRoot":"","sources":["../../src/database/retry-strategy.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';\n\nconst logger = createLogger('RetryStrategy');\n\n/**\n * Configuration for connection retry strategy\n */\nexport interface RetryConfig {\n  /** Maximum number of retry attempts */\n  maxRetries: number;\n  /** Base delay between retries in milliseconds */\n  baseDelay: number;\n}\n\n/**\n * Implements exponential backoff retry strategy for database connections.\n *\n * Features:\n * - Exponential backoff with configurable base delay\n * - Attempt tracking and logging\n * - Graceful failure after max retries\n *\n * @example\n * ```typescript\n * const strategy = new ConnectionRetryStrategy({ maxRetries: 3, baseDelay: 1000 });\n *\n * const result = await strategy.execute(async () => {\n *   return await db.query('SELECT 1');\n * });\n * ```\n */\nexport class ConnectionRetryStrategy {\n  private attempts = 0;\n\n  constructor(private readonly config: RetryConfig) {}\n\n  /**\n   * Executes an operation with retry logic\n   *\n   * @param operation - Async function to execute with retries\n   * @returns Promise resolving to operation result\n   * @throws Error if all retry attempts fail\n   */\n  async execute<T>(operation: () => Promise<T>): Promise<T> {\n    this.attempts = 0;\n\n    while (this.attempts < this.config.maxRetries) {\n      try {\n        const result = await operation();\n        if (this.attempts > 0) {\n          logger.info('Operation succeeded after retry');\n        }\n        return result;\n      } catch (error) {\n        this.attempts++;\n\n        if (this.attempts >= this.config.maxRetries) {\n          logger.error(`Max retry attempts (${this.config.maxRetries}) reached`);\n          throw error;\n        }\n\n        const delay = this.calculateBackoff(this.attempts);\n        logger.warn(\n          `Operation failed (attempt ${this.attempts}/${this.config.maxRetries}), retrying in ${delay}ms...`,\n          { error: error instanceof Error ? error.message : String(error) },\n        );\n\n        await this.sleep(delay);\n      }\n    }\n\n    throw new Error('Retry logic failed unexpectedly');\n  }\n\n  /**\n   * Handles connection errors with retry tracking\n   *\n   * @param error - Error that occurred\n   * @param testConnection - Function to test if connection is restored\n   */\n  async handleConnectionError(error: Error, testConnection: () => Promise<boolean>): Promise<void> {\n    this.attempts++;\n\n    logger.error(\n      `Connection error (attempt ${this.attempts}/${this.config.maxRetries}):`,\n      error.message,\n    );\n\n    if (this.attempts < this.config.maxRetries) {\n      const delay = this.calculateBackoff(this.attempts);\n      logger.info(`Retrying connection in ${delay}ms...`);\n\n      await this.sleep(delay);\n\n      try {\n        const isHealthy = await testConnection();\n        if (isHealthy) {\n          logger.info('Connection restored');\n          this.attempts = 0; // Reset on successful connection\n        } else {\n          logger.error('Connection test failed after retry');\n        }\n      } catch (retryError) {\n        logger.error('Retry failed:', retryError);\n      }\n    } else {\n      logger.error('Max connection retry attempts reached');\n    }\n  }\n\n  /**\n   * Resets the attempt counter\n   * Call this after a successful operation\n   */\n  reset(): void {\n    this.attempts = 0;\n  }\n\n  /**\n   * Gets the current attempt count\n   */\n  getAttempts(): number {\n    return this.attempts;\n  }\n\n  /**\n   * Calculates exponential backoff delay\n   *\n   * @param attempt - Current attempt number (1-indexed)\n   * @returns Delay in milliseconds\n   */\n  private calculateBackoff(attempt: number): number {\n    const base = this.config.baseDelay * Math.pow(2, attempt - 1);\n    const jitter = Math.random() * 0.1 * base;\n    return base + jitter;\n  }\n\n  /**\n   * Sleeps for the specified duration\n   *\n   * @param ms - Milliseconds to sleep\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry-strategy.js","sourceRoot":"","sources":["../../src/database/retry-strategy.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAEtC,yDAA0D;AAE1D,MAAM,MAAM,GAAG,IAAA,uBAAY,EAAC,gBAAgB,CAAC,CAAC;AAY9C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,uBAAuB;IAGL;IAFrB,QAAQ,GAAG,CAAC,CAAC;IAErB,YAA6B,MAAmB;QAAnB,WAAM,GAAN,MAAM,CAAa;IAAG,CAAC;IAEpD;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAI,SAA2B;QAC1C,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAElB,OAAO,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC9C,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;gBACjC,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;oBACtB,MAAM,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;gBACjD,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAEhB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;oBAC5C,MAAM,CAAC,KAAK,CAAC,uBAAuB,IAAI,CAAC,MAAM,CAAC,UAAU,WAAW,CAAC,CAAC;oBACvE,MAAM,KAAK,CAAC;gBACd,CAAC;gBAED,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACnD,MAAM,CAAC,IAAI,CACT,6BAA6B,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,kBAAkB,KAAK,OAAO,EAClG,EAAE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAClE,CAAC;gBAEF,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,qBAAqB,CAAC,KAAY,EAAE,cAAsC;QAC9E,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEhB,MAAM,CAAC,KAAK,CACV,6BAA6B,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,EACxE,KAAK,CAAC,OAAO,CACd,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACnD,MAAM,CAAC,IAAI,CAAC,0BAA0B,KAAK,OAAO,CAAC,CAAC;YAEpD,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAExB,IAAI,CAAC;gBACH,MAAM,SAAS,GAAG,MAAM,cAAc,EAAE,CAAC;gBACzC,IAAI,SAAS,EAAE,CAAC;oBACd,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;oBACnC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,iCAAiC;gBACtD,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;gBACrD,CAAC;YACH,CAAC;YAAC,OAAO,UAAU,EAAE,CAAC;gBACpB,MAAM,CAAC,KAAK,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACK,gBAAgB,CAAC,OAAe;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;QAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,IAAI,CAAC;QAC1C,OAAO,IAAI,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,EAAU;QACtB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;CACF;AAlHD,0DAkHC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\n\nconst logger = createLogger('retry-strategy');\n\n/**\n * Configuration for connection retry strategy\n */\nexport interface RetryConfig {\n  /** Maximum number of retry attempts */\n  maxRetries: number;\n  /** Base delay between retries in milliseconds */\n  baseDelay: number;\n}\n\n/**\n * Implements exponential backoff retry strategy for database connections.\n *\n * Features:\n * - Exponential backoff with configurable base delay\n * - Attempt tracking and logging\n * - Graceful failure after max retries\n *\n * @example\n * ```typescript\n * const strategy = new ConnectionRetryStrategy({ maxRetries: 3, baseDelay: 1000 });\n *\n * const result = await strategy.execute(async () => {\n *   return await db.query('SELECT 1');\n * });\n * ```\n */\nexport class ConnectionRetryStrategy {\n  private attempts = 0;\n\n  constructor(private readonly config: RetryConfig) {}\n\n  /**\n   * Executes an operation with retry logic\n   *\n   * @param operation - Async function to execute with retries\n   * @returns Promise resolving to operation result\n   * @throws Error if all retry attempts fail\n   */\n  async execute<T>(operation: () => Promise<T>): Promise<T> {\n    this.attempts = 0;\n\n    while (this.attempts < this.config.maxRetries) {\n      try {\n        const result = await operation();\n        if (this.attempts > 0) {\n          logger.info('Operation succeeded after retry');\n        }\n        return result;\n      } catch (error) {\n        this.attempts++;\n\n        if (this.attempts >= this.config.maxRetries) {\n          logger.error(`Max retry attempts (${this.config.maxRetries}) reached`);\n          throw error;\n        }\n\n        const delay = this.calculateBackoff(this.attempts);\n        logger.warn(\n          `Operation failed (attempt ${this.attempts}/${this.config.maxRetries}), retrying in ${delay}ms...`,\n          { error: error instanceof Error ? error.message : String(error) },\n        );\n\n        await this.sleep(delay);\n      }\n    }\n\n    throw new Error('Retry logic failed unexpectedly');\n  }\n\n  /**\n   * Handles connection errors with retry tracking\n   *\n   * @param error - Error that occurred\n   * @param testConnection - Function to test if connection is restored\n   */\n  async handleConnectionError(error: Error, testConnection: () => Promise<boolean>): Promise<void> {\n    this.attempts++;\n\n    logger.error(\n      `Connection error (attempt ${this.attempts}/${this.config.maxRetries}):`,\n      error.message,\n    );\n\n    if (this.attempts < this.config.maxRetries) {\n      const delay = this.calculateBackoff(this.attempts);\n      logger.info(`Retrying connection in ${delay}ms...`);\n\n      await this.sleep(delay);\n\n      try {\n        const isHealthy = await testConnection();\n        if (isHealthy) {\n          logger.info('Connection restored');\n          this.attempts = 0; // Reset on successful connection\n        } else {\n          logger.error('Connection test failed after retry');\n        }\n      } catch (retryError) {\n        logger.error('Retry failed:', retryError);\n      }\n    } else {\n      logger.error('Max connection retry attempts reached');\n    }\n  }\n\n  /**\n   * Resets the attempt counter\n   * Call this after a successful operation\n   */\n  reset(): void {\n    this.attempts = 0;\n  }\n\n  /**\n   * Gets the current attempt count\n   */\n  getAttempts(): number {\n    return this.attempts;\n  }\n\n  /**\n   * Calculates exponential backoff delay\n   *\n   * @param attempt - Current attempt number (1-indexed)\n   * @returns Delay in milliseconds\n   */\n  private calculateBackoff(attempt: number): number {\n    const base = this.config.baseDelay * Math.pow(2, attempt - 1);\n    const jitter = Math.random() * 0.1 * base;\n    return base + jitter;\n  }\n\n  /**\n   * Sleeps for the specified duration\n   *\n   * @param ms - Milliseconds to sleep\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n"]}

package/lib/database/tenancy.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Tenant-context plumbing for Postgres row-level security.
+ *
+ * Background: postgres-init.sql installs RLS policies on every user-data
+ * table that consult two session GUCs — `app.org_id` and `app.is_sysadmin`.
+ * Today the tables are in owner-bypass mode (the connection user owns them,
+ * Postgres lets owners skip RLS), so the policies don't actually enforce.
+ * Once we flip a table to `FORCE ROW LEVEL SECURITY`, every query against
+ * it must run inside a transaction that has SET LOCAL'd both GUCs — or it
+ * returns zero rows for non-sysadmins (and may fail to write for any caller).
+ *
+ * This module is the seam.
+ *
+ *   1. `tenantContext` (AsyncLocalStorage) carries `{orgId, isSuperAdmin}`
+ *      down the call chain without prop-drilling. Set once at the request
+ *      boundary; readable from anywhere.
+ *
+ *   2. `withTenantTx(fn)` opens a transaction, SET LOCAL's both GUCs from
+ *      the surrounding context, then invokes `fn(tx)`. Services migrate one
+ *      at a time by wrapping their existing drizzle calls in this helper —
+ *      `db.select().from(...)` becomes `withTenantTx(tx => tx.select().from(...))`.
+ *
+ *   3. `runWithTenantContext(ctx, fn)` is the Express-middleware-side
+ *      bookend that establishes the AsyncLocalStorage scope for the request.
+ *
+ * Migration order (see docs/plans/f-1-0-rls-enforcement.md):
+ *   - First adopters: newly-written services (dashboard, alert-destination)
+ *     where the change is mechanical.
+ *   - Then high-write services (plugin, pipeline). Soak each one before
+ *     flipping the underlying table to FORCE.
+ *   - admin_audit_log uses a sysadmin-only policy — sysadmin paths must
+ *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { db } from './postgres-connection';
+export interface TenantContext {
+    /** Caller's org. Undefined for un-authenticated / system jobs. */
+    orgId?: string;
+    /** True when the caller is a sysadmin (system-org admin). Bypasses RLS
+     *  policies via the sysadmin-bypass branch in `current_is_sysadmin()`. */
+    isSuperAdmin: boolean;
+}
+/**
+ * Per-request tenant context. Populated by Express middleware once the JWT
+ * is validated; consumed by `withTenantTx` and any helper that needs to
+ * know "who is the caller" without re-deriving from the request object.
+ */
+export declare const tenantContext: AsyncLocalStorage<TenantContext>;
+/**
+ * Run `fn` inside the given tenant scope. The AsyncLocalStorage scope
+ * survives across async boundaries (Promises, setTimeout, etc.), so any
+ * `withTenantTx` call inside `fn` — directly or through any depth of
+ * async helpers — picks up `ctx`.
+ *
+ * Wrap `next()` from an Express middleware to establish per-request scope:
+ *
+ *     app.use((req, res, next) => {
+ *       runWithTenantContext({ orgId, isSuperAdmin }, () => next());
+ *     });
+ */
+export declare function runWithTenantContext<T>(ctx: TenantContext, fn: () => T): T;
+/** Read the current tenant context. Returns undefined outside an
+ *  `runWithTenantContext` scope (e.g. background workers, migrations). */
+export declare function getTenantContext(): TenantContext | undefined;
+/**
+ * Assert that the current code is running inside a tenant scope. Callers
+ * that legitimately need to refuse to operate without one (e.g. handlers
+ * that touch FORCE'd RLS tables) can use this instead of relying on the
+ * downstream "permission denied" error to surface the bug.
+ */
+export declare function requireTenantContext(): TenantContext;
+/**
+ * Open a transaction with RLS GUCs SET LOCAL from the current
+ * AsyncLocalStorage tenant context, then invoke `fn(tx)`.
+ *
+ * - When called outside a tenant scope (e.g. from a background job that
+ *   doesn't have a caller identity), the transaction is opened with both
+ *   GUCs cleared — RLS policies will return zero rows on FORCE'd tables.
+ *   Callers that need a sysadmin-equivalent scope should wrap themselves in
+ *   `runWithTenantContext({ isSuperAdmin: true }, …)` explicitly.
+ *
+ * - Uses `set_config(key, value, true)` (the boolean = `is_local`, i.e.
+ *   transaction-scoped). Equivalent to `SET LOCAL` but takes the value as
+ *   a parameter, which is what we want — Drizzle's `sql` template binds the
+ *   value safely so an attacker-controlled `orgId` can't escape the quoting.
+ *
+ * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle
+ *   handles the COMMIT/ROLLBACK for us).
+ */
+export declare function withTenantTx<T>(fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>): Promise<T>;

package/lib/database/tenancy.js

@@ -0,0 +1,143 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tenantContext = void 0;
+exports.runWithTenantContext = runWithTenantContext;
+exports.getTenantContext = getTenantContext;
+exports.requireTenantContext = requireTenantContext;
+exports.withTenantTx = withTenantTx;
+/**
+ * Tenant-context plumbing for Postgres row-level security.
+ *
+ * Background: postgres-init.sql installs RLS policies on every user-data
+ * table that consult two session GUCs — `app.org_id` and `app.is_sysadmin`.
+ * Today the tables are in owner-bypass mode (the connection user owns them,
+ * Postgres lets owners skip RLS), so the policies don't actually enforce.
+ * Once we flip a table to `FORCE ROW LEVEL SECURITY`, every query against
+ * it must run inside a transaction that has SET LOCAL'd both GUCs — or it
+ * returns zero rows for non-sysadmins (and may fail to write for any caller).
+ *
+ * This module is the seam.
+ *
+ *   1. `tenantContext` (AsyncLocalStorage) carries `{orgId, isSuperAdmin}`
+ *      down the call chain without prop-drilling. Set once at the request
+ *      boundary; readable from anywhere.
+ *
+ *   2. `withTenantTx(fn)` opens a transaction, SET LOCAL's both GUCs from
+ *      the surrounding context, then invokes `fn(tx)`. Services migrate one
+ *      at a time by wrapping their existing drizzle calls in this helper —
+ *      `db.select().from(...)` becomes `withTenantTx(tx => tx.select().from(...))`.
+ *
+ *   3. `runWithTenantContext(ctx, fn)` is the Express-middleware-side
+ *      bookend that establishes the AsyncLocalStorage scope for the request.
+ *
+ * Migration order (see docs/plans/f-1-0-rls-enforcement.md):
+ *   - First adopters: newly-written services (dashboard, alert-destination)
+ *     where the change is mechanical.
+ *   - Then high-write services (plugin, pipeline). Soak each one before
+ *     flipping the underlying table to FORCE.
+ *   - admin_audit_log uses a sysadmin-only policy — sysadmin paths must
+ *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.
+ */
+const node_async_hooks_1 = require("node:async_hooks");
+const api_core_1 = require("@pipeline-builder/api-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const postgres_connection_1 = require("./postgres-connection");
+const logger = (0, api_core_1.createLogger)('tenant-context');
+function getContextMode() {
+    const raw = (process.env.RLS_CONTEXT_MODE || 'warn').toLowerCase();
+    return raw === 'silent' || raw === 'strict' ? raw : 'warn';
+}
+/**
+ * Per-request tenant context. Populated by Express middleware once the JWT
+ * is validated; consumed by `withTenantTx` and any helper that needs to
+ * know "who is the caller" without re-deriving from the request object.
+ */
+exports.tenantContext = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Run `fn` inside the given tenant scope. The AsyncLocalStorage scope
+ * survives across async boundaries (Promises, setTimeout, etc.), so any
+ * `withTenantTx` call inside `fn` — directly or through any depth of
+ * async helpers — picks up `ctx`.
+ *
+ * Wrap `next()` from an Express middleware to establish per-request scope:
+ *
+ *     app.use((req, res, next) => {
+ *       runWithTenantContext({ orgId, isSuperAdmin }, () => next());
+ *     });
+ */
+function runWithTenantContext(ctx, fn) {
+    return exports.tenantContext.run(ctx, fn);
+}
+/** Read the current tenant context. Returns undefined outside an
+ *  `runWithTenantContext` scope (e.g. background workers, migrations). */
+function getTenantContext() {
+    return exports.tenantContext.getStore();
+}
+/**
+ * Assert that the current code is running inside a tenant scope. Callers
+ * that legitimately need to refuse to operate without one (e.g. handlers
+ * that touch FORCE'd RLS tables) can use this instead of relying on the
+ * downstream "permission denied" error to surface the bug.
+ */
+function requireTenantContext() {
+    const ctx = exports.tenantContext.getStore();
+    if (!ctx) {
+        throw new Error('requireTenantContext: no tenant scope active. Wrap your handler/worker in '
+            + 'runWithTenantContext({ orgId, isSuperAdmin }, ...) before any DB call.');
+    }
+    return ctx;
+}
+/**
+ * Open a transaction with RLS GUCs SET LOCAL from the current
+ * AsyncLocalStorage tenant context, then invoke `fn(tx)`.
+ *
+ * - When called outside a tenant scope (e.g. from a background job that
+ *   doesn't have a caller identity), the transaction is opened with both
+ *   GUCs cleared — RLS policies will return zero rows on FORCE'd tables.
+ *   Callers that need a sysadmin-equivalent scope should wrap themselves in
+ *   `runWithTenantContext({ isSuperAdmin: true }, …)` explicitly.
+ *
+ * - Uses `set_config(key, value, true)` (the boolean = `is_local`, i.e.
+ *   transaction-scoped). Equivalent to `SET LOCAL` but takes the value as
+ *   a parameter, which is what we want — Drizzle's `sql` template binds the
+ *   value safely so an attacker-controlled `orgId` can't escape the quoting.
+ *
+ * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle
+ *   handles the COMMIT/ROLLBACK for us).
+ */
+async function withTenantTx(fn) {
+    const ctx = exports.tenantContext.getStore();
+    if (!ctx) {
+        // Surface the bug instead of silently SET'ing empty GUCs. The default
+        // mode ('warn') logs an actionable trace so the bad call site is easy
+        // to find; production deployments that have finished the audit can set
+        // RLS_CONTEXT_MODE=strict to fail-fast at the call site (better stack
+        // trace than the Postgres "permission denied" that would otherwise
+        // surface from FORCE'd RLS).
+        const mode = getContextMode();
+        if (mode === 'strict') {
+            throw new Error('withTenantTx called outside a tenant scope. Wrap your handler/worker '
+                + 'in runWithTenantContext({ orgId, isSuperAdmin }, ...) before invoking '
+                + 'any service that touches RLS-enforced tables.');
+        }
+        if (mode === 'warn') {
+            // Include a synthetic stack so the offending call site is in the log.
+            logger.warn('withTenantTx called outside a tenant scope; RLS GUCs will be empty', {
+                stack: new Error('tenant-context missing').stack,
+            });
+        }
+    }
+    const orgId = ctx?.orgId ?? '';
+    const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';
+    return postgres_connection_1.db.transaction(async (tx) => {
+        // SET LOCAL via set_config() so the values are transaction-scoped (auto-
+        // released on COMMIT/ROLLBACK). The driver binds the values as parameters,
+        // so a hostile org_id can't break out of the GUC syntax.
+        await tx.execute((0, drizzle_orm_1.sql) `SELECT set_config('app.org_id', ${orgId}, true)`);
+        await tx.execute((0, drizzle_orm_1.sql) `SELECT set_config('app.is_sysadmin', ${isSuperAdmin}, true)`);
+        return fn(tx);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../../src/database/tenancy.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAsFtC,oDAEC;AAID,4CAEC;AAQD,oDASC;AAoBD,oCAuCC;AAxKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,uDAAqD;AACrD,yDAA0D;AAC1D,6CAAkC;AAClC,+DAA2C;AAE3C,MAAM,MAAM,GAAG,IAAA,uBAAY,EAAC,gBAAgB,CAAC,CAAC;AAa9C,SAAS,cAAc;IACrB,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;IACnE,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;AAC7D,CAAC;AAUD;;;;GAIG;AACU,QAAA,aAAa,GAAG,IAAI,oCAAiB,EAAiB,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,SAAgB,oBAAoB,CAAI,GAAkB,EAAE,EAAW;IACrE,OAAO,qBAAa,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AACpC,CAAC;AAED;0EAC0E;AAC1E,SAAgB,gBAAgB;IAC9B,OAAO,qBAAa,CAAC,QAAQ,EAAE,CAAC;AAClC,CAAC;AAED;;;;;GAKG;AACH,SAAgB,oBAAoB;IAClC,MAAM,GAAG,GAAG,qBAAa,CAAC,QAAQ,EAAE,CAAC;IACrC,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,4EAA4E;cAC1E,wEAAwE,CAC3E,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACI,KAAK,UAAU,YAAY,CAChC,EAA2E;IAE3E,MAAM,GAAG,GAAG,qBAAa,CAAC,QAAQ,EAAE,CAAC;IAErC,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,sEAAsE;QACtE,sEAAsE;QACtE,uEAAuE;QACvE,sEAAsE;QACtE,mEAAmE;QACnE,6BAA6B;QAC7B,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC;QAC9B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACb,uEAAuE;kBACrE,wEAAwE;kBACxE,+CAA+C,CAClD,CAAC;QACJ,CAAC;QACD,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YACpB,sEAAsE;YACtE,MAAM,CAAC,IAAI,CAAC,oEAAoE,EAAE;gBAChF,KAAK,EAAE,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC,KAAK;aACjD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAG,GAAG,EAAE,KAAK,IAAI,EAAE,CAAC;IAC/B,MAAM,YAAY,GAAG,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IAE1D,OAAO,wBAAE,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;QACjC,yEAAyE;QACzE,2EAA2E;QAC3E,yDAAyD;QACzD,MAAM,EAAE,CAAC,OAAO,CAAC,IAAA,iBAAG,EAAA,mCAAmC,KAAK,SAAS,CAAC,CAAC;QACvE,MAAM,EAAE,CAAC,OAAO,CAAC,IAAA,iBAAG,EAAA,wCAAwC,YAAY,SAAS,CAAC,CAAC;QACnF,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Tenant-context plumbing for Postgres row-level security.\n *\n * Background: postgres-init.sql installs RLS policies on every user-data\n * table that consult two session GUCs — `app.org_id` and `app.is_sysadmin`.\n * Today the tables are in owner-bypass mode (the connection user owns them,\n * Postgres lets owners skip RLS), so the policies don't actually enforce.\n * Once we flip a table to `FORCE ROW LEVEL SECURITY`, every query against\n * it must run inside a transaction that has SET LOCAL'd both GUCs — or it\n * returns zero rows for non-sysadmins (and may fail to write for any caller).\n *\n * This module is the seam.\n *\n *   1. `tenantContext` (AsyncLocalStorage) carries `{orgId, isSuperAdmin}`\n *      down the call chain without prop-drilling. Set once at the request\n *      boundary; readable from anywhere.\n *\n *   2. `withTenantTx(fn)` opens a transaction, SET LOCAL's both GUCs from\n *      the surrounding context, then invokes `fn(tx)`. Services migrate one\n *      at a time by wrapping their existing drizzle calls in this helper —\n *      `db.select().from(...)` becomes `withTenantTx(tx => tx.select().from(...))`.\n *\n *   3. `runWithTenantContext(ctx, fn)` is the Express-middleware-side\n *      bookend that establishes the AsyncLocalStorage scope for the request.\n *\n * Migration order (see docs/plans/f-1-0-rls-enforcement.md):\n *   - First adopters: newly-written services (dashboard, alert-destination)\n *     where the change is mechanical.\n *   - Then high-write services (plugin, pipeline). Soak each one before\n *     flipping the underlying table to FORCE.\n *   - admin_audit_log uses a sysadmin-only policy — sysadmin paths must\n *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { db } from './postgres-connection';\n\nconst logger = createLogger('tenant-context');\n\n/**\n * Behavior when `withTenantTx` is invoked outside any `runWithTenantContext`\n * scope. Defaults to 'warn' so existing code paths that haven't been audited\n * keep working but surface in logs. Set RLS_CONTEXT_MODE=strict to flip\n * production into fail-fast — recommended once the codebase is fully audited.\n *\n * 'silent' is kept for tests and scripts that intentionally enter the DB\n * without context (e.g. integration test setup that runs as the connection\n * owner before any tenant is provisioned).\n */\ntype ContextMode = 'silent' | 'warn' | 'strict';\nfunction getContextMode(): ContextMode {\n  const raw = (process.env.RLS_CONTEXT_MODE || 'warn').toLowerCase();\n  return raw === 'silent' || raw === 'strict' ? raw : 'warn';\n}\n\nexport interface TenantContext {\n  /** Caller's org. Undefined for un-authenticated / system jobs. */\n  orgId?: string;\n  /** True when the caller is a sysadmin (system-org admin). Bypasses RLS\n   *  policies via the sysadmin-bypass branch in `current_is_sysadmin()`. */\n  isSuperAdmin: boolean;\n}\n\n/**\n * Per-request tenant context. Populated by Express middleware once the JWT\n * is validated; consumed by `withTenantTx` and any helper that needs to\n * know \"who is the caller\" without re-deriving from the request object.\n */\nexport const tenantContext = new AsyncLocalStorage<TenantContext>();\n\n/**\n * Run `fn` inside the given tenant scope. The AsyncLocalStorage scope\n * survives across async boundaries (Promises, setTimeout, etc.), so any\n * `withTenantTx` call inside `fn` — directly or through any depth of\n * async helpers — picks up `ctx`.\n *\n * Wrap `next()` from an Express middleware to establish per-request scope:\n *\n *     app.use((req, res, next) => {\n *       runWithTenantContext({ orgId, isSuperAdmin }, () => next());\n *     });\n */\nexport function runWithTenantContext<T>(ctx: TenantContext, fn: () => T): T {\n  return tenantContext.run(ctx, fn);\n}\n\n/** Read the current tenant context. Returns undefined outside an\n *  `runWithTenantContext` scope (e.g. background workers, migrations). */\nexport function getTenantContext(): TenantContext | undefined {\n  return tenantContext.getStore();\n}\n\n/**\n * Assert that the current code is running inside a tenant scope. Callers\n * that legitimately need to refuse to operate without one (e.g. handlers\n * that touch FORCE'd RLS tables) can use this instead of relying on the\n * downstream \"permission denied\" error to surface the bug.\n */\nexport function requireTenantContext(): TenantContext {\n  const ctx = tenantContext.getStore();\n  if (!ctx) {\n    throw new Error(\n      'requireTenantContext: no tenant scope active. Wrap your handler/worker in '\n      + 'runWithTenantContext({ orgId, isSuperAdmin }, ...) before any DB call.',\n    );\n  }\n  return ctx;\n}\n\n/**\n * Open a transaction with RLS GUCs SET LOCAL from the current\n * AsyncLocalStorage tenant context, then invoke `fn(tx)`.\n *\n * - When called outside a tenant scope (e.g. from a background job that\n *   doesn't have a caller identity), the transaction is opened with both\n *   GUCs cleared — RLS policies will return zero rows on FORCE'd tables.\n *   Callers that need a sysadmin-equivalent scope should wrap themselves in\n *   `runWithTenantContext({ isSuperAdmin: true }, …)` explicitly.\n *\n * - Uses `set_config(key, value, true)` (the boolean = `is_local`, i.e.\n *   transaction-scoped). Equivalent to `SET LOCAL` but takes the value as\n *   a parameter, which is what we want — Drizzle's `sql` template binds the\n *   value safely so an attacker-controlled `orgId` can't escape the quoting.\n *\n * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle\n *   handles the COMMIT/ROLLBACK for us).\n */\nexport async function withTenantTx<T>(\n  fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>,\n): Promise<T> {\n  const ctx = tenantContext.getStore();\n\n  if (!ctx) {\n    // Surface the bug instead of silently SET'ing empty GUCs. The default\n    // mode ('warn') logs an actionable trace so the bad call site is easy\n    // to find; production deployments that have finished the audit can set\n    // RLS_CONTEXT_MODE=strict to fail-fast at the call site (better stack\n    // trace than the Postgres \"permission denied\" that would otherwise\n    // surface from FORCE'd RLS).\n    const mode = getContextMode();\n    if (mode === 'strict') {\n      throw new Error(\n        'withTenantTx called outside a tenant scope. Wrap your handler/worker '\n        + 'in runWithTenantContext({ orgId, isSuperAdmin }, ...) before invoking '\n        + 'any service that touches RLS-enforced tables.',\n      );\n    }\n    if (mode === 'warn') {\n      // Include a synthetic stack so the offending call site is in the log.\n      logger.warn('withTenantTx called outside a tenant scope; RLS GUCs will be empty', {\n        stack: new Error('tenant-context missing').stack,\n      });\n    }\n  }\n\n  const orgId = ctx?.orgId ?? '';\n  const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';\n\n  return db.transaction(async (tx) => {\n    // SET LOCAL via set_config() so the values are transaction-scoped (auto-\n    // released on COMMIT/ROLLBACK). The driver binds the values as parameters,\n    // so a hostile org_id can't break out of the GUC syntax.\n    await tx.execute(sql`SELECT set_config('app.org_id', ${orgId}, true)`);\n    await tx.execute(sql`SELECT set_config('app.is_sysadmin', ${isSuperAdmin}, true)`);\n    return fn(tx);\n  });\n}\n"]}