@pipeline-builder/pipeline-data 0.0.1

package/lib/database/schema/plugin.js

@@ -0,0 +1,166 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ComputeType, PluginType, SYSTEM_ORG_ID, } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { boolean, integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex, check } from 'drizzle-orm/pg-core';
+/**
+ * Table for storing reusable plugin configurations.
+ * Plugins define the behavior of synth/build steps in CDK pipelines.
+ *
+ * Features * - Versioning support with semantic versioning
+ * - Access control via orgId and the three-rung `visibility` ladder
+ * - Full audit trail (created/updated by/at)
+ * - Flexible metadata storage via JSONB
+ * - Support for both ShellStep and CodeBuildStep types
+ *
+ * @table plugins
+ */
+export const plugin = pgTable('plugins', {
+    // Primary key
+    id: uuid('id').primaryKey().defaultRandom(),
+    // Organization and access control
+    orgId: varchar('org_id', { length: 255 })
+        .default(SYSTEM_ORG_ID)
+        .notNull(),
+    // Audit fields
+    createdBy: text('created_by')
+        .default(SYSTEM_ORG_ID)
+        .notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedBy: text('updated_by')
+        .default(SYSTEM_ORG_ID)
+        .notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    // Core plugin information
+    name: varchar('name', { length: 255 })
+        .notNull(),
+    description: text('description'),
+    keywords: jsonb('keywords')
+        .$type()
+        .default([])
+        .notNull(),
+    version: varchar('version', { length: 50 })
+        .default('1.0.0')
+        .notNull(),
+    // Plugin classification
+    category: varchar('category', { length: 50 })
+        .default('unknown')
+        .notNull(),
+    // Plugin configuration
+    metadata: jsonb('metadata')
+        .$type()
+        .default({})
+        .notNull(),
+    pluginType: varchar('plugin_type', { length: 50 })
+        .$type()
+        .default('CodeBuildStep')
+        .notNull(),
+    computeType: varchar('compute_type', { length: 50 })
+        .$type()
+        .default('SMALL')
+        .notNull(),
+    timeout: integer('timeout'),
+    failureBehavior: varchar('failure_behavior', { length: 10 })
+        .$type()
+        .default('fail')
+        .notNull(),
+    secrets: jsonb('secrets')
+        .$type()
+        .default([])
+        .notNull(),
+    primaryOutputDirectory: varchar('primary_output_directory', { length: 28 }),
+    // Build configuration
+    env: jsonb('env')
+        .$type()
+        .default({})
+        .notNull(),
+    buildArgs: jsonb('build_args')
+        .$type()
+        .default({})
+        .notNull(),
+    installCommands: text('install_commands')
+        .array()
+        .default([])
+        .notNull(),
+    commands: text('commands')
+        .array()
+        .default([])
+        .notNull(),
+    // Docker configuration
+    dockerfile: text('dockerfile'),
+    buildType: varchar('build_type', { length: 20 })
+        .default('build_image')
+        .notNull(),
+    // Developer-portal catalog metadata (ownership / lifecycle / classification).
+    // ownerId defaults to the creating user (set at insert), so every plugin has
+    // an owner for "my services" views; ownerType distinguishes user vs team.
+    ownerId: text('owner_id'),
+    ownerType: varchar('owner_type', { length: 10 }).$type(),
+    lifecycle: varchar('lifecycle', { length: 20 })
+        .$type()
+        .default('production')
+        .notNull(),
+    criticality: varchar('criticality', { length: 10 }).$type(),
+    labels: jsonb('labels')
+        .$type()
+        .default({})
+        .notNull(),
+    links: jsonb('links')
+        .$type()
+        .default([])
+        .notNull(),
+    // Access and visibility — the shared three-rung ladder (see api-core's
+    // `Visibility`): `private` is author-only (`created_by`), `org` is the whole
+    // owning org, `public` reaches the org's teams and — from the system org —
+    // every org. Constrained at the SQL layer too via a CHECK in postgres-init.sql
+    // so a typo can't sneak past the application layer.
+    visibility: varchar('visibility', { length: 10 })
+        .$type()
+        .default('private')
+        .notNull(),
+    isDefault: boolean('is_default')
+        .default(false)
+        .notNull(),
+    isActive: boolean('is_active')
+        .default(true)
+        .notNull(),
+    // Deletion tracking (soft delete)
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+    // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned
+    // rows once `purge_after` has passed (set on delete alongside deleted_at).
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
+}, (table) => ({
+    // Partial index over just the tombstones — drives the retention purge sweep.
+    purgeIdx: index('plugin_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
+    // Indexes for common queries
+    nameIdx: index('plugin_name_idx').on(table.name),
+    orgIdIdx: index('plugin_org_id_idx').on(table.orgId),
+    versionIdx: index('plugin_version_idx').on(table.version),
+    activeIdx: index('plugin_active_idx').on(table.isActive),
+    createdAtIdx: index('plugin_created_at_idx').on(table.createdAt),
+    updatedAtIdx: index('plugin_updated_at_idx').on(table.updatedAt),
+    // Category index for filtering
+    categoryIdx: index('plugin_category_idx').on(table.category),
+    // Developer-portal catalog indexes: "my services" (owner) + lifecycle filter.
+    ownerIdx: index('plugin_owner_idx').on(table.orgId, table.ownerId),
+    lifecycleIdx: index('plugin_lifecycle_idx').on(table.orgId, table.lifecycle),
+    // Composite index for common access pattern (orgId + isActive)
+    orgActiveIdx: index('plugin_org_active_idx').on(table.orgId, table.isActive),
+    // Composite index for filtered queries (orgId + visibility + isActive)
+    orgVisibilityActiveIdx: index('plugin_org_visibility_active_idx').on(table.orgId, table.visibility, table.isActive),
+    // Drives the "my private drafts" leg of the visibility predicate.
+    createdByIdx: index('plugin_created_by_idx').on(table.orgId, table.createdBy),
+    // Partial index for active-only queries (smaller, faster than full index)
+    activeOnlyOrgIdx: index('plugin_active_only_org_idx').on(table.orgId, table.createdAt).where(sql `is_active = true`),
+    // Unique constraint on name + version + orgId
+    nameVersionOrgUnique: uniqueIndex('plugin_name_version_org_unique')
+        .on(table.name, table.version, table.orgId),
+    // Check constraints
+    versionCheck: check('plugin_version_check', sql `${table.version} ~ '^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$'`),
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../../src/database/schema/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  ComputeType, PluginType, SYSTEM_ORG_ID, type Criticality, type EntityLabels, type EntityLink, type Lifecycle, type OwnerType,\n  type Visibility,\n} from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { boolean, integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex, check } from 'drizzle-orm/pg-core';\n\n/**\n * Secret requirement for a plugin.\n * Declares named secrets the plugin expects at build time.\n */\nexport interface PluginSecret {\n  name: string;\n  required: boolean;\n  description?: string;\n}\n\n/**\n * Table for storing reusable plugin configurations.\n * Plugins define the behavior of synth/build steps in CDK pipelines.\n *\n * Features * - Versioning support with semantic versioning\n * - Access control via orgId and the three-rung `visibility` ladder\n * - Full audit trail (created/updated by/at)\n * - Flexible metadata storage via JSONB\n * - Support for both ShellStep and CodeBuildStep types\n *\n * @table plugins\n */\nexport const plugin = pgTable('plugins', {\n  // Primary key\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Organization and access control\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n\n  // Audit fields\n  createdBy: text('created_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n  updatedBy: text('updated_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n\n  // Core plugin information\n  name: varchar('name', { length: 255 })\n    .notNull(),\n  description: text('description'),\n  keywords: jsonb('keywords')\n    .$type<string[]>()\n    .default([])\n    .notNull(),\n  version: varchar('version', { length: 50 })\n    .default('1.0.0')\n    .notNull(),\n\n  // Plugin classification\n  category: varchar('category', { length: 50 })\n    .default('unknown')\n    .notNull(),\n\n  // Plugin configuration\n  metadata: jsonb('metadata')\n    .$type<Record<string, string | number | boolean>>()\n    .default({})\n    .notNull(),\n  pluginType: varchar('plugin_type', { length: 50 })\n    .$type<PluginType>()\n    .default('CodeBuildStep' as PluginType)\n    .notNull(),\n  computeType: varchar('compute_type', { length: 50 })\n    .$type<ComputeType>()\n    .default('SMALL' as ComputeType)\n    .notNull(),\n  timeout: integer('timeout'),\n  failureBehavior: varchar('failure_behavior', { length: 10 })\n    .$type<'fail' | 'warn' | 'ignore'>()\n    .default('fail')\n    .notNull(),\n  secrets: jsonb('secrets')\n    .$type<PluginSecret[]>()\n    .default([])\n    .notNull(),\n  primaryOutputDirectory: varchar('primary_output_directory', { length: 28 }),\n\n  // Build configuration\n  env: jsonb('env')\n    .$type<Record<string, string>>()\n    .default({})\n    .notNull(),\n  buildArgs: jsonb('build_args')\n    .$type<Record<string, string>>()\n    .default({})\n    .notNull(),\n  installCommands: text('install_commands')\n    .array()\n    .default([])\n    .notNull(),\n  commands: text('commands')\n    .array()\n    .default([])\n    .notNull(),\n\n  // Docker configuration\n  dockerfile: text('dockerfile'),\n  buildType: varchar('build_type', { length: 20 })\n    .default('build_image')\n    .notNull(),\n\n  // Developer-portal catalog metadata (ownership / lifecycle / classification).\n  // ownerId defaults to the creating user (set at insert), so every plugin has\n  // an owner for \"my services\" views; ownerType distinguishes user vs team.\n  ownerId: text('owner_id'),\n  ownerType: varchar('owner_type', { length: 10 }).$type<OwnerType>(),\n  lifecycle: varchar('lifecycle', { length: 20 })\n    .$type<Lifecycle>()\n    .default('production' as Lifecycle)\n    .notNull(),\n  criticality: varchar('criticality', { length: 10 }).$type<Criticality>(),\n  labels: jsonb('labels')\n    .$type<EntityLabels>()\n    .default({})\n    .notNull(),\n  links: jsonb('links')\n    .$type<EntityLink[]>()\n    .default([])\n    .notNull(),\n\n  // Access and visibility — the shared three-rung ladder (see api-core's\n  // `Visibility`): `private` is author-only (`created_by`), `org` is the whole\n  // owning org, `public` reaches the org's teams and — from the system org —\n  // every org. Constrained at the SQL layer too via a CHECK in postgres-init.sql\n  // so a typo can't sneak past the application layer.\n  visibility: varchar('visibility', { length: 10 })\n    .$type<Visibility>()\n    .default('private')\n    .notNull(),\n  isDefault: boolean('is_default')\n    .default(false)\n    .notNull(),\n  isActive: boolean('is_active')\n    .default(true)\n    .notNull(),\n\n  // Deletion tracking (soft delete)\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned\n  // rows once `purge_after` has passed (set on delete alongside deleted_at).\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // Partial index over just the tombstones — drives the retention purge sweep.\n  purgeIdx: index('plugin_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // Indexes for common queries\n  nameIdx: index('plugin_name_idx').on(table.name),\n  orgIdIdx: index('plugin_org_id_idx').on(table.orgId),\n  versionIdx: index('plugin_version_idx').on(table.version),\n  activeIdx: index('plugin_active_idx').on(table.isActive),\n  createdAtIdx: index('plugin_created_at_idx').on(table.createdAt),\n  updatedAtIdx: index('plugin_updated_at_idx').on(table.updatedAt),\n\n  // Category index for filtering\n  categoryIdx: index('plugin_category_idx').on(table.category),\n\n  // Developer-portal catalog indexes: \"my services\" (owner) + lifecycle filter.\n  ownerIdx: index('plugin_owner_idx').on(table.orgId, table.ownerId),\n  lifecycleIdx: index('plugin_lifecycle_idx').on(table.orgId, table.lifecycle),\n\n  // Composite index for common access pattern (orgId + isActive)\n  orgActiveIdx: index('plugin_org_active_idx').on(table.orgId, table.isActive),\n\n  // Composite index for filtered queries (orgId + visibility + isActive)\n  orgVisibilityActiveIdx: index('plugin_org_visibility_active_idx').on(table.orgId, table.visibility, table.isActive),\n  // Drives the \"my private drafts\" leg of the visibility predicate.\n  createdByIdx: index('plugin_created_by_idx').on(table.orgId, table.createdBy),\n\n  // Partial index for active-only queries (smaller, faster than full index)\n  activeOnlyOrgIdx: index('plugin_active_only_org_idx').on(table.orgId, table.createdAt).where(sql`is_active = true`),\n\n  // Unique constraint on name + version + orgId\n  nameVersionOrgUnique: uniqueIndex('plugin_name_version_org_unique')\n    .on(table.name, table.version, table.orgId),\n\n  // Check constraints\n  versionCheck: check( 'plugin_version_check',\n    sql`${table.version} ~ '^[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$'`,\n  ),\n}));\n\n/**\n * TypeScript types representing database rows\n */\nexport type Plugin = typeof plugin.$inferSelect;\nexport type PluginInsert = typeof plugin.$inferInsert;\n\n/**\n * Helper types for working with partial updates\n */\nexport type PluginUpdate = Partial<Omit<PluginInsert, 'id' | 'createdAt' | 'createdBy'>>;\n"]}

package/lib/database/tenancy.d.ts

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

package/lib/database/tenancy.js

@@ -0,0 +1,167 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Tenant-context plumbing for Postgres row-level security.
+ *
+ * Background: postgres-init.sql installs RLS policies on every user-data
+ * table that consult two session GUCs — `app.org_id` and `app.is_sysadmin`.
+ * Most user-data tables have been flipped to `FORCE ROW LEVEL SECURITY`, so
+ * the policies DO enforce even for the (owning) connection user — a query
+ * against a FORCE'd table must run inside a transaction that has SET LOCAL'd
+ * both GUCs or it returns zero rows for non-sysadmins (and may fail to write
+ * for any caller). A few tables remain `ENABLE`-only (owner-bypass) pending
+ * their soak; the same context plumbing covers both.
+ *
+ * This module is the seam.
+ *
+ *   1. `tenantContext` (AsyncLocalStorage) carries `{orgId, isSuperAdmin}`
+ *      down the call chain without prop-drilling. Set once at the request
+ *      boundary; readable from anywhere.
+ *
+ *   2. `withTenantTx(fn)` opens a transaction, SET LOCAL's both GUCs from
+ *      the surrounding context, then invokes `fn(tx)`. Services migrate one
+ *      at a time by wrapping their existing drizzle calls in this helper —
+ *      `db.select().from(...)` becomes `withTenantTx(tx => tx.select().from(...))`.
+ *
+ *   3. `runWithTenantContext(ctx, fn)` is the Express-middleware-side
+ *      bookend that establishes the AsyncLocalStorage scope for the request.
+ *
+ * Migration order (see docs/plans/f-1-0-rls-enforcement.md):
+ *   - First adopters: newly-written services (dashboard, alert-destination)
+ *     where the change is mechanical.
+ *   - Then high-write services (plugin, pipeline). Soak each one before
+ *     flipping the underlying table to FORCE.
+ *   - admin_audit_log uses a sysadmin-only policy — sysadmin paths must
+ *     also set `app.is_sysadmin = 'true'` or they'll lose access to it.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createLogger } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { db } from './postgres-connection.js';
+const logger = createLogger('tenant-context');
+function getContextMode() {
+    const raw = process.env.RLS_CONTEXT_MODE?.toLowerCase();
+    if (raw === 'silent' || raw === 'warn' || raw === 'strict')
+        return raw;
+    // 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
+ * know "who is the caller" without re-deriving from the request object.
+ */
+export const tenantContext = new AsyncLocalStorage();
+/**
+ * Run `fn` inside the given tenant scope. The AsyncLocalStorage scope
+ * survives across async boundaries (Promises, setTimeout, etc.), so any
+ * `withTenantTx` call inside `fn` — directly or through any depth of
+ * async helpers — picks up `ctx`.
+ *
+ * Wrap `next()` from an Express middleware to establish per-request scope:
+ *
+ *     app.use((req, res, next) => {
+ *       runWithTenantContext({ orgId, isSuperAdmin }, () => next());
+ *     });
+ */
+export function runWithTenantContext(ctx, fn) {
+    return tenantContext.run(ctx, fn);
+}
+/** Read the current tenant context. Returns undefined outside an
+ *  `runWithTenantContext` scope (e.g. background workers, migrations). */
+export function getTenantContext() {
+    return tenantContext.getStore();
+}
+/**
+ * Assert that the current code is running inside a tenant scope. Callers
+ * that legitimately need to refuse to operate without one (e.g. handlers
+ * that touch FORCE'd RLS tables) can use this instead of relying on the
+ * downstream "permission denied" error to surface the bug.
+ */
+export function requireTenantContext() {
+    const ctx = tenantContext.getStore();
+    if (!ctx) {
+        throw new Error('requireTenantContext: no tenant scope active. Wrap your handler/worker in '
+            + 'runWithTenantContext({ orgId, isSuperAdmin }, ...) before any DB call.');
+    }
+    return ctx;
+}
+/**
+ * Open a transaction with RLS GUCs SET LOCAL from the current
+ * AsyncLocalStorage tenant context, then invoke `fn(tx)`.
+ *
+ * - When called outside a tenant scope (e.g. from a background job that
+ *   doesn't have a caller identity), the transaction is opened with both
+ *   GUCs cleared — RLS policies will return zero rows on FORCE'd tables.
+ *   Callers that need a sysadmin-equivalent scope should wrap themselves in
+ *   `runWithTenantContext({ isSuperAdmin: true }, …)` explicitly.
+ *
+ * - Uses `set_config(key, value, true)` (the boolean = `is_local`, i.e.
+ *   transaction-scoped). Equivalent to `SET LOCAL` but takes the value as
+ *   a parameter, which is what we want — Drizzle's `sql` template binds the
+ *   value safely so an attacker-controlled `orgId` can't escape the quoting.
+ *
+ * - Returns whatever `fn` returns; throws whatever `fn` throws (Drizzle
+ *   handles the COMMIT/ROLLBACK for us).
+ */
+export async function withTenantTx(fn) {
+    const ctx = tenantContext.getStore();
+    if (!ctx) {
+        // Surface the bug instead of silently SET'ing empty GUCs. The default
+        // mode ('warn') logs an actionable trace so the bad call site is easy
+        // to find; production deployments that have finished the audit can set
+        // RLS_CONTEXT_MODE=strict to fail-fast at the call site (better stack
+        // trace than the Postgres "permission denied" that would otherwise
+        // surface from FORCE'd RLS).
+        const mode = getContextMode();
+        if (mode === 'strict') {
+            throw new Error('withTenantTx called outside a tenant scope. Wrap your handler/worker '
+                + 'in runWithTenantContext({ orgId, isSuperAdmin }, ...) before invoking '
+                + 'any service that touches RLS-enforced tables.');
+        }
+        if (mode === 'warn') {
+            // Include a synthetic stack so the offending call site is in the log.
+            logger.warn('withTenantTx called outside a tenant scope; RLS GUCs will be empty', {
+                stack: new Error('tenant-context missing').stack,
+            });
+        }
+    }
+    const orgId = ctx?.orgId ?? '';
+    const isSuperAdmin = ctx?.isSuperAdmin ? 'true' : 'false';
+    const statementTimeoutMs = getStatementTimeoutMs();
+    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 — previously
+        // these were 2–3 separate `tx.execute()` round-trips PER read, each a
+        // network hop that taxes the shared PgBouncer pool on the hot path. `true`
+        // = is_local (SET LOCAL semantics: 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.
+        //
+        // The statement_timeout GUC bounds a runaway query so it can't hold a pooled
+        // connection open indefinitely (`SET LOCAL statement_timeout = $1` is rejected
+        // by Postgres, hence set_config with a bound ms value). Included in the same
+        // statement when enabled (>0), dropped entirely when disabled (0).
+        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 * Most user-data tables have been flipped to `FORCE ROW LEVEL SECURITY`, so\n * the policies DO enforce even for the (owning) connection user — a query\n * against a FORCE'd table must run inside a transaction that has SET LOCAL'd\n * both GUCs or it returns zero rows for non-sysadmins (and may fail to write\n * for any caller). A few tables remain `ENABLE`-only (owner-bypass) pending\n * their soak; the same context plumbing covers both.\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  /** 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 * 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 every transaction-scoped GUC in a SINGLE round-trip. `set_config()`\n    // returns its value, so multiple calls compose in one SELECT — previously\n    // these were 2–3 separate `tx.execute()` round-trips PER read, each a\n    // network hop that taxes the shared PgBouncer 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"]}

package/lib/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module @pipeline-builder/pipeline-data
+ *
+ * Database layer: Drizzle ORM schemas, connection management, and query infrastructure.
+ *
+ * **Database**
+ * - db — shared Drizzle database instance
+ * - getConnection, closeConnection — PostgreSQL connection lifecycle with retry logic
+ * - schema — Drizzle table definitions (plugins, pipelines, messages, compliance, etc.)
+ *
+ * **Services**
+ * - CrudService — generic base class for multi-tenant CRUD with access control and pagination
+ * - ReportingService — aggregate query and reporting base class
+ *
+ * **Query Builders**
+ * - buildPluginConditions, buildPipelineConditions, buildMessageConditions — filter-to-SQL condition builders
+ * - buildCompliancePolicyConditions, buildComplianceRuleConditions, etc. — compliance query builders
+ * - AccessControlBuilder — row-level access control condition builder
+ *
+ * **Filters**
+ * - PluginFilter, PipelineFilter, MessageFilter — typed filter interfaces
+ * - CompliancePolicyFilter, ComplianceRuleFilter, etc. — compliance filter interfaces
+ * - drizzleRows, drizzleCount — Drizzle result type helpers
+ */
+export * from './database/index.js';
+export * from './api/query-builders.js';
+export * from './api/access-control-builder.js';
+export * from './api/viewer-context.js';
+export * from './api/crud-service.js';
+export * from './api/soft-delete-sweep.js';
+export * from './api/reporting-service.js';
+export * from './core/query-filters.js';

package/lib/index.js

@@ -0,0 +1,38 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @module @pipeline-builder/pipeline-data
+ *
+ * Database layer: Drizzle ORM schemas, connection management, and query infrastructure.
+ *
+ * **Database**
+ * - db — shared Drizzle database instance
+ * - getConnection, closeConnection — PostgreSQL connection lifecycle with retry logic
+ * - schema — Drizzle table definitions (plugins, pipelines, messages, compliance, etc.)
+ *
+ * **Services**
+ * - CrudService — generic base class for multi-tenant CRUD with access control and pagination
+ * - ReportingService — aggregate query and reporting base class
+ *
+ * **Query Builders**
+ * - buildPluginConditions, buildPipelineConditions, buildMessageConditions — filter-to-SQL condition builders
+ * - buildCompliancePolicyConditions, buildComplianceRuleConditions, etc. — compliance query builders
+ * - AccessControlBuilder — row-level access control condition builder
+ *
+ * **Filters**
+ * - PluginFilter, PipelineFilter, MessageFilter — typed filter interfaces
+ * - CompliancePolicyFilter, ComplianceRuleFilter, etc. — compliance filter interfaces
+ * - drizzleRows, drizzleCount — Drizzle result type helpers
+ */
+// Database
+export * from './database/index.js';
+// Query builders and services
+export * from './api/query-builders.js';
+export * from './api/access-control-builder.js';
+export * from './api/viewer-context.js';
+export * from './api/crud-service.js';
+export * from './api/soft-delete-sweep.js';
+export * from './api/reporting-service.js';
+// Filters
+export * from './core/query-filters.js';
+//# sourceMappingURL=data:application/json;base64,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