@pipeline-builder/pipeline-data 4.1.22 → 4.1.23

package/lib/api/reporting/ingest.js

@@ -0,0 +1,210 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Event ingest: the WRITE half of reporting. Resolves incoming pipeline events
+ * against the pipeline registry, scrubs every free-form string, batch-inserts
+ * the matched rows idempotently, and invalidates the affected orgs' report
+ * caches. Separate from the report queries because this is reporting's only
+ * durable persistence boundary — everything else in the service only reads.
+ */
+import { createLogger, errorMessage, scrubAwsIdentifiers } from '@pipeline-builder/api-core';
+import { inArray } from 'drizzle-orm';
+import { invalidateOrgReports } from './caches.js';
+import { scrubOptional } from './sql-helpers.js';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx } from '../../database/tenancy.js';
+const logger = createLogger('reporting-ingest');
+/** An action/build event that can be attributed to a plugin step. */
+function isAttributable(e) {
+    return (e.eventType === 'ACTION' || e.eventType === 'BUILD')
+        && (e.eventSource === 'codepipeline' || e.eventSource === 'codebuild')
+        && !!e.stageName && !!e.actionName;
+}
+function stepKey(pipelineId, stageName, actionName) {
+    return `${pipelineId}\u0000${stageName}\u0000${actionName}`;
+}
+/**
+ * Plugin attribution: the step manifests of every pipeline with an attributable
+ * event, in ONE read per batch, keyed for an in-memory join. Names are compared
+ * post-scrub on both sides (the manifest stores them scrubbed the same way).
+ */
+async function loadStepPlugins(tx, attributable) {
+    const pipelineIds = [...new Set(attributable.map((e) => e.pipelineId))];
+    if (pipelineIds.length === 0)
+        return new Map();
+    const rows = await tx
+        .select({
+        pipelineId: schema.pipelineStepManifest.pipelineId,
+        orgId: schema.pipelineStepManifest.orgId,
+        stageName: schema.pipelineStepManifest.stageName,
+        actionName: schema.pipelineStepManifest.actionName,
+        pluginPublisher: schema.pipelineStepManifest.pluginPublisher,
+        pluginPublisherId: schema.pipelineStepManifest.pluginPublisherId,
+        pluginName: schema.pipelineStepManifest.pluginName,
+        pluginVersion: schema.pipelineStepManifest.pluginVersion,
+    })
+        .from(schema.pipelineStepManifest)
+        .where(inArray(schema.pipelineStepManifest.pipelineId, pipelineIds));
+    return new Map(rows.map((m) => [stepKey(m.pipelineId, m.stageName, m.actionName), m]));
+}
+/**
+ * The persisted row for one ingested event. This is the DURABLE persistence
+ * boundary: every user/AWS-derived free-form string is scrubbed here, and
+ * tenancy comes from the pipeline registry, never the caller's claimed org.
+ */
+function toEventRow(event, registry, plugin) {
+    return {
+        // registry.pipelineId === event.pipelineId; the registry's is always a row
+        // that exists (FK) and its orgId is the trusted tenant.
+        pipelineId: registry.pipelineId,
+        orgId: registry.orgId,
+        eventSource: event.eventSource,
+        eventType: event.eventType,
+        status: event.status,
+        // An AWS-ASSIGNED UUID, not free-form text: it can't carry an account id,
+        // and scrubbing a 12-digit run inside it would corrupt the correlation key.
+        executionId: event.executionId,
+        // USER-AUTHORED pipeline-structure names — same untrusted origin as
+        // errorMessage, so scrubbed (a stage named with an ARN must not persist).
+        stageName: scrubOptional(event.stageName),
+        actionName: scrubOptional(event.actionName),
+        // HARD CONSTRAINT: an AWS account id must NEVER be persisted. Failure detail
+        // and messages routinely carry ARNs and bare 12-digit account ids.
+        errorMessage: scrubOptional(event.errorMessage),
+        startedAt: event.startedAt ? new Date(event.startedAt) : undefined,
+        completedAt: event.completedAt ? new Date(event.completedAt) : undefined,
+        durationMs: event.durationMs,
+        // Deploy attribution — scrubbed like the other free-form strings.
+        commitSha: scrubOptional(event.commitSha),
+        commitRef: scrubOptional(event.commitRef),
+        environment: scrubOptional(event.environment),
+        // Measured lead time: the oldest unshipped commit's time + the count. An
+        // SCM-derived instant and a plain integer — nothing to scrub.
+        commitTimestamp: event.commitTimestamp ? new Date(event.commitTimestamp) : undefined,
+        commitCount: event.commitCount,
+        // NULL for non-plugin actions and for pipelines deployed without a manifest.
+        pluginPublisher: plugin?.pluginPublisher ?? null,
+        pluginPublisherId: plugin?.pluginPublisherId ?? null,
+        pluginName: plugin?.pluginName ?? null,
+        pluginVersion: plugin?.pluginVersion ?? null,
+        detail: event.detail !== undefined ? scrubAwsIdentifiers(event.detail) : undefined,
+    };
+}
+/**
+ * Fan terminal STAGE outcomes into the route's metric hook (pipeline-data can't
+ * import api-server's registry) after the insert commits. Driven off the
+ * INSERTED rows, so a re-delivered event the dedup index swallowed is never
+ * counted twice. A non-null environment marks a deploy.
+ */
+function emitStageMetrics(rows, onMetric) {
+    for (const r of rows) {
+        if (r.eventType !== 'STAGE' || (r.status !== 'SUCCEEDED' && r.status !== 'FAILED') || !r.pipelineId)
+            continue;
+        onMetric({
+            pipelineId: r.pipelineId,
+            orgId: r.orgId,
+            stage: r.stageName ?? '',
+            environment: r.environment ?? null,
+            result: r.status === 'SUCCEEDED' ? 'succeeded' : 'failed',
+        });
+    }
+}
+/**
+ * Resolve incoming events against the pipeline registry, batch-insert the
+ * matched ones, and invalidate reporting caches for affected orgs.
+ * Events for unregistered pipeline ids are dropped (and logged at WARN
+ * with sample ids so an operator can see when EventBridge is delivering
+ * events for pipelines that haven't called POST /pipelines/registry yet).
+ *
+ * Returns counts + a sample of unregistered pipeline ids for observability.
+ */
+export async function ingestEvents(events, onMetric) {
+    // Multi-org batch insert: the caller resolves to multiple orgs via the
+    // pipeline-registry lookup below, so the route layer MUST establish a
+    // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling
+    // this function. Under FORCE'd RLS, a single tx with `app.org_id = <one
+    // org>` could only write events for that org; bypass via sysadmin is
+    // the right gate for this server-internal cross-tenant endpoint. See
+    // api/reporting/src/routes/event-ingest.ts for the wrapper.
+    // Caches are invalidated AFTER the tx resolves: doing it inside held the pg
+    // locks open across unrelated cache round-trips. The TTL is 2-5 min, so a
+    // fire-and-forget post-commit invalidation is an acceptable trade.
+    const { inserted, skipped, unregisteredPipelineIds, affectedOrgs, insertedRows } = await withTenantTx(async (tx) => {
+        // Batch-resolve all unique pipeline ids in one query
+        const uniqueIds = [...new Set(events.map(e => e.pipelineId))];
+        const registryRows = await tx
+            .select({
+            pipelineId: schema.pipelineRegistry.pipelineId,
+            orgId: schema.pipelineRegistry.orgId,
+        })
+            .from(schema.pipelineRegistry)
+            .where(inArray(schema.pipelineRegistry.pipelineId, uniqueIds));
+        const idMap = new Map(registryRows.map(r => [r.pipelineId, r]));
+        const stepPlugins = await loadStepPlugins(tx, events.filter((e) => isAttributable(e) && idMap.has(e.pipelineId)));
+        // Build insert batch (skip events whose pipeline isn't registered)
+        const rows = [];
+        let skippedLocal = 0;
+        const unregisteredLocal = [];
+        for (const event of events) {
+            const registry = idMap.get(event.pipelineId);
+            if (!registry) {
+                skippedLocal++;
+                unregisteredLocal.push(event.pipelineId);
+                continue;
+            }
+            const stageName = scrubOptional(event.stageName);
+            const actionName = scrubOptional(event.actionName);
+            const step = isAttributable(event) && stageName && actionName
+                ? stepPlugins.get(stepKey(registry.pipelineId, stageName, actionName))
+                : undefined;
+            // Same-org guard: a manifest row is only ever written by the org that
+            // owns the pipeline, but the ingest runs cross-tenant, so don't lean on it.
+            rows.push(toEventRow(event, registry, step && step.orgId === registry.orgId ? step : undefined));
+        }
+        // SQS is at-least-once, so EventBridge can deliver the same state-change
+        // twice. `onConflictDoNothing` + the partial unique index on
+        // (pipeline_id, execution_id, event_type, status, stage_name, action_name)
+        // makes re-delivery idempotent. `returning` gives the REAL inserted set so
+        // counts, metrics and cache invalidation all ignore duplicates.
+        const landed = rows.length > 0
+            ? await tx.insert(schema.pipelineEvent).values(rows)
+                .onConflictDoNothing()
+                .returning({
+                orgId: schema.pipelineEvent.orgId,
+                pipelineId: schema.pipelineEvent.pipelineId,
+                eventType: schema.pipelineEvent.eventType,
+                status: schema.pipelineEvent.status,
+                stageName: schema.pipelineEvent.stageName,
+                environment: schema.pipelineEvent.environment,
+            })
+            : [];
+        return {
+            inserted: landed.length,
+            skipped: skippedLocal,
+            unregisteredPipelineIds: unregisteredLocal,
+            affectedOrgs: [...new Set(landed.map(r => r.orgId))],
+            insertedRows: landed,
+        };
+    });
+    if (onMetric)
+        emitStageMetrics(insertedRows, onMetric);
+    // Surface the silent skip: an unregistered pipeline id usually means the
+    // pipeline hasn't called POST /pipelines/registry yet (or its
+    // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it
+    // makes a broken join visible instead of looking like "no activity".
+    if (unregisteredPipelineIds.length > 0) {
+        logger.warn('Pipeline events skipped: pipeline id not found in registry', {
+            count: unregisteredPipelineIds.length,
+            sample: unregisteredPipelineIds.slice(0, 3),
+        });
+    }
+    // Post-commit cache invalidation. Fire-and-forget with logging — TTL is
+    // short enough that a missed invalidation self-heals.
+    if (affectedOrgs.length > 0) {
+        void Promise.all(affectedOrgs.map((org) => invalidateOrgReports(org).catch((err) => {
+            logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });
+        })));
+    }
+    return { inserted, skipped, unregisteredPipelineIds, affectedOrgs };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ingest.js","sourceRoot":"","sources":["../../../src/api/reporting/ingest.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Event ingest: the WRITE half of reporting. Resolves incoming pipeline events\n * against the pipeline registry, scrubs every free-form string, batch-inserts\n * the matched rows idempotently, and invalidates the affected orgs' report\n * caches. Separate from the report queries because this is reporting's only\n * durable persistence boundary — everything else in the service only reads.\n */\n\nimport { createLogger, errorMessage, scrubAwsIdentifiers } from '@pipeline-builder/api-core';\nimport { inArray } from 'drizzle-orm';\nimport { invalidateOrgReports } from './caches.js';\nimport { scrubOptional } from './sql-helpers.js';\nimport type { IngestEvent, IngestMetric, IngestResult } from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { withTenantTx } from '../../database/tenancy.js';\nimport type { CrudTx } from '../crud-service.js';\n\nconst logger = createLogger('reporting-ingest');\n\ntype PipelineEventInsert = typeof schema.pipelineEvent.$inferInsert;\n\n\n/** The plugin a pipeline step runs, from the step manifest its last deploy registered. */\ninterface StepPlugin {\n  orgId: string;\n  pluginPublisher: string | null;\n  pluginPublisherId: string | null;\n  pluginName: string | null;\n  pluginVersion: string | null;\n}\n\n/** An action/build event that can be attributed to a plugin step. */\nfunction isAttributable(e: IngestEvent): boolean {\n  return (e.eventType === 'ACTION' || e.eventType === 'BUILD')\n    && (e.eventSource === 'codepipeline' || e.eventSource === 'codebuild')\n    && !!e.stageName && !!e.actionName;\n}\n\nfunction stepKey(pipelineId: string, stageName: string, actionName: string): string {\n  return `${pipelineId}\\u0000${stageName}\\u0000${actionName}`;\n}\n\n/**\n * Plugin attribution: the step manifests of every pipeline with an attributable\n * event, in ONE read per batch, keyed for an in-memory join. Names are compared\n * post-scrub on both sides (the manifest stores them scrubbed the same way).\n */\nasync function loadStepPlugins(tx: CrudTx, attributable: IngestEvent[]): Promise<Map<string, StepPlugin>> {\n  const pipelineIds = [...new Set(attributable.map((e) => e.pipelineId))];\n  if (pipelineIds.length === 0) return new Map();\n  const rows = await tx\n    .select({\n      pipelineId: schema.pipelineStepManifest.pipelineId,\n      orgId: schema.pipelineStepManifest.orgId,\n      stageName: schema.pipelineStepManifest.stageName,\n      actionName: schema.pipelineStepManifest.actionName,\n      pluginPublisher: schema.pipelineStepManifest.pluginPublisher,\n      pluginPublisherId: schema.pipelineStepManifest.pluginPublisherId,\n      pluginName: schema.pipelineStepManifest.pluginName,\n      pluginVersion: schema.pipelineStepManifest.pluginVersion,\n    })\n    .from(schema.pipelineStepManifest)\n    .where(inArray(schema.pipelineStepManifest.pipelineId, pipelineIds));\n  return new Map(rows.map((m) => [stepKey(m.pipelineId, m.stageName, m.actionName), m]));\n}\n\n/**\n * The persisted row for one ingested event. This is the DURABLE persistence\n * boundary: every user/AWS-derived free-form string is scrubbed here, and\n * tenancy comes from the pipeline registry, never the caller's claimed org.\n */\nfunction toEventRow(event: IngestEvent, registry: { pipelineId: string; orgId: string }, plugin: StepPlugin | undefined): PipelineEventInsert {\n  return {\n    // registry.pipelineId === event.pipelineId; the registry's is always a row\n    // that exists (FK) and its orgId is the trusted tenant.\n    pipelineId: registry.pipelineId,\n    orgId: registry.orgId,\n    eventSource: event.eventSource,\n    eventType: event.eventType,\n    status: event.status,\n    // An AWS-ASSIGNED UUID, not free-form text: it can't carry an account id,\n    // and scrubbing a 12-digit run inside it would corrupt the correlation key.\n    executionId: event.executionId,\n    // USER-AUTHORED pipeline-structure names — same untrusted origin as\n    // errorMessage, so scrubbed (a stage named with an ARN must not persist).\n    stageName: scrubOptional(event.stageName),\n    actionName: scrubOptional(event.actionName),\n    // HARD CONSTRAINT: an AWS account id must NEVER be persisted. Failure detail\n    // and messages routinely carry ARNs and bare 12-digit account ids.\n    errorMessage: scrubOptional(event.errorMessage),\n    startedAt: event.startedAt ? new Date(event.startedAt) : undefined,\n    completedAt: event.completedAt ? new Date(event.completedAt) : undefined,\n    durationMs: event.durationMs,\n    // Deploy attribution — scrubbed like the other free-form strings.\n    commitSha: scrubOptional(event.commitSha),\n    commitRef: scrubOptional(event.commitRef),\n    environment: scrubOptional(event.environment),\n    // Measured lead time: the oldest unshipped commit's time + the count. An\n    // SCM-derived instant and a plain integer — nothing to scrub.\n    commitTimestamp: event.commitTimestamp ? new Date(event.commitTimestamp) : undefined,\n    commitCount: event.commitCount,\n    // NULL for non-plugin actions and for pipelines deployed without a manifest.\n    pluginPublisher: plugin?.pluginPublisher ?? null,\n    pluginPublisherId: plugin?.pluginPublisherId ?? null,\n    pluginName: plugin?.pluginName ?? null,\n    pluginVersion: plugin?.pluginVersion ?? null,\n    detail: event.detail !== undefined ? scrubAwsIdentifiers(event.detail) : undefined,\n  };\n}\n\n/**\n * Fan terminal STAGE outcomes into the route's metric hook (pipeline-data can't\n * import api-server's registry) after the insert commits. Driven off the\n * INSERTED rows, so a re-delivered event the dedup index swallowed is never\n * counted twice. A non-null environment marks a deploy.\n */\nfunction emitStageMetrics(\n  rows: ReadonlyArray<{ orgId: string; pipelineId: string | null; eventType: string; status: string; stageName: string | null; environment: string | null }>,\n  onMetric: (m: IngestMetric) => void,\n): void {\n  for (const r of rows) {\n    if (r.eventType !== 'STAGE' || (r.status !== 'SUCCEEDED' && r.status !== 'FAILED') || !r.pipelineId) continue;\n    onMetric({\n      pipelineId: r.pipelineId,\n      orgId: r.orgId,\n      stage: r.stageName ?? '',\n      environment: r.environment ?? null,\n      result: r.status === 'SUCCEEDED' ? 'succeeded' : 'failed',\n    });\n  }\n}\n\n/**\n * Resolve incoming events against the pipeline registry, batch-insert the\n * matched ones, and invalidate reporting caches for affected orgs.\n * Events for unregistered pipeline ids are dropped (and logged at WARN\n * with sample ids so an operator can see when EventBridge is delivering\n * events for pipelines that haven't called POST /pipelines/registry yet).\n *\n * Returns counts + a sample of unregistered pipeline ids for observability.\n */\nexport async function ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult> {\n  // Multi-org batch insert: the caller resolves to multiple orgs via the\n  // pipeline-registry lookup below, so the route layer MUST establish a\n  // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling\n  // this function. Under FORCE'd RLS, a single tx with `app.org_id = <one\n  // org>` could only write events for that org; bypass via sysadmin is\n  // the right gate for this server-internal cross-tenant endpoint. See\n  // api/reporting/src/routes/event-ingest.ts for the wrapper.\n  // Caches are invalidated AFTER the tx resolves: doing it inside held the pg\n  // locks open across unrelated cache round-trips. The TTL is 2-5 min, so a\n  // fire-and-forget post-commit invalidation is an acceptable trade.\n  const { inserted, skipped, unregisteredPipelineIds, affectedOrgs, insertedRows } = await withTenantTx(async (tx) => {\n    // Batch-resolve all unique pipeline ids in one query\n    const uniqueIds = [...new Set(events.map(e => e.pipelineId))];\n    const registryRows = await tx\n      .select({\n        pipelineId: schema.pipelineRegistry.pipelineId,\n        orgId: schema.pipelineRegistry.orgId,\n      })\n      .from(schema.pipelineRegistry)\n      .where(inArray(schema.pipelineRegistry.pipelineId, uniqueIds));\n\n    const idMap = new Map(registryRows.map(r => [r.pipelineId, r]));\n    const stepPlugins = await loadStepPlugins(tx, events.filter((e) => isAttributable(e) && idMap.has(e.pipelineId)));\n\n    // Build insert batch (skip events whose pipeline isn't registered)\n    const rows: PipelineEventInsert[] = [];\n    let skippedLocal = 0;\n    const unregisteredLocal: string[] = [];\n\n    for (const event of events) {\n      const registry = idMap.get(event.pipelineId);\n      if (!registry) {\n        skippedLocal++;\n        unregisteredLocal.push(event.pipelineId);\n        continue;\n      }\n      const stageName = scrubOptional(event.stageName);\n      const actionName = scrubOptional(event.actionName);\n      const step = isAttributable(event) && stageName && actionName\n        ? stepPlugins.get(stepKey(registry.pipelineId, stageName, actionName))\n        : undefined;\n      // Same-org guard: a manifest row is only ever written by the org that\n      // owns the pipeline, but the ingest runs cross-tenant, so don't lean on it.\n      rows.push(toEventRow(event, registry, step && step.orgId === registry.orgId ? step : undefined));\n    }\n\n    // SQS is at-least-once, so EventBridge can deliver the same state-change\n    // twice. `onConflictDoNothing` + the partial unique index on\n    // (pipeline_id, execution_id, event_type, status, stage_name, action_name)\n    // makes re-delivery idempotent. `returning` gives the REAL inserted set so\n    // counts, metrics and cache invalidation all ignore duplicates.\n    const landed = rows.length > 0\n      ? await tx.insert(schema.pipelineEvent).values(rows)\n        .onConflictDoNothing()\n        .returning({\n          orgId: schema.pipelineEvent.orgId,\n          pipelineId: schema.pipelineEvent.pipelineId,\n          eventType: schema.pipelineEvent.eventType,\n          status: schema.pipelineEvent.status,\n          stageName: schema.pipelineEvent.stageName,\n          environment: schema.pipelineEvent.environment,\n        })\n      : [];\n\n    return {\n      inserted: landed.length,\n      skipped: skippedLocal,\n      unregisteredPipelineIds: unregisteredLocal,\n      affectedOrgs: [...new Set(landed.map(r => r.orgId))],\n      insertedRows: landed,\n    };\n  });\n\n  if (onMetric) emitStageMetrics(insertedRows, onMetric);\n\n  // Surface the silent skip: an unregistered pipeline id usually means the\n  // pipeline hasn't called POST /pipelines/registry yet (or its\n  // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it\n  // makes a broken join visible instead of looking like \"no activity\".\n  if (unregisteredPipelineIds.length > 0) {\n    logger.warn('Pipeline events skipped: pipeline id not found in registry', {\n      count: unregisteredPipelineIds.length,\n      sample: unregisteredPipelineIds.slice(0, 3),\n    });\n  }\n\n  // Post-commit cache invalidation. Fire-and-forget with logging — TTL is\n  // short enough that a missed invalidation self-heals.\n  if (affectedOrgs.length > 0) {\n    void Promise.all(affectedOrgs.map((org) =>\n      invalidateOrgReports(org).catch((err) => {\n        logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });\n      }),\n    ));\n  }\n\n  return { inserted, skipped, unregisteredPipelineIds, affectedOrgs };\n}\n"]}

package/lib/api/reporting/retention-sweep.d.ts

@@ -0,0 +1,17 @@
+import type { ReportingRetentionCounts, ReportingRetentionOptions } from './types.js';
+/**
+ * Reporting retention sweep. Hard-deletes rows older than their
+ * retention window, by `created_at`, across every org that has reporting data —
+ * a **split** policy so high-volume standard events expire faster than the
+ * low-volume DORA source:
+ *  - `pipeline_events WHERE environment IS NULL` → standard-event window.
+ *  - `pipeline_events WHERE environment IS NOT NULL` (deploy stages),
+ *    `deployment_outcomes`, and `incidents` → DORA-source window.
+ * Each org's windows come from its `dora_settings` override, else the global
+ * env defaults (see {@link resolveEventRetentionDays} / {@link resolveDoraRetentionDays}).
+ * `ingest_health` and `dora_settings` are never purged. One `now` for the whole
+ * tick (rows crossing the boundary mid-sweep wait for the next). Establishes a
+ * sysadmin tenant scope so the deletes span all orgs / bypass RLS — this is a
+ * cross-tenant housekeeping job. Returns (and logs) per-window purge tallies.
+ */
+export declare function purgeExpiredReportingData(opts?: ReportingRetentionOptions): Promise<ReportingRetentionCounts>;

package/lib/api/reporting/retention-sweep.js

@@ -0,0 +1,155 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The reporting retention SWEEP: the batched hard-delete that enforces the
+ * windows `./retention.ts` resolves. Split from the windows module so the pure,
+ * env-only policy stays free of database code, and from the reporting service
+ * because this is cross-tenant housekeeping, not a report.
+ */
+import { createLogger, errorMessage } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { resolveEventRetentionDays, resolveDoraRetentionDays, retentionCutoff } from './retention.js';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx, runWithTenantContext } from '../../database/tenancy.js';
+import { drizzleRows } from '../crud-service.js';
+const logger = createLogger('reporting-retention');
+/**
+ * Batched hard-DELETE of one reporting table's rows expired past a `created_at`
+ * cutoff, scoped to an org and an optional row predicate. Uses a
+ * `ctid`-in-subquery LIMIT so each statement touches at most `batchSize` rows
+ * (short lock windows, no long table scan under lock); `RETURNING 1` lets us
+ * count via `.rows.length` without depending on the driver's `rowCount`. Loops
+ * until a short batch (drained) or the per-tick cap, then defers the rest.
+ * MUST run inside a sysadmin tenant scope (see purgeExpiredReportingData) so it
+ * bypasses RLS and can delete across the org's rows.
+ */
+async function purgeReportingTableBatched(tableSql, predicate, batchSize, maxBatches) {
+    let total = 0;
+    for (let i = 0; i < maxBatches; i++) {
+        const res = await withTenantTx((tx) => tx.execute(sql `
+      DELETE FROM ${tableSql}
+      WHERE ctid IN (
+        SELECT ctid FROM ${tableSql}
+        WHERE ${predicate}
+        LIMIT ${batchSize}
+      )
+      RETURNING 1
+    `));
+        const purged = drizzleRows(res.rows).length;
+        total += purged;
+        if (purged < batchSize)
+            break; // drained
+        if (i === maxBatches - 1) {
+            logger.warn('Reporting retention hit per-tick cap; remaining rows deferred', {
+                purgedThisTick: total,
+            });
+        }
+    }
+    return total;
+}
+/**
+ * Reporting retention sweep. Hard-deletes rows older than their
+ * retention window, by `created_at`, across every org that has reporting data —
+ * a **split** policy so high-volume standard events expire faster than the
+ * low-volume DORA source:
+ *  - `pipeline_events WHERE environment IS NULL` → standard-event window.
+ *  - `pipeline_events WHERE environment IS NOT NULL` (deploy stages),
+ *    `deployment_outcomes`, and `incidents` → DORA-source window.
+ * Each org's windows come from its `dora_settings` override, else the global
+ * env defaults (see {@link resolveEventRetentionDays} / {@link resolveDoraRetentionDays}).
+ * `ingest_health` and `dora_settings` are never purged. One `now` for the whole
+ * tick (rows crossing the boundary mid-sweep wait for the next). Establishes a
+ * sysadmin tenant scope so the deletes span all orgs / bypass RLS — this is a
+ * cross-tenant housekeeping job. Returns (and logs) per-window purge tallies.
+ */
+export async function purgeExpiredReportingData(opts = {}) {
+    const batchSize = Math.max(1, opts.batchSize ?? 1000);
+    const maxBatches = Math.max(1, opts.maxBatchesPerTable ?? 50);
+    const now = opts.now ?? new Date();
+    const resolveRetentionOrgId = opts.resolveRetentionOrgId ?? (async (orgId) => orgId);
+    const counts = {
+        orgs: 0, standardEvents: 0, doraEvents: 0, deploymentOutcomes: 0, incidents: 0,
+    };
+    return runWithTenantContext({ isSuperAdmin: true }, async () => {
+        // Enumerate every org with reporting data (union across the three tables).
+        const orgRows = drizzleRows((await withTenantTx((tx) => tx.execute(sql `
+      SELECT DISTINCT org_id FROM (
+        SELECT ${schema.pipelineEvent.orgId} AS org_id FROM ${schema.pipelineEvent}
+        UNION
+        SELECT ${schema.deploymentOutcome.orgId} AS org_id FROM ${schema.deploymentOutcome}
+        UNION
+        SELECT ${schema.incident.orgId} AS org_id FROM ${schema.incident}
+      ) AS orgs
+    `))).rows);
+        if (orgRows.length === 0)
+            return counts;
+        // Per-org retention overrides (a single read; orgs without a row use defaults).
+        const overrideRows = drizzleRows((await withTenantTx((tx) => tx.execute(sql `
+      SELECT ${schema.doraSettings.orgId} AS org_id,
+             ${schema.doraSettings.eventRetentionDays} AS event_retention_days,
+             ${schema.doraSettings.doraRetentionDays} AS dora_retention_days
+      FROM ${schema.doraSettings}
+    `))).rows);
+        const overrides = new Map(overrideRows.map((r) => [r.org_id, r]));
+        const eventsTable = sql `${schema.pipelineEvent}`;
+        const outcomesTable = sql `${schema.deploymentOutcome}`;
+        const incidentsTable = sql `${schema.incident}`;
+        for (const { org_id: orgId } of orgRows) {
+            // Retention follows the account ROOT's entitlement (billing syncs it onto
+            // the root only). An unresolvable root ⇒ skip this org this tick rather
+            // than purge a team's rows on the (shorter) env default.
+            let retentionOrgId;
+            try {
+                retentionOrgId = await resolveRetentionOrgId(orgId);
+            }
+            catch (err) {
+                logger.warn('Reporting retention: root resolution threw; skipping org this tick', { orgId, error: errorMessage(err) });
+                retentionOrgId = null;
+            }
+            if (retentionOrgId === null) {
+                logger.warn('Reporting retention: could not resolve the retention root; org skipped this tick', { orgId });
+                continue;
+            }
+            const ov = overrides.get(retentionOrgId);
+            const eventDays = resolveEventRetentionDays(ov?.event_retention_days);
+            const doraDays = resolveDoraRetentionDays(ov?.dora_retention_days);
+            // `-1` = unlimited: keep forever, skip that window's deletes for
+            // this org. Standard-event and DORA-source windows are independent; an org
+            // with both `-1` is fully skipped. Log the skip so it's observable.
+            const skipEvents = eventDays === -1;
+            const skipDora = doraDays === -1;
+            if (skipEvents || skipDora) {
+                logger.info('Reporting retention sweep skipping unlimited window(s)', {
+                    orgId,
+                    standardEvents: skipEvents ? 'unlimited' : eventDays,
+                    doraSource: skipDora ? 'unlimited' : doraDays,
+                });
+            }
+            if (!skipEvents) {
+                const eventCutoff = retentionCutoff(now, eventDays);
+                counts.standardEvents += await purgeReportingTableBatched(eventsTable, 
+                // Spare rows carrying a commit timestamp: they are DORA SOURCE data.
+                // Lead time joins deploys to the execution's earliest
+                // `commit_timestamp`, and that enrichment rides the PIPELINE/source
+                // event (environment IS NULL), never the deploy STAGE row. Purging
+                // them on this short window while the deploys they explain live on
+                // the DORA window made lead time read "unknown" for every range
+                // older than the standard retention — silently, with the deploys
+                // still counted. They follow the DORA window below instead.
+                sql `org_id = ${orgId} AND environment IS NULL AND commit_timestamp IS NULL AND created_at < ${eventCutoff}`, batchSize, maxBatches);
+            }
+            if (!skipDora) {
+                const doraCutoff = retentionCutoff(now, doraDays);
+                counts.doraEvents += await purgeReportingTableBatched(eventsTable, sql `org_id = ${orgId} AND (environment IS NOT NULL OR commit_timestamp IS NOT NULL) AND created_at < ${doraCutoff}`, batchSize, maxBatches);
+                counts.deploymentOutcomes += await purgeReportingTableBatched(outcomesTable, sql `org_id = ${orgId} AND created_at < ${doraCutoff}`, batchSize, maxBatches);
+                counts.incidents += await purgeReportingTableBatched(incidentsTable, sql `org_id = ${orgId} AND created_at < ${doraCutoff}`, batchSize, maxBatches);
+            }
+            counts.orgs += 1;
+        }
+        const purgedAny = counts.standardEvents + counts.doraEvents + counts.deploymentOutcomes + counts.incidents;
+        if (purgedAny > 0)
+            logger.info('Reporting retention sweep purged expired rows', { ...counts });
+        return counts;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retention-sweep.js","sourceRoot":"","sources":["../../../src/api/reporting/retention-sweep.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The reporting retention SWEEP: the batched hard-delete that enforces the\n * windows `./retention.ts` resolves. Split from the windows module so the pure,\n * env-only policy stays free of database code, and from the reporting service\n * because this is cross-tenant housekeeping, not a report.\n */\n\nimport { createLogger, errorMessage } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { resolveEventRetentionDays, resolveDoraRetentionDays, retentionCutoff } from './retention.js';\nimport type { ReportingRetentionCounts, ReportingRetentionOptions } from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { withTenantTx, runWithTenantContext } from '../../database/tenancy.js';\nimport { drizzleRows } from '../crud-service.js';\n\nconst logger = createLogger('reporting-retention');\n\n/**\n * Batched hard-DELETE of one reporting table's rows expired past a `created_at`\n * cutoff, scoped to an org and an optional row predicate. Uses a\n * `ctid`-in-subquery LIMIT so each statement touches at most `batchSize` rows\n * (short lock windows, no long table scan under lock); `RETURNING 1` lets us\n * count via `.rows.length` without depending on the driver's `rowCount`. Loops\n * until a short batch (drained) or the per-tick cap, then defers the rest.\n * MUST run inside a sysadmin tenant scope (see purgeExpiredReportingData) so it\n * bypasses RLS and can delete across the org's rows.\n */\nasync function purgeReportingTableBatched(\n  tableSql: ReturnType<typeof sql>,\n  predicate: ReturnType<typeof sql>,\n  batchSize: number,\n  maxBatches: number,\n): Promise<number> {\n  let total = 0;\n  for (let i = 0; i < maxBatches; i++) {\n    const res = await withTenantTx((tx) => tx.execute(sql`\n      DELETE FROM ${tableSql}\n      WHERE ctid IN (\n        SELECT ctid FROM ${tableSql}\n        WHERE ${predicate}\n        LIMIT ${batchSize}\n      )\n      RETURNING 1\n    `));\n    const purged = drizzleRows<unknown>(res.rows).length;\n    total += purged;\n    if (purged < batchSize) break; // drained\n    if (i === maxBatches - 1) {\n      logger.warn('Reporting retention hit per-tick cap; remaining rows deferred', {\n        purgedThisTick: total,\n      });\n    }\n  }\n  return total;\n}\n\n/**\n * Reporting retention sweep. Hard-deletes rows older than their\n * retention window, by `created_at`, across every org that has reporting data —\n * a **split** policy so high-volume standard events expire faster than the\n * low-volume DORA source:\n *  - `pipeline_events WHERE environment IS NULL` → standard-event window.\n *  - `pipeline_events WHERE environment IS NOT NULL` (deploy stages),\n *    `deployment_outcomes`, and `incidents` → DORA-source window.\n * Each org's windows come from its `dora_settings` override, else the global\n * env defaults (see {@link resolveEventRetentionDays} / {@link resolveDoraRetentionDays}).\n * `ingest_health` and `dora_settings` are never purged. One `now` for the whole\n * tick (rows crossing the boundary mid-sweep wait for the next). Establishes a\n * sysadmin tenant scope so the deletes span all orgs / bypass RLS — this is a\n * cross-tenant housekeeping job. Returns (and logs) per-window purge tallies.\n */\nexport async function purgeExpiredReportingData(opts: ReportingRetentionOptions = {}): Promise<ReportingRetentionCounts> {\n  const batchSize = Math.max(1, opts.batchSize ?? 1000);\n  const maxBatches = Math.max(1, opts.maxBatchesPerTable ?? 50);\n  const now = opts.now ?? new Date();\n  const resolveRetentionOrgId = opts.resolveRetentionOrgId ?? (async (orgId: string) => orgId);\n  const counts: ReportingRetentionCounts = {\n    orgs: 0, standardEvents: 0, doraEvents: 0, deploymentOutcomes: 0, incidents: 0,\n  };\n\n  return runWithTenantContext({ isSuperAdmin: true }, async () => {\n    // Enumerate every org with reporting data (union across the three tables).\n    const orgRows = drizzleRows<{ org_id: string }>((await withTenantTx((tx) => tx.execute(sql`\n      SELECT DISTINCT org_id FROM (\n        SELECT ${schema.pipelineEvent.orgId} AS org_id FROM ${schema.pipelineEvent}\n        UNION\n        SELECT ${schema.deploymentOutcome.orgId} AS org_id FROM ${schema.deploymentOutcome}\n        UNION\n        SELECT ${schema.incident.orgId} AS org_id FROM ${schema.incident}\n      ) AS orgs\n    `))).rows);\n    if (orgRows.length === 0) return counts;\n\n    // Per-org retention overrides (a single read; orgs without a row use defaults).\n    const overrideRows = drizzleRows<{\n      org_id: string;\n      event_retention_days: number | null;\n      dora_retention_days: number | null;\n    }>((await withTenantTx((tx) => tx.execute(sql`\n      SELECT ${schema.doraSettings.orgId} AS org_id,\n             ${schema.doraSettings.eventRetentionDays} AS event_retention_days,\n             ${schema.doraSettings.doraRetentionDays} AS dora_retention_days\n      FROM ${schema.doraSettings}\n    `))).rows);\n    const overrides = new Map(overrideRows.map((r) => [r.org_id, r]));\n\n    const eventsTable = sql`${schema.pipelineEvent}`;\n    const outcomesTable = sql`${schema.deploymentOutcome}`;\n    const incidentsTable = sql`${schema.incident}`;\n\n    for (const { org_id: orgId } of orgRows) {\n      // Retention follows the account ROOT's entitlement (billing syncs it onto\n      // the root only). An unresolvable root ⇒ skip this org this tick rather\n      // than purge a team's rows on the (shorter) env default.\n      let retentionOrgId: string | null;\n      try {\n        retentionOrgId = await resolveRetentionOrgId(orgId);\n      } catch (err) {\n        logger.warn('Reporting retention: root resolution threw; skipping org this tick', { orgId, error: errorMessage(err) });\n        retentionOrgId = null;\n      }\n      if (retentionOrgId === null) {\n        logger.warn('Reporting retention: could not resolve the retention root; org skipped this tick', { orgId });\n        continue;\n      }\n      const ov = overrides.get(retentionOrgId);\n      const eventDays = resolveEventRetentionDays(ov?.event_retention_days);\n      const doraDays = resolveDoraRetentionDays(ov?.dora_retention_days);\n      // `-1` = unlimited: keep forever, skip that window's deletes for\n      // this org. Standard-event and DORA-source windows are independent; an org\n      // with both `-1` is fully skipped. Log the skip so it's observable.\n      const skipEvents = eventDays === -1;\n      const skipDora = doraDays === -1;\n      if (skipEvents || skipDora) {\n        logger.info('Reporting retention sweep skipping unlimited window(s)', {\n          orgId,\n          standardEvents: skipEvents ? 'unlimited' : eventDays,\n          doraSource: skipDora ? 'unlimited' : doraDays,\n        });\n      }\n\n      if (!skipEvents) {\n        const eventCutoff = retentionCutoff(now, eventDays);\n        counts.standardEvents += await purgeReportingTableBatched(\n          eventsTable,\n          // Spare rows carrying a commit timestamp: they are DORA SOURCE data.\n          // Lead time joins deploys to the execution's earliest\n          // `commit_timestamp`, and that enrichment rides the PIPELINE/source\n          // event (environment IS NULL), never the deploy STAGE row. Purging\n          // them on this short window while the deploys they explain live on\n          // the DORA window made lead time read \"unknown\" for every range\n          // older than the standard retention — silently, with the deploys\n          // still counted. They follow the DORA window below instead.\n          sql`org_id = ${orgId} AND environment IS NULL AND commit_timestamp IS NULL AND created_at < ${eventCutoff}`,\n          batchSize, maxBatches,\n        );\n      }\n\n      if (!skipDora) {\n        const doraCutoff = retentionCutoff(now, doraDays);\n        counts.doraEvents += await purgeReportingTableBatched(\n          eventsTable,\n          sql`org_id = ${orgId} AND (environment IS NOT NULL OR commit_timestamp IS NOT NULL) AND created_at < ${doraCutoff}`,\n          batchSize, maxBatches,\n        );\n        counts.deploymentOutcomes += await purgeReportingTableBatched(\n          outcomesTable,\n          sql`org_id = ${orgId} AND created_at < ${doraCutoff}`,\n          batchSize, maxBatches,\n        );\n        counts.incidents += await purgeReportingTableBatched(\n          incidentsTable,\n          sql`org_id = ${orgId} AND created_at < ${doraCutoff}`,\n          batchSize, maxBatches,\n        );\n      }\n      counts.orgs += 1;\n    }\n\n    const purgedAny = counts.standardEvents + counts.doraEvents + counts.deploymentOutcomes + counts.incidents;\n    if (purgedAny > 0) logger.info('Reporting retention sweep purged expired rows', { ...counts });\n    return counts;\n  });\n}\n"]}

package/lib/api/reporting/retention.d.ts

@@ -1,7 +1,7 @@
 /**
  * Reporting retention windows. Records in `pipeline_events`,
  * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
- * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
+ * split, per-org retention purge (see `purgeExpiredReportingData` in ./retention-sweep.ts)
  * hard-deletes rows older than these windows, by `created_at`:
  *  - **Standard events** — `pipeline_events` with `environment IS NULL`
  *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).

package/lib/api/reporting/retention.js

@@ -8,7 +8,7 @@ import { envInt, RETENTION_MAX_DAYS, RETENTION_MIN_DAYS } from '@pipeline-builde
 /**
  * Reporting retention windows. Records in `pipeline_events`,
  * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
- * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
+ * split, per-org retention purge (see `purgeExpiredReportingData` in ./retention-sweep.ts)
  * hard-deletes rows older than these windows, by `created_at`:
  *  - **Standard events** — `pipeline_events` with `environment IS NULL`
  *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).
@@ -58,4 +58,4 @@ export function retentionCutoff(now, days) {
     return new Date(now.getTime() - days * 86_400_000);
 }
 /** Per-org retention override row. Both nullable ⇒ global defaults. */
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/reporting-service.d.ts

@@ -7,11 +7,8 @@ export declare class ReportingService {
     /**
      * Resolve incoming events against the pipeline registry, batch-insert the
      * matched ones, and invalidate reporting caches for affected orgs.
-     * Events for unregistered pipeline ids are dropped (and logged at WARN
-     * with sample ids so an operator can see when EventBridge is delivering
-     * events for pipelines that haven't called POST /pipelines/registry yet).
-     *
-     * Returns counts + a sample of unregistered pipeline ids for observability.
+     * See ./reporting/ingest.ts — the caller must already hold a sysadmin
+     * tenant scope, because a batch spans whatever orgs the registry resolves to.
      */
     ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult>;
     /** Execution count per pipeline with status breakdown. */
@@ -189,19 +186,9 @@ export declare class ReportingService {
      */
     getIngestHealth(orgId: string): Promise<IngestHealthStatus | null>;
     /**
-     * Reporting retention sweep. Hard-deletes rows older than their
-     * retention window, by `created_at`, across every org that has reporting data —
-     * a **split** policy so high-volume standard events expire faster than the
-     * low-volume DORA source:
-     *  - `pipeline_events WHERE environment IS NULL` → standard-event window.
-     *  - `pipeline_events WHERE environment IS NOT NULL` (deploy stages),
-     *    `deployment_outcomes`, and `incidents` → DORA-source window.
-     * Each org's windows come from its `dora_settings` override, else the global
-     * env defaults (see {@link resolveEventRetentionDays} / {@link resolveDoraRetentionDays}).
-     * `ingest_health` and `dora_settings` are never purged. One `now` for the whole
-     * tick (rows crossing the boundary mid-sweep wait for the next). Establishes a
-     * sysadmin tenant scope so the deletes span all orgs / bypass RLS — this is a
-     * cross-tenant housekeeping job. Returns (and logs) per-window purge tallies.
+     * Reporting retention sweep: hard-deletes rows past their per-org retention
+     * window (split standard-event vs DORA-source). Cross-tenant housekeeping —
+     * it establishes its own sysadmin scope. See ./reporting/retention-sweep.ts.
      */
     purgeExpiredReportingData(opts?: ReportingRetentionOptions): Promise<ReportingRetentionCounts>;
 }