@pipeline-builder/pipeline-data 4.1.46 → 4.1.47

package/lib/database/tenancy.d.ts

@@ -33,6 +33,7 @@
  */
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { db } from './postgres-connection.js';
+import { type LagVerdict } from './read-lag.js';
 export interface TenantContext {
     /** Caller's org. Undefined for un-authenticated / system jobs. */
     orgId?: string;
@@ -51,6 +52,25 @@ export interface TenantContext {
      *  (e.g. entity-event compliance eval) can honor parent `propagateToChildren`
      *  rules without a request in scope. */
     parentOrgId?: string;
+    /**
+     * Set once this request has opened a PRIMARY transaction, i.e. may have
+     * written. Subsequent `withTenantTxRead` calls in the same request then go to
+     * the primary too, so a handler cannot read its own write off a replica that
+     * has not replayed it yet.
+     *
+     * Deliberately set by `withTenantTx` rather than by write call sites: that
+     * path is the one that can write, it needs no per-call-site discipline, and
+     * being wrong in this direction only costs a replica hit. Mutated in place on
+     * the AsyncLocalStorage store — the store is per-request, so this cannot leak
+     * between requests.
+     *
+     * SCOPE: this covers reads AFTER a write IN THE SAME REQUEST. It does NOT
+     * cover the next request (POST then a page reload issuing GET). That needs
+     * shared state — see the cross-request section of
+     * docs/plans/postgres-read-write-split.md — and must be settled before call
+     * sites are migrated in bulk.
+     */
+    mayHaveWritten?: boolean;
 }
 /**
  * Per-request tenant context. Populated by Express middleware once the JWT
@@ -92,4 +112,85 @@ export declare function getTenantContext(): TenantContext | undefined;
  * - 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>;
+export declare function withTenantTx<T>(fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>, 
+/**
+ * INTERNAL. Whether this transaction should mark the request as possibly
+ * having written. Always true for a real caller; only withTenantTxRead's
+ * primary-fallback path passes false, because a read that lands on the
+ * primary has not written. See the comment at the assignment below.
+ */
+markWritten?: boolean): Promise<T>;
+/**
+ * Why a read was or was not sent to the replica. Returned by
+ * {@link chooseReadTarget} so the decision is inspectable — and testable
+ * without a replica, which matters because the test substrate (PGlite) has no
+ * replication at all.
+ */
+export type ReadTargetReason = 
+/** No replica configured, or DB_READ_ENABLED=false. */
+'no-replica'
+/** This request already opened a primary transaction and may have written. */
+ | 'may-have-written'
+/**
+ * No tenant context. A caller outside `runWithTenantContext` has no org to
+ * scope RLS by and no watermark to compare, so it goes to the primary — where
+ * `withTenantTx`'s RLS_CONTEXT_MODE guard logs or throws. Routed to a replica
+ * instead, the same call would set `app.org_id = ''` with no diagnostic at all.
+ */
+ | 'no-context'
+/**
+ * A replica exists but its replay lag is beyond `DB_READ_MAX_LAG_SECONDS`,
+ * or is UNKNOWN (no sample yet, the sample failed, or the cached sample has
+ * gone stale). Unknown and lagging are the same decision on purpose: the
+ * circuit fails closed.
+ */
+ | 'replica-lagging'
+/** Routed to the replica. */
+ | 'replica';
+export interface ReadTarget {
+    useReplica: boolean;
+    reason: ReadTargetReason;
+}
+/**
+ * Decide where a read-only transaction should run.
+ *
+ * Pure and side-effect free on purpose: this is the whole of the routing
+ * policy, and it is the part worth testing. Replication itself cannot be
+ * reproduced locally, so the testable unit is the DECISION, not the lag.
+ *
+ * The bias is deliberate: anything uncertain resolves to the primary. A read
+ * served by the primary is merely less efficient; a read served by a stale
+ * replica is a user-visible bug nobody can reproduce.
+ */
+/** Everything about the replica that is not request-specific. */
+export interface ReadReplicaHealth {
+    /** A replica pool exists AND `DB_READ_ENABLED` is not false. */
+    available: boolean;
+    /** The lag circuit's verdict. `unknown` is treated exactly like `lagging`. */
+    lag: LagVerdict;
+}
+/**
+ * Where a read goes, and why.
+ *
+ * SYSTEM gates are checked before REQUEST gates, which matters only for the
+ * explanation — but the explanation is what an operator reads when asking why
+ * the replica is idle, and "my request wrote" is a far less useful answer than
+ * "the standby is 40 seconds behind".
+ */
+export declare function chooseReadTarget(ctx: TenantContext | undefined, health: ReadReplicaHealth): ReadTarget;
+/**
+ * Open a READ-ONLY transaction with the same RLS GUCs `withTenantTx` sets,
+ * routed to the replica when {@link chooseReadTarget} allows it.
+ *
+ * `SET TRANSACTION READ ONLY` is the guardrail, not decoration. Several queries
+ * in this codebase look like reads at the call site and are not —
+ * `SELECT … FOR UPDATE` in crud-service's setDefault, `pg_advisory_xact_lock`
+ * in pipeline-service and compliance's subscription-service. Routed to a
+ * standby those fail anyway; declaring the transaction read-only makes them
+ * fail HERE, with a clear message, including on the primary where they would
+ * otherwise succeed and quietly acquire a lock the caller did not intend.
+ *
+ * Falls back to the primary transparently, so a caller never has to ask
+ * whether a replica exists.
+ */
+export declare function withTenantTxRead<T>(fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>): Promise<T>;

package/lib/database/tenancy.js

@@ -34,9 +34,11 @@
  *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.
  */
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { createLogger, envInt } from '@pipeline-builder/api-core';
+import { createLogger, emitCounter, envInt } from '@pipeline-builder/api-core';
 import { sql } from 'drizzle-orm';
 import { db } from './postgres-connection.js';
+import { getReadDb, getReadPool } from './read-connection.js';
+import { lagVerdict, maybeSampleLag } from './read-lag.js';
 const logger = createLogger('tenant-context');
 function getContextMode() {
     const raw = process.env.RLS_CONTEXT_MODE?.toLowerCase();
@@ -102,7 +104,14 @@ export function getTenantContext() {
  * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle
  *   handles the COMMIT/ROLLBACK for us).
  */
-export async function withTenantTx(fn) {
+export async function withTenantTx(fn, 
+/**
+ * INTERNAL. Whether this transaction should mark the request as possibly
+ * having written. Always true for a real caller; only withTenantTxRead's
+ * primary-fallback path passes false, because a read that lands on the
+ * primary has not written. See the comment at the assignment below.
+ */
+markWritten = true) {
     const ctx = tenantContext.getStore();
     if (!ctx) {
         // Surface the bug instead of silently SET'ing empty GUCs. The default
@@ -127,6 +136,22 @@ export async function withTenantTx(fn) {
     const orgId = ctx?.orgId ?? '';
     const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';
     const statementTimeoutMs = getStatementTimeoutMs();
+    // This transaction runs on the PRIMARY and may write, so any later read in
+    // this request must stay on the primary too. Set before the transaction opens
+    // rather than after it commits: a read issued concurrently from the same
+    // handler would otherwise race the flag.
+    //
+    // `markWritten: false` is passed ONLY by withTenantTxRead's fallback path,
+    // and it is not an optimisation — without it the feature defeats itself. That
+    // path runs on the primary, so it would set this flag, which api-server's
+    // middleware reads after the response to set the Redis write pin. A purely
+    // READ-ONLY request would therefore pin its whole org to the primary for the
+    // pin TTL, every time, and since reads fall back whenever no replica is
+    // configured (the shipping default) every org would be permanently pinned.
+    // The flag means "this request may have WRITTEN", not "this request touched
+    // the primary", and the difference is the whole read-offload benefit.
+    if (ctx && markWritten)
+        ctx.mayHaveWritten = true;
     return db.transaction(async (tx) => {
         // Set every transaction-scoped GUC in a SINGLE round-trip. `set_config()`
         // returns its value, so multiple calls compose in one SELECT rather than a
@@ -149,4 +174,77 @@ export async function withTenantTx(fn) {
         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 * Every tenant table is `FORCE ROW LEVEL SECURITY`, so the policies enforce\n * even for the (owning) connection user — a query against one must run inside a\n * transaction that has SET LOCAL'd both GUCs or it returns zero rows for\n * non-sysadmins (and may fail to write for any caller). The cross-org plugin\n * ecosystem catalog tables carry a permissive app-role policy instead.\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:\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, envInt } 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 ms = envInt('DB_STATEMENT_TIMEOUT_MS', 30_000);\n  return ms >= 0 ? ms : 30_000;\n}\n\nexport interface TenantContext {\n  /** Caller's org. Undefined for un-authenticated / system jobs. */\n  orgId?: string;\n  /** Caller's user id. Not used for RLS — Postgres policies are org-grained,\n   *  with no per-user session GUC — but carried so app-layer predicates with a\n   *  PER-USER rung (pipeline templates' `private` visibility) can resolve \"who\n   *  is asking\" on paths that have nowhere to pass it, notably CrudService's\n   *  `writeConditions`. Absent for system jobs, which is the fail-closed case:\n   *  no viewer ⇒ no private rows. */\n  userId?: 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 * 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 every transaction-scoped GUC in a SINGLE round-trip. `set_config()`\n    // returns its value, so multiple calls compose in one SELECT rather than a\n    // round-trip per GUC — each a network hop that taxes the shared PgBouncer\n    // pool on the hot path. `true`\n    // = is_local (SET LOCAL semantics: auto-released on COMMIT/ROLLBACK). The\n    // driver binds the values as parameters, so a hostile org_id can't break out\n    // of the GUC syntax.\n    //\n    // The statement_timeout GUC bounds a runaway query so it can't hold a pooled\n    // connection open indefinitely (`SET LOCAL statement_timeout = $1` is rejected\n    // by Postgres, hence set_config with a bound ms value). Included in the same\n    // statement when enabled (>0), dropped entirely when disabled (0).\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n"]}
+/**
+ * Where a read goes, and why.
+ *
+ * SYSTEM gates are checked before REQUEST gates, which matters only for the
+ * explanation — but the explanation is what an operator reads when asking why
+ * the replica is idle, and "my request wrote" is a far less useful answer than
+ * "the standby is 40 seconds behind".
+ */
+export function chooseReadTarget(ctx, health) {
+    if (!health.available)
+        return { useReplica: false, reason: 'no-replica' };
+    if (health.lag !== 'ok')
+        return { useReplica: false, reason: 'replica-lagging' };
+    if (!ctx)
+        return { useReplica: false, reason: 'no-context' };
+    if (ctx.mayHaveWritten)
+        return { useReplica: false, reason: 'may-have-written' };
+    return { useReplica: true, reason: 'replica' };
+}
+/**
+ * Open a READ-ONLY transaction with the same RLS GUCs `withTenantTx` sets,
+ * routed to the replica when {@link chooseReadTarget} allows it.
+ *
+ * `SET TRANSACTION READ ONLY` is the guardrail, not decoration. Several queries
+ * in this codebase look like reads at the call site and are not —
+ * `SELECT … FOR UPDATE` in crud-service's setDefault, `pg_advisory_xact_lock`
+ * in pipeline-service and compliance's subscription-service. Routed to a
+ * standby those fail anyway; declaring the transaction read-only makes them
+ * fail HERE, with a clear message, including on the primary where they would
+ * otherwise succeed and quietly acquire a lock the caller did not intend.
+ *
+ * Falls back to the primary transparently, so a caller never has to ask
+ * whether a replica exists.
+ */
+export async function withTenantTxRead(fn) {
+    const ctx = tenantContext.getStore();
+    const readDb = getReadDb();
+    const readPool = getReadPool();
+    // Keep the lag sample warm. Fire-and-forget by design: it is debounced to
+    // DB_READ_LAG_SAMPLE_MS, never throws, and must not add a round-trip to this
+    // read. The first read of a process therefore routes to the primary (no
+    // sample yet) and warms the circuit for the ones after it.
+    if (readPool)
+        void maybeSampleLag(readPool);
+    const target = chooseReadTarget(ctx, { available: readDb !== null, lag: lagVerdict() });
+    emitCounter('postgres_read_routed_total', { target: target.useReplica ? 'replica' : 'primary', reason: target.reason });
+    if (!target.useReplica) {
+        // Primary path: identical semantics to withTenantTx, plus the read-only
+        // declaration so an accidental write is caught on every target — including
+        // the ones that will never have a replica.
+        return withTenantTx(async (tx) => {
+            await tx.execute(sql `SET TRANSACTION READ ONLY`);
+            return fn(tx);
+        }, /* markWritten */ false);
+    }
+    // Non-null by construction: chooseReadTarget only returns useReplica for a
+    // ctx that exists. Read the GUCs off it directly rather than defaulting to
+    // '' — a default here would silently re-open the hole that 'no-context'
+    // closes, because an empty app.org_id is a VALID-looking RLS scope.
+    const { orgId } = ctx;
+    const isSuperAdmin = ctx.isSuperAdmin ? 'true' : 'false';
+    const statementTimeoutMs = getStatementTimeoutMs();
+    return readDb.transaction(async (tx) => {
+        await tx.execute(sql `SET TRANSACTION READ ONLY`);
+        if (statementTimeoutMs > 0) {
+            await tx.execute(sql `SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`);
+        }
+        else {
+            await tx.execute(sql `SELECT set_config('app.org_id', ${orgId}, true), 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":"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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 * Every tenant table is `FORCE ROW LEVEL SECURITY`, so the policies enforce\n * even for the (owning) connection user — a query against one must run inside a\n * transaction that has SET LOCAL'd both GUCs or it returns zero rows for\n * non-sysadmins (and may fail to write for any caller). The cross-org plugin\n * ecosystem catalog tables carry a permissive app-role policy instead.\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:\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, emitCounter, envInt } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { db } from './postgres-connection.js';\nimport { getReadDb, getReadPool } from './read-connection.js';\nimport { lagVerdict, maybeSampleLag, type LagVerdict } from './read-lag.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 ms = envInt('DB_STATEMENT_TIMEOUT_MS', 30_000);\n  return ms >= 0 ? ms : 30_000;\n}\n\nexport interface TenantContext {\n  /** Caller's org. Undefined for un-authenticated / system jobs. */\n  orgId?: string;\n  /** Caller's user id. Not used for RLS — Postgres policies are org-grained,\n   *  with no per-user session GUC — but carried so app-layer predicates with a\n   *  PER-USER rung (pipeline templates' `private` visibility) can resolve \"who\n   *  is asking\" on paths that have nowhere to pass it, notably CrudService's\n   *  `writeConditions`. Absent for system jobs, which is the fail-closed case:\n   *  no viewer ⇒ no private rows. */\n  userId?: 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   * Set once this request has opened a PRIMARY transaction, i.e. may have\n   * written. Subsequent `withTenantTxRead` calls in the same request then go to\n   * the primary too, so a handler cannot read its own write off a replica that\n   * has not replayed it yet.\n   *\n   * Deliberately set by `withTenantTx` rather than by write call sites: that\n   * path is the one that can write, it needs no per-call-site discipline, and\n   * being wrong in this direction only costs a replica hit. Mutated in place on\n   * the AsyncLocalStorage store — the store is per-request, so this cannot leak\n   * between requests.\n   *\n   * SCOPE: this covers reads AFTER a write IN THE SAME REQUEST. It does NOT\n   * cover the next request (POST then a page reload issuing GET). That needs\n   * shared state — see the cross-request section of\n   * docs/plans/postgres-read-write-split.md — and must be settled before call\n   * sites are migrated in bulk.\n   */\n  mayHaveWritten?: 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 * 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  /**\n   * INTERNAL. Whether this transaction should mark the request as possibly\n   * having written. Always true for a real caller; only withTenantTxRead's\n   * primary-fallback path passes false, because a read that lands on the\n   * primary has not written. See the comment at the assignment below.\n   */\n  markWritten = true,\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  // This transaction runs on the PRIMARY and may write, so any later read in\n  // this request must stay on the primary too. Set before the transaction opens\n  // rather than after it commits: a read issued concurrently from the same\n  // handler would otherwise race the flag.\n  //\n  // `markWritten: false` is passed ONLY by withTenantTxRead's fallback path,\n  // and it is not an optimisation — without it the feature defeats itself. That\n  // path runs on the primary, so it would set this flag, which api-server's\n  // middleware reads after the response to set the Redis write pin. A purely\n  // READ-ONLY request would therefore pin its whole org to the primary for the\n  // pin TTL, every time, and since reads fall back whenever no replica is\n  // configured (the shipping default) every org would be permanently pinned.\n  // The flag means \"this request may have WRITTEN\", not \"this request touched\n  // the primary\", and the difference is the whole read-offload benefit.\n  if (ctx && markWritten) ctx.mayHaveWritten = true;\n\n  return db.transaction(async (tx) => {\n    // Set every transaction-scoped GUC in a SINGLE round-trip. `set_config()`\n    // returns its value, so multiple calls compose in one SELECT rather than a\n    // round-trip per GUC — each a network hop that taxes the shared PgBouncer\n    // pool on the hot path. `true`\n    // = is_local (SET LOCAL semantics: auto-released on COMMIT/ROLLBACK). The\n    // driver binds the values as parameters, so a hostile org_id can't break out\n    // of the GUC syntax.\n    //\n    // The statement_timeout GUC bounds a runaway query so it can't hold a pooled\n    // connection open indefinitely (`SET LOCAL statement_timeout = $1` is rejected\n    // by Postgres, hence set_config with a bound ms value). Included in the same\n    // statement when enabled (>0), dropped entirely when disabled (0).\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n\n/**\n * Why a read was or was not sent to the replica. Returned by\n * {@link chooseReadTarget} so the decision is inspectable — and testable\n * without a replica, which matters because the test substrate (PGlite) has no\n * replication at all.\n */\nexport type ReadTargetReason =\n  /** No replica configured, or DB_READ_ENABLED=false. */\n  | 'no-replica'\n  /** This request already opened a primary transaction and may have written. */\n  | 'may-have-written'\n  /**\n   * No tenant context. A caller outside `runWithTenantContext` has no org to\n   * scope RLS by and no watermark to compare, so it goes to the primary — where\n   * `withTenantTx`'s RLS_CONTEXT_MODE guard logs or throws. Routed to a replica\n   * instead, the same call would set `app.org_id = ''` with no diagnostic at all.\n   */\n  | 'no-context'\n  /**\n   * A replica exists but its replay lag is beyond `DB_READ_MAX_LAG_SECONDS`,\n   * or is UNKNOWN (no sample yet, the sample failed, or the cached sample has\n   * gone stale). Unknown and lagging are the same decision on purpose: the\n   * circuit fails closed.\n   */\n  | 'replica-lagging'\n  /** Routed to the replica. */\n  | 'replica';\n\nexport interface ReadTarget {\n  useReplica: boolean;\n  reason: ReadTargetReason;\n}\n\n/**\n * Decide where a read-only transaction should run.\n *\n * Pure and side-effect free on purpose: this is the whole of the routing\n * policy, and it is the part worth testing. Replication itself cannot be\n * reproduced locally, so the testable unit is the DECISION, not the lag.\n *\n * The bias is deliberate: anything uncertain resolves to the primary. A read\n * served by the primary is merely less efficient; a read served by a stale\n * replica is a user-visible bug nobody can reproduce.\n */\n/** Everything about the replica that is not request-specific. */\nexport interface ReadReplicaHealth {\n  /** A replica pool exists AND `DB_READ_ENABLED` is not false. */\n  available: boolean;\n  /** The lag circuit's verdict. `unknown` is treated exactly like `lagging`. */\n  lag: LagVerdict;\n}\n\n/**\n * Where a read goes, and why.\n *\n * SYSTEM gates are checked before REQUEST gates, which matters only for the\n * explanation — but the explanation is what an operator reads when asking why\n * the replica is idle, and \"my request wrote\" is a far less useful answer than\n * \"the standby is 40 seconds behind\".\n */\nexport function chooseReadTarget(ctx: TenantContext | undefined, health: ReadReplicaHealth): ReadTarget {\n  if (!health.available) return { useReplica: false, reason: 'no-replica' };\n  if (health.lag !== 'ok') return { useReplica: false, reason: 'replica-lagging' };\n  if (!ctx) return { useReplica: false, reason: 'no-context' };\n  if (ctx.mayHaveWritten) return { useReplica: false, reason: 'may-have-written' };\n  return { useReplica: true, reason: 'replica' };\n}\n\n/**\n * Open a READ-ONLY transaction with the same RLS GUCs `withTenantTx` sets,\n * routed to the replica when {@link chooseReadTarget} allows it.\n *\n * `SET TRANSACTION READ ONLY` is the guardrail, not decoration. Several queries\n * in this codebase look like reads at the call site and are not —\n * `SELECT … FOR UPDATE` in crud-service's setDefault, `pg_advisory_xact_lock`\n * in pipeline-service and compliance's subscription-service. Routed to a\n * standby those fail anyway; declaring the transaction read-only makes them\n * fail HERE, with a clear message, including on the primary where they would\n * otherwise succeed and quietly acquire a lock the caller did not intend.\n *\n * Falls back to the primary transparently, so a caller never has to ask\n * whether a replica exists.\n */\nexport async function withTenantTxRead<T>(\n  fn: (tx: Parameters<Parameters<typeof db.transaction>[0]>[0]) => Promise<T>,\n): Promise<T> {\n  const ctx = tenantContext.getStore();\n  const readDb = getReadDb();\n  const readPool = getReadPool();\n\n  // Keep the lag sample warm. Fire-and-forget by design: it is debounced to\n  // DB_READ_LAG_SAMPLE_MS, never throws, and must not add a round-trip to this\n  // read. The first read of a process therefore routes to the primary (no\n  // sample yet) and warms the circuit for the ones after it.\n  if (readPool) void maybeSampleLag(readPool);\n\n  const target = chooseReadTarget(ctx, { available: readDb !== null, lag: lagVerdict() });\n  emitCounter('postgres_read_routed_total', { target: target.useReplica ? 'replica' : 'primary', reason: target.reason });\n\n  if (!target.useReplica) {\n    // Primary path: identical semantics to withTenantTx, plus the read-only\n    // declaration so an accidental write is caught on every target — including\n    // the ones that will never have a replica.\n    return withTenantTx(async (tx) => {\n      await tx.execute(sql`SET TRANSACTION READ ONLY`);\n      return fn(tx);\n    }, /* markWritten */ false);\n  }\n\n  // Non-null by construction: chooseReadTarget only returns useReplica for a\n  // ctx that exists. Read the GUCs off it directly rather than defaulting to\n  // '' — a default here would silently re-open the hole that 'no-context'\n  // closes, because an empty app.org_id is a VALID-looking RLS scope.\n  const { orgId } = ctx!;\n  const isSuperAdmin = ctx!.isSuperAdmin ? 'true' : 'false';\n  const statementTimeoutMs = getStatementTimeoutMs();\n\n  return readDb!.transaction(async (tx) => {\n    await tx.execute(sql`SET TRANSACTION READ ONLY`);\n    if (statementTimeoutMs > 0) {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true), set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`,\n      );\n    } else {\n      await tx.execute(\n        sql`SELECT set_config('app.org_id', ${orgId}, true), set_config('app.is_sysadmin', ${isSuperAdmin}, true)`,\n      );\n    }\n    return fn(tx);\n  });\n}\n"]}

package/lib/testing/exports.json

@@ -20,10 +20,12 @@
       "buildPipelineTemplateConditions": "function",
       "buildPluginConditions": "function",
       "buildPublishedRuleCatalogConditions": "function",
+      "chooseReadTarget": "function",
       "classifyFailure": "function",
       "closeConnection": "function",
       "closeFixedExposures": "function",
       "closePublicReader": "function",
+      "closeReadConnection": "function",
       "COMMUNITY_PUBLISHER_HANDLE": "value",
       "compareSemver": "function",
       "compareSemverParts": "function",
@@ -77,6 +79,8 @@
       "getPublicListedVersion": "function",
       "getPublicListing": "function",
       "getPublicReaderDb": "function",
+      "getReadDb": "function",
+      "getReadPool": "function",
       "getResourceConsumption": "function",
       "getSection": "function",
       "getSslConfig": "function",
@@ -95,6 +99,7 @@
       "isTeamActionable": "function",
       "isUniqueViolation": "function",
       "isVersionRange": "function",
+      "lagVerdict": "function",
       "lapsedAcceptances": "function",
       "leadTimeGapOf": "function",
       "listedPluginRecord": "function",
@@ -108,6 +113,7 @@
       "LOW_SAMPLE_THRESHOLD": "value",
       "MAX_BOUNCES": "value",
       "MAX_SHARE_LINK_TTL_DAYS": "value",
+      "maybeSampleLag": "function",
       "message": "value",
       "messageAttachment": "value",
       "mintToken": "function",
@@ -170,6 +176,8 @@
       "reportRecipient": "value",
       "reportRun": "value",
       "reportShareLink": "value",
+      "resetLagStateForTests": "function",
+      "resetReadConnectionForTests": "function",
       "resolvableListings": "function",
       "resolveListingReference": "function",
       "resolvePeriod": "function",
@@ -188,6 +196,7 @@
       "searchPublicListings": "function",
       "sectionIds": "function",
       "semverOrderBy": "function",
+      "setLagSampleForTests": "function",
       "softDeleteRetentionMs": "function",
       "stakeholderReportStore": "value",
       "StakeholderReportStore": "class",
@@ -203,6 +212,7 @@
       "versionGap": "function",
       "viewerCacheSegment": "function",
       "withTenantTx": "function",
+      "withTenantTxRead": "function",
       "withViewerContext": "function"
     }
   }

package/package.json

@@ -24,7 +24,7 @@
     "typescript": "npm:@typescript/typescript6@^6.0.2"
   },
   "dependencies": {
-    "@pipeline-builder/api-core": "5.0.21",
+    "@pipeline-builder/api-core": "5.0.22",
     "drizzle-orm": "0.45.4",
     "pg": "8.23.1"
   },
@@ -85,7 +85,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.46",
+  "version": "4.1.47",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },