@pipeline-builder/pipeline-data 3.4.97 → 3.4.98

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

@@ -1,5 +1,27 @@
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { Pool, type PoolClient } from 'pg';
+/**
+ * Resolve the pg TLS/SSL config from an explicit option or the environment,
+ * following the same env-tunable pattern as the pool sizing above.
+ *
+ * Precedence:
+ *   1. An explicit `options.ssl` (constructor arg) always wins — including an
+ *      explicit `false` to force plaintext.
+ *   2. `DB_SSL` (`true`/`1` on, `false`/`0` off) or Postgres' standard
+ *      `PGSSLMODE` (`disable` = off, any other mode = on).
+ *   3. Default: ON in production (RDS connections must be encrypted in transit),
+ *      OFF everywhere else so a local Postgres without TLS keeps working.
+ *
+ * When enabled, `rejectUnauthorized` follows `DB_SSL_REJECT_UNAUTHORIZED`
+ * (default `false`): AWS RDS presents a cert signed by the RDS CA, which is not
+ * in Node's default trust store unless the CA bundle is mounted, so certificate
+ * VERIFICATION is opt-in to avoid breaking a stock RDS deploy — the channel is
+ * still ENCRYPTED. Set `DB_SSL_REJECT_UNAUTHORIZED=true` once the RDS CA bundle
+ * is wired to get full verification.
+ */
+export declare function getSslConfig(explicit?: ConnectionOptions['ssl']): boolean | {
+    rejectUnauthorized: boolean;
+};
 /**
  * Database connection statistics for monitoring
  */
@@ -94,7 +116,13 @@ export declare class Connection {
      */
     getStats(): ConnectionStats;
     /**
-     * Executes a database transaction
+     * Executes a database transaction.
+     *
+     * DEAD PATH — no production callers. Every real transaction goes through
+     * `withTenantTx` (tenancy.ts), which now sets `statement_timeout` alongside
+     * the RLS GUCs, so THIS wrapper's `SET LOCAL statement_timeout` guard is no
+     * longer the server-side timeout mechanism. `getClient()` below is likewise
+     * caller-less. Both are safe to remove; kept for now to avoid churn.
      *
      * @param callback - Function to execute within the transaction
      * @returns Result of the transaction

package/lib/database/postgres-connection.js

@@ -19,6 +19,43 @@ function parseIntEnv(value, fallback) {
 }
 /** Detect Lambda environment for pool-size tuning */
 const isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;
+/**
+ * Resolve the pg TLS/SSL config from an explicit option or the environment,
+ * following the same env-tunable pattern as the pool sizing above.
+ *
+ * Precedence:
+ *   1. An explicit `options.ssl` (constructor arg) always wins — including an
+ *      explicit `false` to force plaintext.
+ *   2. `DB_SSL` (`true`/`1` on, `false`/`0` off) or Postgres' standard
+ *      `PGSSLMODE` (`disable` = off, any other mode = on).
+ *   3. Default: ON in production (RDS connections must be encrypted in transit),
+ *      OFF everywhere else so a local Postgres without TLS keeps working.
+ *
+ * When enabled, `rejectUnauthorized` follows `DB_SSL_REJECT_UNAUTHORIZED`
+ * (default `false`): AWS RDS presents a cert signed by the RDS CA, which is not
+ * in Node's default trust store unless the CA bundle is mounted, so certificate
+ * VERIFICATION is opt-in to avoid breaking a stock RDS deploy — the channel is
+ * still ENCRYPTED. Set `DB_SSL_REJECT_UNAUTHORIZED=true` once the RDS CA bundle
+ * is wired to get full verification.
+ */
+export function getSslConfig(explicit) {
+    if (explicit !== undefined)
+        return explicit;
+    const dbSsl = process.env.DB_SSL?.toLowerCase();
+    const sslMode = process.env.PGSSLMODE?.toLowerCase();
+    let enabled;
+    if (dbSsl === 'true' || dbSsl === '1')
+        enabled = true;
+    else if (dbSsl === 'false' || dbSsl === '0')
+        enabled = false;
+    else if (sslMode)
+        enabled = sslMode !== 'disable';
+    else
+        enabled = process.env.NODE_ENV === 'production';
+    if (!enabled)
+        return false;
+    return { rejectUnauthorized: process.env.DB_SSL_REJECT_UNAUTHORIZED === 'true' };
+}
 function getDatabaseConfig() {
     // Lambda: small pool (each invocation is short-lived, many concurrent instances)
     // ECS/long-running: larger pool for sustained concurrency
@@ -81,7 +118,10 @@ export class Connection {
             enableAutoRetry: options.enableAutoRetry ?? true,
             maxRetries: options.maxRetries ?? parseInt(process.env.DB_MAX_RETRIES || '3', 10),
             retryDelay: options.retryDelay ?? parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10),
-            ssl: options.ssl ?? false,
+            // Env-driven TLS: on-by-default in production, env-enableable elsewhere.
+            // getInstance() is normally called with no options, so this is the only
+            // place production RDS connections pick up SSL (formerly hard-coded off).
+            ssl: getSslConfig(options.ssl),
         };
         // Initialize retry strategy
         this.retryStrategy = new ConnectionRetryStrategy({
@@ -173,7 +213,13 @@ export class Connection {
         };
     }
     /**
-     * Executes a database transaction
+     * Executes a database transaction.
+     *
+     * DEAD PATH — no production callers. Every real transaction goes through
+     * `withTenantTx` (tenancy.ts), which now sets `statement_timeout` alongside
+     * the RLS GUCs, so THIS wrapper's `SET LOCAL statement_timeout` guard is no
+     * longer the server-side timeout mechanism. `getClient()` below is likewise
+     * caller-less. Both are safe to remove; kept for now to avoid churn.
      *
      * @param callback - Function to execute within the transaction
      * @returns Result of the transaction
@@ -514,4 +560,4 @@ async function closeReplicaPool() {
         _replica = null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postgres-connection.js","sourceRoot":"","sources":["../../src/database/postgres-connection.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAE,IAAI,EAAoC,MAAM,IAAI,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;AAExC;;;GAGG;AACH,SAAS,WAAW,CAAC,KAAyB,EAAE,QAAgB;IAC9D,IAAI,CAAC,KAAK;QAAE,OAAO,QAAQ,CAAC;IAC5B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACnC,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC;AAClD,CAAC;AAED,qDAAqD;AACrD,MAAM,QAAQ,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC;AAExD,SAAS,iBAAiB;IACxB,iFAAiF;IACjF,0DAA0D;IAC1D,MAAM,eAAe,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1C,MAAM,kBAAkB,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAEpD,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU;QACvC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC;QAC5C,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,kBAAkB;QACpD,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU;QACvC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAY,CAAC,CAAC,CAAC,EAAE,CAAC;QACrK,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,eAAe,CAAC;QAC5E,iBAAiB,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,2BAA2B,EAAE,kBAAkB,CAAC;QAC3F,uBAAuB,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,iCAAiC,EAAE,IAAI,CAAC;KAC1F,CAAC;AACJ,CAAC;AA+BD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,UAAU;IACb,MAAM,CAAC,QAAQ,GAAsB,IAAI,CAAC;IAElD;;OAEG;IACa,EAAE,CAA6B;IAE9B,IAAI,CAAO;IACX,OAAO,CAA8B;IACrC,aAAa,CAA0B;IAChD,cAAc,GAAG,KAAK,CAAC;IAE/B;;;;;;OAMG;IACH,YAAoB,UAA6B,EAAE;QACjD,IAAI,CAAC,OAAO,GAAG;YACb,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,IAAI;YAC5C,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,IAAI;YAChD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,GAAG,EAAE,EAAE,CAAC;YACjF,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,MAAM,EAAE,EAAE,CAAC;YACvF,GAAG,EAAE,OAAO,CAAC,GAAG,IAAI,KAAK;SAC1B,CAAC;QAEF,4BAA4B;QAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,uBAAuB,CAAC;YAC/C,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;YACnC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;SACnC,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;YAEnC,MAAM,UAAU,GAAe;gBAC7B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,GAAG,EAAE,MAAM,CAAC,WAAW;gBACvB,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;gBAC3C,uBAAuB,EAAE,MAAM,CAAC,uBAAuB;gBACvD,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG;gBACrB,eAAe,EAAE,IAAI;aACtB,CAAC;YAEF,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;YACjC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAE1B,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YAEzC,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC/B,MAAM,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;gBAC5D,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,2CAA2C,EAAE,KAAK,CAAC,CAAC;YACjE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,WAAW,CAAC,OAA2B;QACnD,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YACzB,UAAU,CAAC,QAAQ,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,UAAU,CAAC,QAAQ,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,gBAAyB,IAAI;QACrD,IAAI,UAAU,CAAC,QAAQ,IAAI,aAAa,EAAE,CAAC;YACzC,MAAM,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACpC,CAAC;QACD,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,cAAc;QACzB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACzC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAC9C,MAAM,CAAC,OAAO,EAAE,CAAC;YAEjB,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC/B,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;YACrD,CAAC;YAED,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,kCAAkC,EAAE,KAAK,CAAC,CAAC;YACxD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,QAAQ;QACb,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU;YAChC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS;YAC9B,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY;SACrC,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACI,KAAK,CAAC,WAAW,CACtB,QAAmD,EACnD,YAAoB,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE,KAAK,CAAC;QAE7E,IAAI,KAAoC,CAAC;QACzC,4EAA4E;QAC5E,4EAA4E;QAC5E,6EAA6E;QAC7E,uCAAuC;QACvC,MAAM,eAAe,GAAoB,KAAK,EAAE,EAAE,EAAE,EAAE;YACpD,sEAAsE;YACtE,6EAA6E;YAC7E,qDAAqD;YACrD,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA,0CAA0C,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAC1F,OAAO,QAAQ,CAAC,EAAE,CAAC,CAAC;QACtB,CAAC,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,eAAe,CAAe,CAAC;QACrE,MAAM,cAAc,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YACtD,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,6BAA6B,SAAS,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QACrG,CAAC,CAAC,CAAC;QACH,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;QACzD,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAM,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,KAAK,CAAC,SAAS;QACpB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,KAAK,CAAC,UAAkB,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,IAAI,CAAC;QACrF,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;YACnD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAE3B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC/B,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;gBACnD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC9B,MAAM,CAAC,IAAI,CAAC,uBAAuB,KAAK,CAAC,UAAU,WAAW,KAAK,CAAC,SAAS,cAAc,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;YACnH,CAAC;YAED,sCAAsC;YACtC,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACrC,MAAM,cAAc,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAC/C,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC,EAAE,OAAO,CAAC,CACzE,CAAC;YAEF,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC;YAEnD,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC/B,MAAM,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;YACzD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,KAAK,CAAC,CAAC;YAC1D,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC9B,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,SAAS;QACd,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED;;OAEG;IACK,kBAAkB;QACxB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;YAC5B,MAAM,CAAC,KAAK,CAAC,kCAAkC,EAAE,GAAG,CAAC,CAAC;YAEtD,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;gBAC/F,KAAK,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE;oBACjG,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,QAAQ,CAAC,CAAC;gBACpD,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YAC3B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,iCAAiC;YAE7D,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC/B,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;YACtD,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YAC1B,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC/B,MAAM,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,MAAkB;QAC5C,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE;YACrC,IAAI,EAAE,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE;YACrC,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,WAAW,EAAE,MAAM,CAAC,GAAG;YACvB,aAAa,EAAE,MAAM,CAAC,iBAAiB;YACvC,mBAAmB,EAAE,MAAM,CAAC,uBAAuB;YACnD,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;SACzC,CAAC,CAAC;IACL,CAAC;;AAGH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,6DAA6D;AAC7D,IAAI,WAAW,GAAsC,IAAI,CAAC;AAE1D;;;GAGG;AACH,SAAS,aAAa;IACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,WAAW,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,IAAI,KAAK,CAAC,EAAgC,EAAE;IAC5D,GAAG,CAAC,CAAC,EAAE,IAAqB;QAC1B,MAAM,QAAQ,GAAG,aAAa,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,QAAQ,CAAC,IAA6B,CAAC,CAAC;QACtD,0DAA0D;QAC1D,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;YAChC,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,UAAU,CAAC,WAAW,EAAE,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,MAAM,UAAU,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;IAC5C,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;IACzB,MAAM,gBAAgB,EAAE,CAAC,CAAC,gEAAgE;IAC1F,WAAW,GAAG,IAAI,CAAC,CAAC,sBAAsB;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,MAAM,UAAU,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,UAAU,CAAC,cAAc,EAAE,CAAC;AACrC,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB;IACtC,MAAM,UAAU,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;IAC5C,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,cAAc,EAAE,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;AACH,CAAC;AAyBD,IAAI,QAAQ,GAAuB,IAAI,CAAC;AAExC,SAAS,gBAAgB;IACvB,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC;IAChD,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IAC9B,MAAM,GAAG,GAAG,iBAAiB,EAAE,CAAC;IAChC,OAAO;QACL,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,GAAG,CAAC,IAAI,CAAC;QACxD,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,GAAG,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,GAAG,CAAC,WAAW,CAAC;QAClE,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;QACxC,uBAAuB,EAAE,GAAG,CAAC,uBAAuB;QACpD,eAAe,EAAE,IAAI;KACtB,CAAC;AACJ,CAAC;AAED,SAAS,cAAc;IACrB,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,MAAM,GAAG,GAAG,gBAAgB,EAAE,CAAC;IAC/B,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACtF,QAAQ,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;IACnD,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IACjF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,EAAgC,EAAE;IACnE,GAAG,CAAC,CAAC,EAAE,IAAqB;QAC1B,MAAM,OAAO,GAAG,cAAc,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,IAA2B,CAAC,CAAC;QAClD,IAAI,OAAO,KAAK,KAAK,UAAU;YAAE,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3D,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAC,CAAC;AAEH;wEACwE;AACxE,KAAK,UAAU,gBAAgB;IAC7B,IAAI,CAAC,QAAQ;QAAE,OAAO;IACtB,IAAI,CAAC;QACH,MAAM,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QAC1B,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;IAC1C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,4BAA4B,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1G,CAAC;YAAS,CAAC;QACT,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC;AACH,CAAC","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, type PoolConfig, type PoolClient } from 'pg';\nimport { schema } from './drizzle-schema.js';\nimport { ConnectionRetryStrategy } from './retry-strategy.js';\n\nconst logger = createLogger('database');\n\n/**\n * Get database configuration from environment variables\n * Note: Uses environment variables directly to avoid circular dependency with pipeline-core\n */\nfunction parseIntEnv(value: string | undefined, fallback: number): number {\n  if (!value) return fallback;\n  const parsed = parseInt(value, 10);\n  return Number.isNaN(parsed) ? fallback : parsed;\n}\n\n/** Detect Lambda environment for pool-size tuning */\nconst isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;\n\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      // `SET LOCAL statement_timeout = ${n}` parameterizes to `= $1`, which\n      // Postgres rejects for SET — use set_config (accepts a bound value, is_local\n      // = true ⇒ transaction-scoped), matching tenancy.ts.\n      await tx.execute(sql`SELECT set_config('statement_timeout', ${String(timeoutMs)}, true)`);\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  await closeReplicaPool(); // tear down the read-replica pool too (services only call this)\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"]}
+//# 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, type PoolConfig, type PoolClient } from 'pg';\nimport { schema } from './drizzle-schema.js';\nimport { ConnectionRetryStrategy } from './retry-strategy.js';\n\nconst logger = createLogger('database');\n\n/**\n * Get database configuration from environment variables\n * Note: Uses environment variables directly to avoid circular dependency with pipeline-core\n */\nfunction parseIntEnv(value: string | undefined, fallback: number): number {\n  if (!value) return fallback;\n  const parsed = parseInt(value, 10);\n  return Number.isNaN(parsed) ? fallback : parsed;\n}\n\n/** Detect Lambda environment for pool-size tuning */\nconst isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;\n\n/**\n * Resolve the pg TLS/SSL config from an explicit option or the environment,\n * following the same env-tunable pattern as the pool sizing above.\n *\n * Precedence:\n *   1. An explicit `options.ssl` (constructor arg) always wins — including an\n *      explicit `false` to force plaintext.\n *   2. `DB_SSL` (`true`/`1` on, `false`/`0` off) or Postgres' standard\n *      `PGSSLMODE` (`disable` = off, any other mode = on).\n *   3. Default: ON in production (RDS connections must be encrypted in transit),\n *      OFF everywhere else so a local Postgres without TLS keeps working.\n *\n * When enabled, `rejectUnauthorized` follows `DB_SSL_REJECT_UNAUTHORIZED`\n * (default `false`): AWS RDS presents a cert signed by the RDS CA, which is not\n * in Node's default trust store unless the CA bundle is mounted, so certificate\n * VERIFICATION is opt-in to avoid breaking a stock RDS deploy — the channel is\n * still ENCRYPTED. Set `DB_SSL_REJECT_UNAUTHORIZED=true` once the RDS CA bundle\n * is wired to get full verification.\n */\nexport function getSslConfig(explicit?: ConnectionOptions['ssl']): boolean | { rejectUnauthorized: boolean } {\n  if (explicit !== undefined) return explicit;\n\n  const dbSsl = process.env.DB_SSL?.toLowerCase();\n  const sslMode = process.env.PGSSLMODE?.toLowerCase();\n\n  let enabled: boolean;\n  if (dbSsl === 'true' || dbSsl === '1') enabled = true;\n  else if (dbSsl === 'false' || dbSsl === '0') enabled = false;\n  else if (sslMode) enabled = sslMode !== 'disable';\n  else enabled = process.env.NODE_ENV === 'production';\n\n  if (!enabled) return false;\n  return { rejectUnauthorized: process.env.DB_SSL_REJECT_UNAUTHORIZED === 'true' };\n}\n\nfunction getDatabaseConfig() {\n  // Lambda: small pool (each invocation is short-lived, many concurrent instances)\n  // ECS/long-running: larger pool for sustained concurrency\n  const defaultPoolSize = isLambda ? 2 : 20;\n  const defaultIdleTimeout = isLambda ? 10000 : 30000;\n\n  return {\n    host: process.env.DB_HOST || 'postgres',\n    port: parseIntEnv(process.env.DB_PORT, 5432),\n    database: process.env.DATABASE || 'pipeline_builder',\n    user: process.env.DB_USER || 'postgres',\n    password: process.env.DB_PASSWORD || (process.env.NODE_ENV === 'production' ? (() => { throw new Error('DB_PASSWORD is required in production'); })() as string : ''),\n    maxPoolSize: parseIntEnv(process.env.DRIZZLE_MAX_POOL_SIZE, defaultPoolSize),\n    idleTimeoutMillis: parseIntEnv(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS, defaultIdleTimeout),\n    connectionTimeoutMillis: parseIntEnv(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS, 5000),\n  };\n}\n\n/**\n * Database connection statistics for monitoring\n */\nexport interface ConnectionStats {\n  totalCount: number;\n  idleCount: number;\n  waitingCount: number;\n}\n\n/**\n * Options for configuring the database connection\n */\nexport interface ConnectionOptions {\n  /** Whether to enable connection logging */\n  enableLogging?: boolean;\n\n  /** Whether to automatically retry failed connections */\n  enableAutoRetry?: boolean;\n\n  /** Maximum number of connection retry attempts */\n  maxRetries?: number;\n\n  /** Delay between retry attempts in milliseconds */\n  retryDelay?: number;\n\n  /** SSL configuration */\n  ssl?: boolean | { rejectUnauthorized: boolean };\n}\n\n/**\n * Singleton database connection class.\n * Manages PostgreSQL connection pooling and Drizzle ORM instance.\n *\n * Features:\n * - Singleton pattern for single connection pool\n * - Automatic connection retry with backoff\n * - Connection health monitoring\n * - Graceful shutdown handling\n * - Comprehensive error handling\n * - Connection statistics tracking\n *\n * @example\n * ```typescript\n * import { Connection } from './connection';\n *\n * const connection = Connection.getInstance();\n * const plugins = await connection.db.select().from(schema.plugin);\n *\n * // During shutdown\n * await connection.close();\n * ```\n */\nexport class Connection {\n  private static instance: Connection | null = null;\n\n  /**\n   * Drizzle ORM database instance with schema\n   */\n  public readonly db: ReturnType<typeof drizzle>;\n\n  private readonly pool: Pool;\n  private readonly options: Required<ConnectionOptions>;\n  private readonly retryStrategy: ConnectionRetryStrategy;\n  private isShuttingDown = false;\n\n  /**\n   * Private constructor to enforce singleton pattern.\n   * Initializes PostgreSQL connection pool and Drizzle ORM instance.\n   *\n   * @param options - Optional configuration for the connection\n   * @throws {Error} If database initialization fails after all retries\n   */\n  private constructor(options: ConnectionOptions = {}) {\n    this.options = {\n      enableLogging: options.enableLogging ?? true,\n      enableAutoRetry: options.enableAutoRetry ?? true,\n      maxRetries: options.maxRetries ?? parseInt(process.env.DB_MAX_RETRIES || '3', 10),\n      retryDelay: options.retryDelay ?? parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10),\n      // Env-driven TLS: on-by-default in production, env-enableable elsewhere.\n      // getInstance() is normally called with no options, so this is the only\n      // place production RDS connections pick up SSL (formerly hard-coded off).\n      ssl: getSslConfig(options.ssl),\n    };\n\n    // Initialize retry strategy\n    this.retryStrategy = new ConnectionRetryStrategy({\n      maxRetries: this.options.maxRetries,\n      baseDelay: this.options.retryDelay,\n    });\n\n    try {\n      const config = getDatabaseConfig();\n\n      const poolConfig: PoolConfig = {\n        host: config.host,\n        port: config.port,\n        database: config.database,\n        user: config.user,\n        password: config.password,\n        max: config.maxPoolSize,\n        idleTimeoutMillis: config.idleTimeoutMillis,\n        connectionTimeoutMillis: config.connectionTimeoutMillis,\n        ssl: this.options.ssl,\n        allowExitOnIdle: true,\n      };\n\n      this.pool = new Pool(poolConfig);\n      this.setupEventHandlers();\n\n      this.db = drizzle(this.pool, { schema });\n\n      if (this.options.enableLogging) {\n        logger.info('Database connection initialized successfully');\n        this.logConnectionConfig(poolConfig);\n      }\n    } catch (error) {\n      logger.error('Failed to initialize database connection:', error);\n      throw new Error('Database initialization failed');\n    }\n  }\n\n  /**\n   * Gets the singleton instance of the Connection class.\n   * Creates a new instance if one doesn't exist.\n   *\n   * @param options - Optional configuration (only used on first call)\n   * @returns The singleton Connection instance\n   */\n  public static getInstance(options?: ConnectionOptions): Connection {\n    if (!Connection.instance) {\n      Connection.instance = new Connection(options);\n    }\n    return Connection.instance;\n  }\n\n  /**\n   * Resets the singleton instance.\n   * Useful for testing or reconfiguring the connection.\n   *\n   * @param closeExisting - Whether to close existing connection before reset\n   */\n  public static async reset(closeExisting: boolean = true): Promise<void> {\n    if (Connection.instance && closeExisting) {\n      await Connection.instance.close();\n    }\n    Connection.instance = null;\n  }\n\n  /**\n   * Tests the database connection\n   *\n   * @returns Promise that resolves to true if connection is healthy\n   */\n  public async testConnection(): Promise<boolean> {\n    try {\n      const client = await this.pool.connect();\n      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   * DEAD PATH — no production callers. Every real transaction goes through\n   * `withTenantTx` (tenancy.ts), which now sets `statement_timeout` alongside\n   * the RLS GUCs, so THIS wrapper's `SET LOCAL statement_timeout` guard is no\n   * longer the server-side timeout mechanism. `getClient()` below is likewise\n   * caller-less. Both are safe to remove; kept for now to avoid churn.\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      // `SET LOCAL statement_timeout = ${n}` parameterizes to `= $1`, which\n      // Postgres rejects for SET — use set_config (accepts a bound value, is_local\n      // = true ⇒ transaction-scoped), matching tenancy.ts.\n      await tx.execute(sql`SELECT set_config('statement_timeout', ${String(timeoutMs)}, true)`);\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  await closeReplicaPool(); // tear down the read-replica pool too (services only call this)\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"]}

package/lib/database/tenancy.js

@@ -45,6 +45,19 @@ function getContextMode() {
     // No explicit override: fail-fast in production, warn everywhere else.
     return process.env.NODE_ENV === 'production' ? 'strict' : 'warn';
 }
+/**
+ * Per-statement server-side timeout (ms) applied INSIDE every `withTenantTx`
+ * transaction, next to the RLS GUCs. `withTenantTx` is the real query path for
+ * all RLS/CRUD reads and writes, so this is where the DB-side guard belongs (the
+ * old `Connection.transaction` wrapper that set it is dead — see
+ * postgres-connection.ts). Bounds a runaway query so it can't hold a pooled
+ * connection open indefinitely. Env-configurable via `DB_STATEMENT_TIMEOUT_MS`
+ * (default 30s); set to `0` to disable the timeout.
+ */
+function getStatementTimeoutMs() {
+    const raw = parseInt(process.env.DB_STATEMENT_TIMEOUT_MS ?? '', 10);
+    return Number.isFinite(raw) && raw >= 0 ? raw : 30000;
+}
 /**
  * Per-request tenant context. Populated by Express middleware once the JWT
  * is validated; consumed by `withTenantTx` and any helper that needs to
@@ -127,13 +140,21 @@ export async function withTenantTx(fn) {
     }
     const orgId = ctx?.orgId ?? '';
     const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';
+    const statementTimeoutMs = getStatementTimeoutMs();
     return 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(sql `SELECT set_config('app.org_id', ${orgId}, true)`);
         await tx.execute(sql `SELECT set_config('app.is_sysadmin', ${isSuperAdmin}, true)`);
+        // Server-side statement timeout on the REAL query path (transaction-scoped,
+        // same set_config(is_local=true) mechanism as the RLS GUCs). `SET LOCAL
+        // statement_timeout = $1` is rejected by Postgres, so set_config with a bound
+        // value is used. A bare number is milliseconds. Skipped when disabled (0).
+        if (statementTimeoutMs > 0) {
+            await tx.execute(sql `SELECT set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`);
+        }
         return fn(tx);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../../src/database/tenancy.ts"],"names":[],"mappings":"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","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.js';\n\nconst logger = createLogger('tenant-context');\n\n/**\n * Behavior when `withTenantTx` is invoked outside any `runWithTenantContext`\n * scope. The effective default is fail-fast ('strict') in production so a\n * missing tenant scope surfaces at the bad call site instead of silently\n * running with empty RLS GUCs; outside production it defaults to 'warn' so\n * un-audited dev/test paths keep working but log an actionable trace. An\n * explicit RLS_CONTEXT_MODE env override always wins.\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?.toLowerCase();\n  if (raw === 'silent' || raw === 'warn' || raw === 'strict') return raw;\n  // No explicit override: fail-fast in production, warn everywhere else.\n  return process.env.NODE_ENV === 'production' ? 'strict' : '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  /** Org → team hierarchy: the caller's active-org parent (present only when the\n   *  active org is a team). Not used for RLS; carried so downstream side-effects\n   *  (e.g. entity-event compliance eval) can honor parent `propagateToChildren`\n   *  rules without a request in scope. */\n  parentOrgId?: string;\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../../src/database/tenancy.ts"],"names":[],"mappings":"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","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.js';\n\nconst logger = createLogger('tenant-context');\n\n/**\n * Behavior when `withTenantTx` is invoked outside any `runWithTenantContext`\n * scope. The effective default is fail-fast ('strict') in production so a\n * missing tenant scope surfaces at the bad call site instead of silently\n * running with empty RLS GUCs; outside production it defaults to 'warn' so\n * un-audited dev/test paths keep working but log an actionable trace. An\n * explicit RLS_CONTEXT_MODE env override always wins.\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?.toLowerCase();\n  if (raw === 'silent' || raw === 'warn' || raw === 'strict') return raw;\n  // No explicit override: fail-fast in production, warn everywhere else.\n  return process.env.NODE_ENV === 'production' ? 'strict' : 'warn';\n}\n\n/**\n * Per-statement server-side timeout (ms) applied INSIDE every `withTenantTx`\n * transaction, next to the RLS GUCs. `withTenantTx` is the real query path for\n * all RLS/CRUD reads and writes, so this is where the DB-side guard belongs (the\n * old `Connection.transaction` wrapper that set it is dead — see\n * postgres-connection.ts). Bounds a runaway query so it can't hold a pooled\n * connection open indefinitely. Env-configurable via `DB_STATEMENT_TIMEOUT_MS`\n * (default 30s); set to `0` to disable the timeout.\n */\nfunction getStatementTimeoutMs(): number {\n  const raw = parseInt(process.env.DB_STATEMENT_TIMEOUT_MS ?? '', 10);\n  return Number.isFinite(raw) && raw >= 0 ? raw : 30000;\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  /** Org → team hierarchy: the caller's active-org parent (present only when the\n   *  active org is a team). Not used for RLS; carried so downstream side-effects\n   *  (e.g. entity-event compliance eval) can honor parent `propagateToChildren`\n   *  rules without a request in scope. */\n  parentOrgId?: string;\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  const statementTimeoutMs = getStatementTimeoutMs();\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    // Server-side statement timeout on the REAL query path (transaction-scoped,\n    // same set_config(is_local=true) mechanism as the RLS GUCs). `SET LOCAL\n    // statement_timeout = $1` is rejected by Postgres, so set_config with a bound\n    // value is used. A bare number is milliseconds. Skipped when disabled (0).\n    if (statementTimeoutMs > 0) {\n      await tx.execute(sql`SELECT set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`);\n    }\n    return fn(tx);\n  });\n}\n"]}

package/package.json

@@ -24,7 +24,7 @@
   "dependencies": {
     "drizzle-orm": "0.45.2",
     "pg": "8.22.0",
-    "@pipeline-builder/api-core": "3.4.94"
+    "@pipeline-builder/api-core": "3.4.95"
   },
   "keywords": [
     "ci-cd",
@@ -80,7 +80,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.97",
+  "version": "3.4.98",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },