@pipeline-builder/pipeline-data 4.1.23 → 4.1.25

package/lib/api/reporting/plugin-exposure.js

@@ -0,0 +1,312 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * What plugin versions an org's pipelines are actually on, and which of those are
+ * known-vulnerable.
+ *
+ * Two tables, written here, read by the outdated-plugin and vulnerability report
+ * sections:
+ *
+ *  - `pipeline_plugin_resolution` — the DECLARED side. Recomputed on pipeline
+ *    write and on plugin publish, because the alternative is resolving every step
+ *    of every pipeline against the catalog on every read, and that is not a query
+ *    anyone can afford to put in a report.
+ *  - `plugin_vuln_exposure` — the VULNERABLE side, per PIPELINE. A version-level
+ *    table would force every reader to re-derive "which of our pipelines is
+ *    exposed", which is the only form of the question anybody asks.
+ *
+ * DECLARED IS NOT DEPLOYED, and the report says which it is showing. A pipeline's
+ * config declares `^2.0.0`; what ran at its last deploy is whatever the step
+ * manifest recorded, pinned to a digest. Those disagree whenever a pipeline has not
+ * re-synthed since a publish — which is most of the time, and exactly the gap a
+ * vulnerability report is for. Conflating them would let a report say "fixed"
+ * about a pipeline still running the old image.
+ */
+import { randomUUID } from 'node:crypto';
+import { createLogger, errorMessage } from '@pipeline-builder/api-core';
+import { and, eq, inArray, isNull, lte, sql } from 'drizzle-orm';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx } from '../../database/tenancy.js';
+const logger = createLogger('plugin-exposure');
+/** `1.2.3` → `[1, 2, 3]`; anything unparseable → null. */
+function semver(v) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v ?? '');
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+/**
+ * How far `resolved` is behind `latest`.
+ *
+ * `null` when either side is unparseable, NOT `'none'`. "We could not tell" and
+ * "it is up to date" are opposite answers, and reporting the second for the first
+ * is how a pipeline on an ancient pre-release version gets a clean bill of health.
+ */
+export function versionGap(resolved, latest) {
+    const a = semver(resolved);
+    const b = semver(latest);
+    if (!a || !b)
+        return null;
+    if (b[0] > a[0])
+        return 'major';
+    if (b[0] < a[0])
+        return 'none'; // resolved is ahead of "latest" — not behind
+    if (b[1] > a[1])
+        return 'minor';
+    if (b[1] < a[1])
+        return 'none';
+    if (b[2] > a[2])
+        return 'patch';
+    return 'none';
+}
+/**
+ * Replace a pipeline's resolution rows.
+ *
+ * DELETE-then-INSERT for the pipeline, in one transaction, because a step can be
+ * REMOVED from a config: an upsert-only writer would leave the deleted step's row
+ * behind forever, and the outdated-plugin section would keep reporting a step the
+ * pipeline no longer has.
+ */
+export async function replacePipelineResolution(pipelineId, steps) {
+    const values = steps.map((s) => ({
+        orgId: s.orgId,
+        pipelineId: s.pipelineId,
+        stageName: s.stageName,
+        stepName: s.stepName,
+        pluginPublisher: s.pluginPublisher ?? null,
+        pluginName: s.pluginName,
+        declaredVersion: s.declaredVersion ?? null,
+        resolvedVersion: s.resolvedVersion ?? null,
+        latestVersion: s.latestVersion ?? null,
+        versionGap: versionGap(s.resolvedVersion, s.latestVersion),
+        withinPolicy: s.withinPolicy ?? true,
+        computedAt: new Date(),
+    }));
+    return withTenantTx(async (tx) => {
+        await tx.delete(schema.pipelinePluginResolution)
+            .where(eq(schema.pipelinePluginResolution.pipelineId, pipelineId));
+        if (values.length === 0)
+            return 0;
+        const landed = await tx.insert(schema.pipelinePluginResolution).values(values)
+            .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId });
+        return landed.length;
+    });
+}
+/**
+ * Refresh the `latest`/gap columns for one plugin across every pipeline that uses
+ * it, without re-resolving anything else.
+ *
+ * Called on publish. A publish changes what "latest" means for every pipeline in
+ * the instance that declares the plugin, and re-resolving each of those pipelines
+ * from scratch would make publishing cost O(pipelines) work — so only the two
+ * columns a publish can change are touched.
+ */
+export async function refreshLatestForPlugin(pluginName, pluginPublisher, latestVersion) {
+    const rows = await withTenantTx((tx) => tx.update(schema.pipelinePluginResolution)
+        .set({
+        latestVersion,
+        // Recomputed in SQL from the row's own resolved version, so one statement
+        // covers every pipeline rather than a round trip each.
+        // `::text` on every bind of the version: Postgres otherwise deduces
+        // inconsistent types for the same parameter (varchar for the assignment,
+        // text for `split_part`) and refuses to plan the statement.
+        versionGap: sql `CASE
+        WHEN ${schema.pipelinePluginResolution.resolvedVersion} IS NULL THEN NULL
+        WHEN split_part(${latestVersion}::text, '.', 1)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'major'
+        WHEN split_part(${latestVersion}::text, '.', 1)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'none'
+        WHEN split_part(${latestVersion}::text, '.', 2)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'minor'
+        WHEN split_part(${latestVersion}::text, '.', 2)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'none'
+        WHEN split_part(${latestVersion}::text, '.', 3)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 3)::int THEN 'patch'
+        ELSE 'none' END`,
+        computedAt: new Date(),
+    })
+        .where(and(eq(schema.pipelinePluginResolution.pluginName, pluginName), pluginPublisher === null
+        ? isNull(schema.pipelinePluginResolution.pluginPublisher)
+        : eq(schema.pipelinePluginResolution.pluginPublisher, pluginPublisher), 
+    // Only rows whose resolved version parses as semver; anything else has no
+    // gap to compute and the CASE would throw on the cast.
+    sql `${schema.pipelinePluginResolution.resolvedVersion} ~ '^[0-9]+\\.[0-9]+\\.[0-9]+'`))
+        .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId }));
+    return rows.length;
+}
+/**
+ * Open or refresh exposures.
+ *
+ * Upserts on (pipeline, plugin, version, source) so a nightly rescan REFRESHES the
+ * counts rather than opening a new row every night — otherwise the report would
+ * show one exposure per night of the same problem, which reads as an escalating
+ * situation when nothing changed.
+ *
+ * A refresh deliberately does NOT reset `triage_state`: an org that accepted a
+ * finding with a reason and a deadline has made a decision, and re-raising it every
+ * night is how a team learns to ignore the report. It DOES clear a stale
+ * acceptance, because that is what the deadline was for.
+ */
+export async function upsertExposures(inputs, now = new Date()) {
+    if (inputs.length === 0)
+        return 0;
+    const values = inputs.map((e) => ({
+        id: randomUUID(),
+        orgId: e.orgId,
+        pipelineId: e.pipelineId,
+        pluginPublisher: e.pluginPublisher ?? null,
+        pluginName: e.pluginName,
+        pluginVersion: e.pluginVersion,
+        imageDigest: e.imageDigest ?? null,
+        source: e.source,
+        criticalCount: e.criticalCount,
+        highCount: e.highCount,
+        topFindings: e.topFindings ?? [],
+        flaggedAt: now,
+        updatedAt: now,
+    }));
+    try {
+        const landed = await withTenantTx((tx) => tx.insert(schema.pluginVulnExposure).values(values)
+            .onConflictDoUpdate({
+            target: [
+                schema.pluginVulnExposure.pipelineId,
+                schema.pluginVulnExposure.pluginName,
+                schema.pluginVulnExposure.pluginVersion,
+                schema.pluginVulnExposure.source,
+            ],
+            set: {
+                criticalCount: sql `excluded.critical_count`,
+                highCount: sql `excluded.high_count`,
+                topFindings: sql `excluded.top_findings`,
+                imageDigest: sql `COALESCE(excluded.image_digest, ${schema.pluginVulnExposure.imageDigest})`,
+                // Still exposed, so the fix marker is cleared: a row that was closed by a
+                // deploy and is flagged again is a regression, and leaving `fixed_at` set
+                // would hide it.
+                fixedAt: null,
+                // An acceptance past its deadline stops being an acceptance. That is the
+                // entire point of time-boxing it, and it is enforced HERE rather than at
+                // read time so the stored state is the truth.
+                triageState: sql `CASE
+            WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'
+             AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL
+             AND ${schema.pluginVulnExposure.acceptedUntil} <= ${now}
+            THEN 'open'
+            WHEN ${schema.pluginVulnExposure.triageState} = 'fixed' THEN 'open'
+            ELSE ${schema.pluginVulnExposure.triageState} END`,
+                updatedAt: now,
+            },
+        })
+            .returning({ id: schema.pluginVulnExposure.id }));
+        return landed.length;
+    }
+    catch (err) {
+        logger.warn('Plugin exposure upsert failed', { count: values.length, error: errorMessage(err) });
+        return 0;
+    }
+}
+/**
+ * Close the exposures a pipeline has moved off.
+ *
+ * Called when a deploy records a new step manifest: anything flagged for that
+ * pipeline whose version is NOT in the set it now runs is fixed. Closing by
+ * absence rather than waiting for a rescan to notice is what makes "we fixed it"
+ * show up in the report on the next deploy instead of the next night.
+ */
+export async function closeFixedExposures(pipelineId, liveVersions, now = new Date()) {
+    const live = new Set(liveVersions.map((v) => `${v.pluginName}@${v.pluginVersion}`));
+    const open = await withTenantTx((tx) => tx.select({
+        id: schema.pluginVulnExposure.id,
+        pluginName: schema.pluginVulnExposure.pluginName,
+        pluginVersion: schema.pluginVulnExposure.pluginVersion,
+    }).from(schema.pluginVulnExposure)
+        .where(and(eq(schema.pluginVulnExposure.pipelineId, pipelineId), isNull(schema.pluginVulnExposure.fixedAt))));
+    const stale = open
+        .filter((r) => !live.has(`${r.pluginName}@${r.pluginVersion}`))
+        .map((r) => r.id);
+    if (stale.length === 0)
+        return 0;
+    const closed = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)
+        .set({ fixedAt: now, triageState: 'fixed', updatedAt: now })
+        .where(inArray(schema.pluginVulnExposure.id, stale))
+        .returning({ id: schema.pluginVulnExposure.id }));
+    return closed.length;
+}
+/**
+ * The org's live exposures, for the report section.
+ *
+ * `accepted` rows whose deadline has passed come back as OPEN even if no rescan
+ * has refreshed them yet: a read must not present an expired acceptance as a
+ * current one, and the report is read far more often than the rescan runs.
+ */
+export async function openExposures(orgId) {
+    const now = new Date();
+    const rows = await withTenantTx((tx) => tx.select({
+        pipelineId: schema.pluginVulnExposure.pipelineId,
+        pluginName: schema.pluginVulnExposure.pluginName,
+        pluginVersion: schema.pluginVulnExposure.pluginVersion,
+        pluginPublisher: schema.pluginVulnExposure.pluginPublisher,
+        source: schema.pluginVulnExposure.source,
+        criticalCount: schema.pluginVulnExposure.criticalCount,
+        highCount: schema.pluginVulnExposure.highCount,
+        topFindings: schema.pluginVulnExposure.topFindings,
+        triageState: schema.pluginVulnExposure.triageState,
+        acceptedUntil: schema.pluginVulnExposure.acceptedUntil,
+        flaggedAt: schema.pluginVulnExposure.flaggedAt,
+    }).from(schema.pluginVulnExposure)
+        .where(and(eq(schema.pluginVulnExposure.orgId, orgId), isNull(schema.pluginVulnExposure.fixedAt), 
+    // An acceptance that has run out is not an acceptance.
+    sql `(${schema.pluginVulnExposure.triageState} <> 'accepted'
+           OR ${schema.pluginVulnExposure.acceptedUntil} IS NULL
+           OR ${schema.pluginVulnExposure.acceptedUntil} <= ${now})`))
+        .orderBy(sql `${schema.pluginVulnExposure.criticalCount} DESC, ${schema.pluginVulnExposure.highCount} DESC`));
+    return rows.map((r) => ({
+        pipelineId: r.pipelineId,
+        pluginName: r.pluginName,
+        pluginVersion: r.pluginVersion,
+        pluginPublisher: r.pluginPublisher ?? null,
+        source: r.source,
+        criticalCount: r.criticalCount,
+        highCount: r.highCount,
+        topFindings: r.topFindings ?? [],
+        // An expired acceptance reads as open, which is what it is.
+        triageState: r.triageState === 'accepted' && r.acceptedUntil ? 'open' : r.triageState,
+        flaggedAt: r.flaggedAt,
+    }));
+}
+/**
+ * Record a triage decision.
+ *
+ * `accepted` REQUIRES a deadline and a reason. A permanent, unexplained mute is
+ * how a finding stops being anybody's problem, and there is no good reason to
+ * support it — the caller gets an error rather than a silently unbounded
+ * acceptance.
+ */
+export async function triageExposure(orgId, id, decision) {
+    if (decision.state === 'accepted' && (!decision.acceptedUntil || !decision.reason?.trim())) {
+        throw new Error('Accepting a vulnerability exposure needs a reason and an expiry date');
+    }
+    const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)
+        .set({
+        triageState: decision.state,
+        acceptedUntil: decision.state === 'accepted' ? (decision.acceptedUntil ?? null) : null,
+        triageReason: decision.reason ?? null,
+        triagedBy: decision.actor,
+        triagedAt: new Date(),
+        updatedAt: new Date(),
+    })
+        .where(and(eq(schema.pluginVulnExposure.id, id), eq(schema.pluginVulnExposure.orgId, orgId)))
+        .returning({ id: schema.pluginVulnExposure.id }));
+    return rows.length > 0;
+}
+/**
+ * Exposures whose acceptance has lapsed, for the org's security notifications.
+ *
+ * Surfaced rather than silently reopened: somebody decided to accept this until a
+ * date, that date has passed, and the person who decided is the one who should
+ * hear about it.
+ */
+export async function lapsedAcceptances(orgId, now = new Date()) {
+    const rows = await withTenantTx((tx) => tx.select({
+        id: schema.pluginVulnExposure.id,
+        pluginName: schema.pluginVulnExposure.pluginName,
+        pluginVersion: schema.pluginVulnExposure.pluginVersion,
+        triagedBy: schema.pluginVulnExposure.triagedBy,
+        acceptedUntil: schema.pluginVulnExposure.acceptedUntil,
+    }).from(schema.pluginVulnExposure)
+        .where(and(eq(schema.pluginVulnExposure.orgId, orgId), eq(schema.pluginVulnExposure.triageState, 'accepted'), isNull(schema.pluginVulnExposure.fixedAt), lte(schema.pluginVulnExposure.acceptedUntil, now))));
+    return rows;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-exposure.js","sourceRoot":"","sources":["../../../src/api/reporting/plugin-exposure.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What plugin versions an org's pipelines are actually on, and which of those are\n * known-vulnerable.\n *\n * Two tables, written here, read by the outdated-plugin and vulnerability report\n * sections:\n *\n *  - `pipeline_plugin_resolution` — the DECLARED side. Recomputed on pipeline\n *    write and on plugin publish, because the alternative is resolving every step\n *    of every pipeline against the catalog on every read, and that is not a query\n *    anyone can afford to put in a report.\n *  - `plugin_vuln_exposure` — the VULNERABLE side, per PIPELINE. A version-level\n *    table would force every reader to re-derive \"which of our pipelines is\n *    exposed\", which is the only form of the question anybody asks.\n *\n * DECLARED IS NOT DEPLOYED, and the report says which it is showing. A pipeline's\n * config declares `^2.0.0`; what ran at its last deploy is whatever the step\n * manifest recorded, pinned to a digest. Those disagree whenever a pipeline has not\n * re-synthed since a publish — which is most of the time, and exactly the gap a\n * vulnerability report is for. Conflating them would let a report say \"fixed\"\n * about a pipeline still running the old image.\n */\n\nimport { randomUUID } from 'node:crypto';\nimport { createLogger, errorMessage } from '@pipeline-builder/api-core';\nimport { and, eq, inArray, isNull, lte, sql } from 'drizzle-orm';\nimport { schema } from '../../database/drizzle-schema.js';\nimport type { ExposureSource } from '../../database/schema/reporting-analytics.js';\nimport { withTenantTx } from '../../database/tenancy.js';\n\nconst logger = createLogger('plugin-exposure');\n\n/** How far behind a resolved version is from the newest one available. */\nexport type VersionGap = 'major' | 'minor' | 'patch' | 'none';\n\n/** One resolved step, as the writer takes it. */\nexport interface ResolvedStep {\n  orgId: string;\n  pipelineId: string;\n  stageName: string;\n  stepName: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  declaredVersion?: string | null;\n  resolvedVersion?: string | null;\n  latestVersion?: string | null;\n  withinPolicy?: boolean;\n}\n\n/** `1.2.3` → `[1, 2, 3]`; anything unparseable → null. */\nfunction semver(v: string | null | undefined): [number, number, number] | null {\n  const m = /^v?(\\d+)\\.(\\d+)\\.(\\d+)/.exec(v ?? '');\n  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;\n}\n\n/**\n * How far `resolved` is behind `latest`.\n *\n * `null` when either side is unparseable, NOT `'none'`. \"We could not tell\" and\n * \"it is up to date\" are opposite answers, and reporting the second for the first\n * is how a pipeline on an ancient pre-release version gets a clean bill of health.\n */\nexport function versionGap(resolved: string | null | undefined, latest: string | null | undefined): VersionGap | null {\n  const a = semver(resolved);\n  const b = semver(latest);\n  if (!a || !b) return null;\n  if (b[0] > a[0]) return 'major';\n  if (b[0] < a[0]) return 'none'; // resolved is ahead of \"latest\" — not behind\n  if (b[1] > a[1]) return 'minor';\n  if (b[1] < a[1]) return 'none';\n  if (b[2] > a[2]) return 'patch';\n  return 'none';\n}\n\n/**\n * Replace a pipeline's resolution rows.\n *\n * DELETE-then-INSERT for the pipeline, in one transaction, because a step can be\n * REMOVED from a config: an upsert-only writer would leave the deleted step's row\n * behind forever, and the outdated-plugin section would keep reporting a step the\n * pipeline no longer has.\n */\nexport async function replacePipelineResolution(\n  pipelineId: string,\n  steps: readonly ResolvedStep[],\n): Promise<number> {\n  const values = steps.map((s) => ({\n    orgId: s.orgId,\n    pipelineId: s.pipelineId,\n    stageName: s.stageName,\n    stepName: s.stepName,\n    pluginPublisher: s.pluginPublisher ?? null,\n    pluginName: s.pluginName,\n    declaredVersion: s.declaredVersion ?? null,\n    resolvedVersion: s.resolvedVersion ?? null,\n    latestVersion: s.latestVersion ?? null,\n    versionGap: versionGap(s.resolvedVersion, s.latestVersion),\n    withinPolicy: s.withinPolicy ?? true,\n    computedAt: new Date(),\n  }));\n\n  return withTenantTx(async (tx) => {\n    await tx.delete(schema.pipelinePluginResolution)\n      .where(eq(schema.pipelinePluginResolution.pipelineId, pipelineId));\n    if (values.length === 0) return 0;\n    const landed = await tx.insert(schema.pipelinePluginResolution).values(values)\n      .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId });\n    return (landed as unknown[]).length;\n  });\n}\n\n/**\n * Refresh the `latest`/gap columns for one plugin across every pipeline that uses\n * it, without re-resolving anything else.\n *\n * Called on publish. A publish changes what \"latest\" means for every pipeline in\n * the instance that declares the plugin, and re-resolving each of those pipelines\n * from scratch would make publishing cost O(pipelines) work — so only the two\n * columns a publish can change are touched.\n */\nexport async function refreshLatestForPlugin(\n  pluginName: string,\n  pluginPublisher: string | null,\n  latestVersion: string,\n): Promise<number> {\n  const rows = await withTenantTx((tx) => tx.update(schema.pipelinePluginResolution)\n    .set({\n      latestVersion,\n      // Recomputed in SQL from the row's own resolved version, so one statement\n      // covers every pipeline rather than a round trip each.\n      // `::text` on every bind of the version: Postgres otherwise deduces\n      // inconsistent types for the same parameter (varchar for the assignment,\n      // text for `split_part`) and refuses to plan the statement.\n      versionGap: sql`CASE\n        WHEN ${schema.pipelinePluginResolution.resolvedVersion} IS NULL THEN NULL\n        WHEN split_part(${latestVersion}::text, '.', 1)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'major'\n        WHEN split_part(${latestVersion}::text, '.', 1)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'none'\n        WHEN split_part(${latestVersion}::text, '.', 2)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'minor'\n        WHEN split_part(${latestVersion}::text, '.', 2)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'none'\n        WHEN split_part(${latestVersion}::text, '.', 3)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 3)::int THEN 'patch'\n        ELSE 'none' END`,\n      computedAt: new Date(),\n    })\n    .where(and(\n      eq(schema.pipelinePluginResolution.pluginName, pluginName),\n      pluginPublisher === null\n        ? isNull(schema.pipelinePluginResolution.pluginPublisher)\n        : eq(schema.pipelinePluginResolution.pluginPublisher, pluginPublisher),\n      // Only rows whose resolved version parses as semver; anything else has no\n      // gap to compute and the CASE would throw on the cast.\n      sql`${schema.pipelinePluginResolution.resolvedVersion} ~ '^[0-9]+\\\\.[0-9]+\\\\.[0-9]+'`,\n    ))\n    .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId }));\n  return (rows as unknown[]).length;\n}\n\n/** One flagged version, as the rescan reports it. */\nexport interface ExposureInput {\n  orgId: string;\n  pipelineId: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest?: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings?: Array<Record<string, unknown>>;\n}\n\n/**\n * Open or refresh exposures.\n *\n * Upserts on (pipeline, plugin, version, source) so a nightly rescan REFRESHES the\n * counts rather than opening a new row every night — otherwise the report would\n * show one exposure per night of the same problem, which reads as an escalating\n * situation when nothing changed.\n *\n * A refresh deliberately does NOT reset `triage_state`: an org that accepted a\n * finding with a reason and a deadline has made a decision, and re-raising it every\n * night is how a team learns to ignore the report. It DOES clear a stale\n * acceptance, because that is what the deadline was for.\n */\nexport async function upsertExposures(inputs: readonly ExposureInput[], now = new Date()): Promise<number> {\n  if (inputs.length === 0) return 0;\n  const values = inputs.map((e) => ({\n    id: randomUUID(),\n    orgId: e.orgId,\n    pipelineId: e.pipelineId,\n    pluginPublisher: e.pluginPublisher ?? null,\n    pluginName: e.pluginName,\n    pluginVersion: e.pluginVersion,\n    imageDigest: e.imageDigest ?? null,\n    source: e.source,\n    criticalCount: e.criticalCount,\n    highCount: e.highCount,\n    topFindings: e.topFindings ?? [],\n    flaggedAt: now,\n    updatedAt: now,\n  }));\n\n  try {\n    const landed = await withTenantTx((tx) => tx.insert(schema.pluginVulnExposure).values(values)\n      .onConflictDoUpdate({\n        target: [\n          schema.pluginVulnExposure.pipelineId,\n          schema.pluginVulnExposure.pluginName,\n          schema.pluginVulnExposure.pluginVersion,\n          schema.pluginVulnExposure.source,\n        ],\n        set: {\n          criticalCount: sql`excluded.critical_count`,\n          highCount: sql`excluded.high_count`,\n          topFindings: sql`excluded.top_findings`,\n          imageDigest: sql`COALESCE(excluded.image_digest, ${schema.pluginVulnExposure.imageDigest})`,\n          // Still exposed, so the fix marker is cleared: a row that was closed by a\n          // deploy and is flagged again is a regression, and leaving `fixed_at` set\n          // would hide it.\n          fixedAt: null,\n          // An acceptance past its deadline stops being an acceptance. That is the\n          // entire point of time-boxing it, and it is enforced HERE rather than at\n          // read time so the stored state is the truth.\n          triageState: sql`CASE\n            WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'\n             AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL\n             AND ${schema.pluginVulnExposure.acceptedUntil} <= ${now}\n            THEN 'open'\n            WHEN ${schema.pluginVulnExposure.triageState} = 'fixed' THEN 'open'\n            ELSE ${schema.pluginVulnExposure.triageState} END`,\n          updatedAt: now,\n        },\n      })\n      .returning({ id: schema.pluginVulnExposure.id }));\n    return (landed as unknown[]).length;\n  } catch (err) {\n    logger.warn('Plugin exposure upsert failed', { count: values.length, error: errorMessage(err) });\n    return 0;\n  }\n}\n\n/**\n * Close the exposures a pipeline has moved off.\n *\n * Called when a deploy records a new step manifest: anything flagged for that\n * pipeline whose version is NOT in the set it now runs is fixed. Closing by\n * absence rather than waiting for a rescan to notice is what makes \"we fixed it\"\n * show up in the report on the next deploy instead of the next night.\n */\nexport async function closeFixedExposures(\n  pipelineId: string,\n  liveVersions: ReadonlyArray<{ pluginName: string; pluginVersion: string }>,\n  now = new Date(),\n): Promise<number> {\n  const live = new Set(liveVersions.map((v) => `${v.pluginName}@${v.pluginVersion}`));\n  const open = await withTenantTx((tx) => tx.select({\n    id: schema.pluginVulnExposure.id,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.pipelineId, pipelineId),\n      isNull(schema.pluginVulnExposure.fixedAt),\n    )));\n  const stale = (open as Array<{ id: string; pluginName: string; pluginVersion: string }>)\n    .filter((r) => !live.has(`${r.pluginName}@${r.pluginVersion}`))\n    .map((r) => r.id);\n  if (stale.length === 0) return 0;\n\n  const closed = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)\n    .set({ fixedAt: now, triageState: 'fixed', updatedAt: now })\n    .where(inArray(schema.pluginVulnExposure.id, stale))\n    .returning({ id: schema.pluginVulnExposure.id }));\n  return (closed as unknown[]).length;\n}\n\n/**\n * The org's live exposures, for the report section.\n *\n * `accepted` rows whose deadline has passed come back as OPEN even if no rescan\n * has refreshed them yet: a read must not present an expired acceptance as a\n * current one, and the report is read far more often than the rescan runs.\n */\nexport async function openExposures(orgId: string): Promise<Array<{\n  pipelineId: string;\n  pluginName: string;\n  pluginVersion: string;\n  pluginPublisher: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings: Array<Record<string, unknown>>;\n  triageState: string;\n  flaggedAt: Date;\n}>> {\n  const now = new Date();\n  const rows = await withTenantTx((tx) => tx.select({\n    pipelineId: schema.pluginVulnExposure.pipelineId,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    pluginPublisher: schema.pluginVulnExposure.pluginPublisher,\n    source: schema.pluginVulnExposure.source,\n    criticalCount: schema.pluginVulnExposure.criticalCount,\n    highCount: schema.pluginVulnExposure.highCount,\n    topFindings: schema.pluginVulnExposure.topFindings,\n    triageState: schema.pluginVulnExposure.triageState,\n    acceptedUntil: schema.pluginVulnExposure.acceptedUntil,\n    flaggedAt: schema.pluginVulnExposure.flaggedAt,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.orgId, orgId),\n      isNull(schema.pluginVulnExposure.fixedAt),\n      // An acceptance that has run out is not an acceptance.\n      sql`(${schema.pluginVulnExposure.triageState} <> 'accepted'\n           OR ${schema.pluginVulnExposure.acceptedUntil} IS NULL\n           OR ${schema.pluginVulnExposure.acceptedUntil} <= ${now})`,\n    ))\n    .orderBy(sql`${schema.pluginVulnExposure.criticalCount} DESC, ${schema.pluginVulnExposure.highCount} DESC`));\n\n  return (rows as Array<Record<string, unknown>>).map((r) => ({\n    pipelineId: r.pipelineId as string,\n    pluginName: r.pluginName as string,\n    pluginVersion: r.pluginVersion as string,\n    pluginPublisher: (r.pluginPublisher as string | null) ?? null,\n    source: r.source as ExposureSource,\n    criticalCount: r.criticalCount as number,\n    highCount: r.highCount as number,\n    topFindings: (r.topFindings as Array<Record<string, unknown>>) ?? [],\n    // An expired acceptance reads as open, which is what it is.\n    triageState: r.triageState === 'accepted' && r.acceptedUntil ? 'open' : (r.triageState as string),\n    flaggedAt: r.flaggedAt as Date,\n  }));\n}\n\n/**\n * Record a triage decision.\n *\n * `accepted` REQUIRES a deadline and a reason. A permanent, unexplained mute is\n * how a finding stops being anybody's problem, and there is no good reason to\n * support it — the caller gets an error rather than a silently unbounded\n * acceptance.\n */\nexport async function triageExposure(\n  orgId: string,\n  id: string,\n  decision: { state: 'open' | 'accepted' | 'false_positive'; reason?: string; acceptedUntil?: Date; actor: string },\n): Promise<boolean> {\n  if (decision.state === 'accepted' && (!decision.acceptedUntil || !decision.reason?.trim())) {\n    throw new Error('Accepting a vulnerability exposure needs a reason and an expiry date');\n  }\n  const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)\n    .set({\n      triageState: decision.state,\n      acceptedUntil: decision.state === 'accepted' ? (decision.acceptedUntil ?? null) : null,\n      triageReason: decision.reason ?? null,\n      triagedBy: decision.actor,\n      triagedAt: new Date(),\n      updatedAt: new Date(),\n    })\n    .where(and(\n      eq(schema.pluginVulnExposure.id, id),\n      eq(schema.pluginVulnExposure.orgId, orgId),\n    ))\n    .returning({ id: schema.pluginVulnExposure.id }));\n  return (rows as unknown[]).length > 0;\n}\n\n/**\n * Exposures whose acceptance has lapsed, for the org's security notifications.\n *\n * Surfaced rather than silently reopened: somebody decided to accept this until a\n * date, that date has passed, and the person who decided is the one who should\n * hear about it.\n */\nexport async function lapsedAcceptances(orgId: string, now = new Date()): Promise<Array<{\n  id: string;\n  pluginName: string;\n  pluginVersion: string;\n  triagedBy: string | null;\n  acceptedUntil: Date | null;\n}>> {\n  const rows = await withTenantTx((tx) => tx.select({\n    id: schema.pluginVulnExposure.id,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    triagedBy: schema.pluginVulnExposure.triagedBy,\n    acceptedUntil: schema.pluginVulnExposure.acceptedUntil,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.orgId, orgId),\n      eq(schema.pluginVulnExposure.triageState, 'accepted'),\n      isNull(schema.pluginVulnExposure.fixedAt),\n      lte(schema.pluginVulnExposure.acceptedUntil, now),\n    )));\n  return rows as Array<{ id: string; pluginName: string; pluginVersion: string; triagedBy: string | null; acceptedUntil: Date | null }>;\n}\n"]}

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

@@ -95,6 +95,14 @@ export async function purgeExpiredReportingData(opts = {}) {
         const outcomesTable = sql `${schema.deploymentOutcome}`;
         const incidentsTable = sql `${schema.incident}`;
         for (const { org_id: orgId } of orgRows) {
+            // Lock lost, or shutting down: stop between orgs. Every remaining org still
+            // has expired rows, so the next tick resumes exactly where this left off.
+            if (opts.run?.signal.aborted) {
+                logger.info('Reporting retention sweep stopping early', {
+                    reason: String(opts.run.signal.reason ?? 'aborted'), orgsDone: counts.orgs,
+                });
+                break;
+            }
             // 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.
@@ -152,4 +160,4 @@ export async function purgeExpiredReportingData(opts = {}) {
         return counts;
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retention-sweep.js","sourceRoot":"","sources":["../../../src/api/reporting/retention-sweep.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtG,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAEnD;;;;;;;;;GASG;AACH,KAAK,UAAU,0BAA0B,CACvC,QAAgC,EAChC,SAAiC,EACjC,SAAiB,EACjB,UAAkB;IAElB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;oBACrC,QAAQ;;2BAED,QAAQ;gBACnB,SAAS;gBACT,SAAS;;;KAGpB,CAAC,CAAC,CAAC;QACJ,MAAM,MAAM,GAAG,WAAW,CAAU,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;QACrD,KAAK,IAAI,MAAM,CAAC;QAChB,IAAI,MAAM,GAAG,SAAS;YAAE,MAAM,CAAC,UAAU;QACzC,IAAI,CAAC,KAAK,UAAU,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,IAAI,CAAC,+DAA+D,EAAE;gBAC3E,cAAc,EAAE,KAAK;aACtB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,IAAI,GAA8B,EAAE;IAClF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;IACtD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC;IAC9D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;IACnC,MAAM,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,IAAI,CAAC,KAAK,EAAE,KAAa,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAC7F,MAAM,MAAM,GAA6B;QACvC,IAAI,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC;KAC/E,CAAC;IAEF,OAAO,oBAAoB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,KAAK,IAAI,EAAE;QAC7D,2EAA2E;QAC3E,MAAM,OAAO,GAAG,WAAW,CAAqB,CAAC,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;iBAE7E,MAAM,CAAC,aAAa,CAAC,KAAK,mBAAmB,MAAM,CAAC,aAAa;;iBAEjE,MAAM,CAAC,iBAAiB,CAAC,KAAK,mBAAmB,MAAM,CAAC,iBAAiB;;iBAEzE,MAAM,CAAC,QAAQ,CAAC,KAAK,mBAAmB,MAAM,CAAC,QAAQ;;KAEnE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACX,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,MAAM,CAAC;QAExC,gFAAgF;QAChF,MAAM,YAAY,GAAG,WAAW,CAI7B,CAAC,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;eAClC,MAAM,CAAC,YAAY,CAAC,KAAK;eACzB,MAAM,CAAC,YAAY,CAAC,kBAAkB;eACtC,MAAM,CAAC,YAAY,CAAC,iBAAiB;aACvC,MAAM,CAAC,YAAY;KAC3B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACX,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAElE,MAAM,WAAW,GAAG,GAAG,CAAA,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC;QACjD,MAAM,aAAa,GAAG,GAAG,CAAA,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC;QACvD,MAAM,cAAc,GAAG,GAAG,CAAA,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;QAE/C,KAAK,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,OAAO,EAAE,CAAC;YACxC,0EAA0E;YAC1E,wEAAwE;YACxE,yDAAyD;YACzD,IAAI,cAA6B,CAAC;YAClC,IAAI,CAAC;gBACH,cAAc,GAAG,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;YACtD,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,oEAAoE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACvH,cAAc,GAAG,IAAI,CAAC;YACxB,CAAC;YACD,IAAI,cAAc,KAAK,IAAI,EAAE,CAAC;gBAC5B,MAAM,CAAC,IAAI,CAAC,kFAAkF,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBAC3G,SAAS;YACX,CAAC;YACD,MAAM,EAAE,GAAG,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YACzC,MAAM,SAAS,GAAG,yBAAyB,CAAC,EAAE,EAAE,oBAAoB,CAAC,CAAC;YACtE,MAAM,QAAQ,GAAG,wBAAwB,CAAC,EAAE,EAAE,mBAAmB,CAAC,CAAC;YACnE,iEAAiE;YACjE,2EAA2E;YAC3E,oEAAoE;YACpE,MAAM,UAAU,GAAG,SAAS,KAAK,CAAC,CAAC,CAAC;YACpC,MAAM,QAAQ,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC;YACjC,IAAI,UAAU,IAAI,QAAQ,EAAE,CAAC;gBAC3B,MAAM,CAAC,IAAI,CAAC,wDAAwD,EAAE;oBACpE,KAAK;oBACL,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;oBACpD,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ;iBAC9C,CAAC,CAAC;YACL,CAAC;YAED,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,WAAW,GAAG,eAAe,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBACpD,MAAM,CAAC,cAAc,IAAI,MAAM,0BAA0B,CACvD,WAAW;gBACX,qEAAqE;gBACrE,sDAAsD;gBACtD,oEAAoE;gBACpE,mEAAmE;gBACnE,mEAAmE;gBACnE,gEAAgE;gBAChE,iEAAiE;gBACjE,4DAA4D;gBAC5D,GAAG,CAAA,YAAY,KAAK,0EAA0E,WAAW,EAAE,EAC3G,SAAS,EAAE,UAAU,CACtB,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;gBAClD,MAAM,CAAC,UAAU,IAAI,MAAM,0BAA0B,CACnD,WAAW,EACX,GAAG,CAAA,YAAY,KAAK,mFAAmF,UAAU,EAAE,EACnH,SAAS,EAAE,UAAU,CACtB,CAAC;gBACF,MAAM,CAAC,kBAAkB,IAAI,MAAM,0BAA0B,CAC3D,aAAa,EACb,GAAG,CAAA,YAAY,KAAK,qBAAqB,UAAU,EAAE,EACrD,SAAS,EAAE,UAAU,CACtB,CAAC;gBACF,MAAM,CAAC,SAAS,IAAI,MAAM,0BAA0B,CAClD,cAAc,EACd,GAAG,CAAA,YAAY,KAAK,qBAAqB,UAAU,EAAE,EACrD,SAAS,EAAE,UAAU,CACtB,CAAC;YACJ,CAAC;YACD,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;QACnB,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,kBAAkB,GAAG,MAAM,CAAC,SAAS,CAAC;QAC3G,IAAI,SAAS,GAAG,CAAC;YAAE,MAAM,CAAC,IAAI,CAAC,+CAA+C,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;QAC/F,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CAAC;AACL,CAAC","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"]}
+//# 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      // Lock lost, or shutting down: stop between orgs. Every remaining org still\n      // has expired rows, so the next tick resumes exactly where this left off.\n      if (opts.run?.signal.aborted) {\n        logger.info('Reporting retention sweep stopping early', {\n          reason: String(opts.run.signal.reason ?? 'aborted'), orgsDone: counts.orgs,\n        });\n        break;\n      }\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/sql-helpers.d.ts

@@ -1,4 +1,8 @@
-import { sql } from 'drizzle-orm';
+/**
+ * Small SQL fragments and input guards shared across the reporting queries.
+ */
+import { type WeekStart } from '@pipeline-builder/api-core';
+import { sql, type SQL } from 'drizzle-orm';
 /**
  * Defense-in-depth guard for the `DATE_TRUNC(${interval}, …)` bucket argument.
  * The route layer (`parseReportInterval`) is the security boundary and already
@@ -8,6 +12,35 @@ import { sql } from 'drizzle-orm';
  * REPORT_INTERVALS allow-list so the two can't drift.
  */
 export declare function assertReportInterval(interval: string): void;
+/**
+ * The time-bucket expression for a report series: `DATE_TRUNC` in the REPORT'S
+ * timezone, honouring the org's week start.
+ *
+ * Two things this fixes, both of which made a manager's report cover the wrong
+ * days:
+ *
+ *  - Bucketing ran in the database session's timezone, which is UTC in every
+ *    deploy. A Chicago team's "week" therefore began 18:00 Sunday local, so their
+ *    Monday report cut off Sunday evening's work and attributed it to the previous
+ *    week. `AT TIME ZONE` converts to local wall time BEFORE truncating.
+ *  - Postgres `DATE_TRUNC('week', …)` is ISO-8601 and always starts Monday, with
+ *    no setting. A Sunday-week org gets the boundary shifted a day either side of
+ *    the truncation, which is the only way to move it.
+ *
+ * `interval` is asserted against the allow-list by {@link assertReportInterval};
+ * `tz` rides as a BOUND parameter, never interpolated.
+ *
+ * Returns a `timestamp without time zone` in local wall time — which is what a
+ * period label ("2026-W38", "2026-08") should read as.
+ */
+export declare function periodBucket(interval: string, column: SQL, tz: string, weekStart?: WeekStart): SQL;
+/**
+ * Cache-key suffix for the bucketing settings. Report cache keys carried the
+ * interval and the date range but NOT the timezone or week start, so once
+ * bucketing became timezone-aware one org's Chicago buckets would have been
+ * served to a request asking for UTC. Every keyed report must include this.
+ */
+export declare function bucketKey(tz: string, weekStart?: WeekStart): string;
 /**
  * Scrub AWS identifiers from an optional free-form string, preserving `undefined`
  * (so an absent field stays absent rather than becoming an empty scrubbed string).
@@ -22,7 +55,7 @@ export declare function scrubOptional(value: string | undefined): string | undef
  * trend, and build health — so the precedence can't drift between them. Assumes the
  * grouped event alias is `e`.
  */
-export declare const terminalStatusRollup: import("drizzle-orm").SQL<unknown>;
+export declare const terminalStatusRollup: SQL<unknown>;
 /** The report window on `e.started_at` (inclusive `[from, to]`). */
 export declare function startedAtWindow(from: string, to: string): ReturnType<typeof sql>;
 /** Optional `[from,to]` window on `e.started_at` for the execution reports —

package/lib/api/reporting/sql-helpers.js

@@ -18,6 +18,44 @@ export function assertReportInterval(interval) {
         throw new Error(`Invalid report interval: ${interval}. Expected one of: ${REPORT_INTERVALS.join(', ')}`);
     }
 }
+/**
+ * The time-bucket expression for a report series: `DATE_TRUNC` in the REPORT'S
+ * timezone, honouring the org's week start.
+ *
+ * Two things this fixes, both of which made a manager's report cover the wrong
+ * days:
+ *
+ *  - Bucketing ran in the database session's timezone, which is UTC in every
+ *    deploy. A Chicago team's "week" therefore began 18:00 Sunday local, so their
+ *    Monday report cut off Sunday evening's work and attributed it to the previous
+ *    week. `AT TIME ZONE` converts to local wall time BEFORE truncating.
+ *  - Postgres `DATE_TRUNC('week', …)` is ISO-8601 and always starts Monday, with
+ *    no setting. A Sunday-week org gets the boundary shifted a day either side of
+ *    the truncation, which is the only way to move it.
+ *
+ * `interval` is asserted against the allow-list by {@link assertReportInterval};
+ * `tz` rides as a BOUND parameter, never interpolated.
+ *
+ * Returns a `timestamp without time zone` in local wall time — which is what a
+ * period label ("2026-W38", "2026-08") should read as.
+ */
+export function periodBucket(interval, column, tz, weekStart = 'monday') {
+    assertReportInterval(interval);
+    const local = sql `(${column} AT TIME ZONE ${tz})`;
+    if (interval === 'week' && weekStart === 'sunday') {
+        return sql `(DATE_TRUNC('week', ${local} + INTERVAL '1 day') - INTERVAL '1 day')`;
+    }
+    return sql `DATE_TRUNC(${interval}, ${local})`;
+}
+/**
+ * Cache-key suffix for the bucketing settings. Report cache keys carried the
+ * interval and the date range but NOT the timezone or week start, so once
+ * bucketing became timezone-aware one org's Chicago buckets would have been
+ * served to a request asking for UTC. Every keyed report must include this.
+ */
+export function bucketKey(tz, weekStart = 'monday') {
+    return `${tz}:${weekStart}`;
+}
 /**
  * Scrub AWS identifiers from an optional free-form string, preserving `undefined`
  * (so an absent field stays absent rather than becoming an empty scrubbed string).
@@ -61,4 +99,4 @@ export function optionalStartedAtRange(range) {
  * `in_window` is false for a look-back-only row kept solely so incidents opened
  * near `from` can correlate to a deploy that completed just before the window.
  */
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FsLWhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL3JlcG9ydGluZy9zcWwtaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDOztHQUVHO0FBRUgsT0FBTyxFQUFFLGdCQUFnQixFQUFFLDZCQUE2QixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDN0YsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUVsQzs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUFDLFFBQWdCO0lBQ25ELElBQUksQ0FBRSxnQkFBc0MsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztRQUNoRSxNQUFNLElBQUksS0FBSyxDQUFDLDRCQUE0QixRQUFRLHNCQUFzQixnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQzNHLENBQUM7QUFDSCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUFDLEtBQXlCO0lBQ3JELE9BQU8sS0FBSyxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsNkJBQTZCLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztBQUNoRixDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsR0FBRyxDQUFBOzs7O2dCQUl2QixDQUFDO0FBRWpCLG9FQUFvRTtBQUNwRSxNQUFNLFVBQVUsZUFBZSxDQUFDLElBQVksRUFBRSxFQUFVO0lBQ3RELE9BQU8sR0FBRyxDQUFBLG1CQUFtQixJQUFJLHFDQUFxQyxFQUFFLGVBQWUsQ0FBQztBQUMxRixDQUFDO0FBRUQ7O3FGQUVxRjtBQUNyRixNQUFNLFVBQVUsc0JBQXNCLENBQUMsS0FBc0M7SUFDM0UsT0FBTyxLQUFLLEVBQUUsSUFBSSxJQUFJLEtBQUssRUFBRSxFQUFFO1FBQzdCLENBQUMsQ0FBQyxHQUFHLENBQUEsT0FBTyxlQUFlLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsRUFBRSxDQUFDLEVBQUU7UUFDbkQsQ0FBQyxDQUFDLEdBQUcsQ0FBQSxFQUFFLENBQUM7QUFDWixDQUFDO0FBRUQ7Ozs7Ozs7OztHQVNHIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbi8qKlxuICogU21hbGwgU1FMIGZyYWdtZW50cyBhbmQgaW5wdXQgZ3VhcmRzIHNoYXJlZCBhY3Jvc3MgdGhlIHJlcG9ydGluZyBxdWVyaWVzLlxuICovXG5cbmltcG9ydCB7IFJFUE9SVF9JTlRFUlZBTFMsIHNjcnViQXdzSWRlbnRpZmllcnNGcm9tU3RyaW5nIH0gZnJvbSAnQHBpcGVsaW5lLWJ1aWxkZXIvYXBpLWNvcmUnO1xuaW1wb3J0IHsgc3FsIH0gZnJvbSAnZHJpenpsZS1vcm0nO1xuXG4vKipcbiAqIERlZmVuc2UtaW4tZGVwdGggZ3VhcmQgZm9yIHRoZSBgREFURV9UUlVOQygke2ludGVydmFsfSwg4oCmKWAgYnVja2V0IGFyZ3VtZW50LlxuICogVGhlIHJvdXRlIGxheWVyIChgcGFyc2VSZXBvcnRJbnRlcnZhbGApIGlzIHRoZSBzZWN1cml0eSBib3VuZGFyeSBhbmQgYWxyZWFkeVxuICogcmVqZWN0cyB1bmtub3duIGludGVydmFsczsgdGhpcyBhc3NlcnQgbWFrZXMgYW4gaW52YWxpZCB2YWx1ZSBmYWlsIGZhc3QgYXQgdGhlXG4gKiBzZXJ2aWNlIGJvdW5kYXJ5IHdpdGggYSBjbGVhciBlcnJvciBpbnN0ZWFkIG9mIHN1cmZhY2luZyBhIHJhdyBQb3N0Z3JlcyBlcnJvclxuICogaWYgYSBjYWxsZXIgZXZlciBieXBhc3NlcyB0aGUgcm91dGUgdmFsaWRhdGlvbi4gU2hhcmVzIGFwaS1jb3JlJ3NcbiAqIFJFUE9SVF9JTlRFUlZBTFMgYWxsb3ctbGlzdCBzbyB0aGUgdHdvIGNhbid0IGRyaWZ0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0UmVwb3J0SW50ZXJ2YWwoaW50ZXJ2YWw6IHN0cmluZyk6IHZvaWQge1xuICBpZiAoIShSRVBPUlRfSU5URVJWQUxTIGFzIHJlYWRvbmx5IHN0cmluZ1tdKS5pbmNsdWRlcyhpbnRlcnZhbCkpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgcmVwb3J0IGludGVydmFsOiAke2ludGVydmFsfS4gRXhwZWN0ZWQgb25lIG9mOiAke1JFUE9SVF9JTlRFUlZBTFMuam9pbignLCAnKX1gKTtcbiAgfVxufVxuXG4vKipcbiAqIFNjcnViIEFXUyBpZGVudGlmaWVycyBmcm9tIGFuIG9wdGlvbmFsIGZyZWUtZm9ybSBzdHJpbmcsIHByZXNlcnZpbmcgYHVuZGVmaW5lZGBcbiAqIChzbyBhbiBhYnNlbnQgZmllbGQgc3RheXMgYWJzZW50IHJhdGhlciB0aGFuIGJlY29taW5nIGFuIGVtcHR5IHNjcnViYmVkIHN0cmluZykuXG4gKiBUaGUgRFVSQUJMRSBwZXJzaXN0ZW5jZSBib3VuZGFyeSBmb3IgdGhlIGluZ2VzdCBwYXRocyDigJQgZXZlcnkgdXNlci9BV1MtZGVyaXZlZFxuICogc3RyaW5nIGZpZWxkIGlzIGZ1bm5lbGVkIHRocm91Z2ggdGhpcyBiZWZvcmUgaW5zZXJ0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2NydWJPcHRpb25hbCh2YWx1ZTogc3RyaW5nIHwgdW5kZWZpbmVkKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgcmV0dXJuIHZhbHVlICE9PSB1bmRlZmluZWQgPyBzY3J1YkF3c0lkZW50aWZpZXJzRnJvbVN0cmluZyh2YWx1ZSkgOiB1bmRlZmluZWQ7XG59XG5cbi8qKlxuICogUm9sbCBhIGdyb3VwIG9mIGRlcGxveS9zdGFnZSBldmVudHMgKGdyb3VwZWQgcGVyIGV4ZWN1dGlvbikgdXAgdG8gb25lIHRlcm1pbmFsXG4gKiBzdGF0dXM6IEZBSUxFRCB3aW5zLCB0aGVuIFNVQ0NFRURFRCwgZWxzZSBPVEhFUiAoc3RpbGwtcnVubmluZyAvIG5vbi10ZXJtaW5hbCkuXG4gKiBTaGFyZWQgYnkgdGhlIHRocmVlIHBlci0oZW52fHN0YWdlLCBleGVjdXRpb24pIHJvbGx1cCBDVEVzIOKAlCBET1JBIG1ldHJpY3MsIERPUkFcbiAqIHRyZW5kLCBhbmQgYnVpbGQgaGVhbHRoIOKAlCBzbyB0aGUgcHJlY2VkZW5jZSBjYW4ndCBkcmlmdCBiZXR3ZWVuIHRoZW0uIEFzc3VtZXMgdGhlXG4gKiBncm91cGVkIGV2ZW50IGFsaWFzIGlzIGBlYC5cbiAqL1xuZXhwb3J0IGNvbnN0IHRlcm1pbmFsU3RhdHVzUm9sbHVwID0gc3FsYENBU0VcbiAgICAgICAgICAgICAgV0hFTiBib29sX29yKGUuc3RhdHVzID0gJ0ZBSUxFRCcpIFRIRU4gJ0ZBSUxFRCdcbiAgICAgICAgICAgICAgV0hFTiBib29sX29yKGUuc3RhdHVzID0gJ1NVQ0NFRURFRCcpIFRIRU4gJ1NVQ0NFRURFRCdcbiAgICAgICAgICAgICAgRUxTRSAnT1RIRVInXG4gICAgICAgICAgICBFTkRgO1xuXG4vKiogVGhlIHJlcG9ydCB3aW5kb3cgb24gYGUuc3RhcnRlZF9hdGAgKGluY2x1c2l2ZSBgW2Zyb20sIHRvXWApLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHN0YXJ0ZWRBdFdpbmRvdyhmcm9tOiBzdHJpbmcsIHRvOiBzdHJpbmcpOiBSZXR1cm5UeXBlPHR5cGVvZiBzcWw+IHtcbiAgcmV0dXJuIHNxbGBlLnN0YXJ0ZWRfYXQgPj0gJHtmcm9tfTo6dGltZXN0YW1wdHogQU5EIGUuc3RhcnRlZF9hdCA8PSAke3RvfTo6dGltZXN0YW1wdHpgO1xufVxuXG4vKiogT3B0aW9uYWwgYFtmcm9tLHRvXWAgd2luZG93IG9uIGBlLnN0YXJ0ZWRfYXRgIGZvciB0aGUgZXhlY3V0aW9uIHJlcG9ydHMg4oCUXG4gKiAgYSBuby1vcCBgc3FsYCBmcmFnbWVudCB3aGVuIGVpdGhlciBib3VuZCBpcyBhYnNlbnQgKGFsbC10aW1lKS4gU2hhcmVkIGJ5IHRoZVxuICogIGV4ZWN1dGlvbi1jb3VudCBhbmQgcGVyLXBpcGVsaW5lLWV4ZWN1dGlvbiByZXBvcnRzIHNvIHRoZXkgbmFycm93IGlkZW50aWNhbGx5LiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG9wdGlvbmFsU3RhcnRlZEF0UmFuZ2UocmFuZ2U/OiB7IGZyb20/OiBzdHJpbmc7IHRvPzogc3RyaW5nIH0pOiBSZXR1cm5UeXBlPHR5cGVvZiBzcWw+IHtcbiAgcmV0dXJuIHJhbmdlPy5mcm9tICYmIHJhbmdlPy50b1xuICAgID8gc3FsYEFORCAke3N0YXJ0ZWRBdFdpbmRvdyhyYW5nZS5mcm9tLCByYW5nZS50byl9YFxuICAgIDogc3FsYGA7XG59XG5cbi8qKlxuICogUGVyLWV4ZWN1dGlvbiB0ZXJtaW5hbCBkZXBsb3kgcm93IChvbmUgcm93IHBlciAoZW52aXJvbm1lbnQsIGV4ZWN1dGlvbiksXG4gKiBOT1QgcGVyIHN0YWdlKS4gVGhlIFNRTCByb2xscyBldmVyeSBkZXBsb3kgU1RBR0UgdGFyZ2V0aW5nIGFuIGVudiB3aXRoaW4gYW5cbiAqIGV4ZWN1dGlvbiB1cCB0byBhIHNpbmdsZSB0ZXJtaW5hbCBzdGF0dXM7IHRoZSBKUyBzaGFwaW5nIGJ1Y2tldHMgdGhlc2UgYnlcbiAqIGVudmlyb25tZW50LiBgY29tbWl0X3RzYCBpcyB0aGUgZXhlY3V0aW9uJ3MgRUFSTElFU1QgY29tbWl0IHRpbWUgYWNyb3NzXG4gKiBhbGwgaXRzIGV2ZW50cyDigJQgY29tbWl0IGVucmljaG1lbnQgcmlkZXMgdGhlIFBJUEVMSU5FL3NvdXJjZSBldmVudCwgbm90IHRoZVxuICogZGVwbG95IFNUQUdFIOKAlCBqb2luZWQgYnkgZXhlY3V0aW9uX2lkIChudWxsIHdoZW4gdW5yZXNvbHZlZCDihpIgbGVhZCBgdW5rbm93bmApLlxuICogYGluX3dpbmRvd2AgaXMgZmFsc2UgZm9yIGEgbG9vay1iYWNrLW9ubHkgcm93IGtlcHQgc29sZWx5IHNvIGluY2lkZW50cyBvcGVuZWRcbiAqIG5lYXIgYGZyb21gIGNhbiBjb3JyZWxhdGUgdG8gYSBkZXBsb3kgdGhhdCBjb21wbGV0ZWQganVzdCBiZWZvcmUgdGhlIHdpbmRvdy5cbiAqL1xuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sql-helpers.js","sourceRoot":"","sources":["../../../src/api/reporting/sql-helpers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,6BAA6B,EAAkB,MAAM,4BAA4B,CAAC;AAC7G,OAAO,EAAE,GAAG,EAAY,MAAM,aAAa,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACnD,IAAI,CAAE,gBAAsC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChE,MAAM,IAAI,KAAK,CAAC,4BAA4B,QAAQ,sBAAsB,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3G,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,YAAY,CAAC,QAAgB,EAAE,MAAW,EAAE,EAAU,EAAE,SAAS,GAAc,QAAQ;IACrG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,GAAG,CAAA,IAAI,MAAM,iBAAiB,EAAE,GAAG,CAAC;IAClD,IAAI,QAAQ,KAAK,MAAM,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClD,OAAO,GAAG,CAAA,uBAAuB,KAAK,0CAA0C,CAAC;IACnF,CAAC;IACD,OAAO,GAAG,CAAA,cAAc,QAAQ,KAAK,KAAK,GAAG,CAAC;AAChD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,EAAU,EAAE,SAAS,GAAc,QAAQ;IACnE,OAAO,GAAG,EAAE,IAAI,SAAS,EAAE,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAyB;IACrD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAChF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAA;;;;gBAIvB,CAAC;AAEjB,oEAAoE;AACpE,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,EAAU;IACtD,OAAO,GAAG,CAAA,mBAAmB,IAAI,qCAAqC,EAAE,eAAe,CAAC;AAC1F,CAAC;AAED;;qFAEqF;AACrF,MAAM,UAAU,sBAAsB,CAAC,KAAsC;IAC3E,OAAO,KAAK,EAAE,IAAI,IAAI,KAAK,EAAE,EAAE;QAC7B,CAAC,CAAC,GAAG,CAAA,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE;QACnD,CAAC,CAAC,GAAG,CAAA,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;;GASG","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Small SQL fragments and input guards shared across the reporting queries.\n */\n\nimport { REPORT_INTERVALS, scrubAwsIdentifiersFromString, type WeekStart } from '@pipeline-builder/api-core';\nimport { sql, type SQL } from 'drizzle-orm';\n\n/**\n * Defense-in-depth guard for the `DATE_TRUNC(${interval}, …)` bucket argument.\n * The route layer (`parseReportInterval`) is the security boundary and already\n * rejects unknown intervals; this assert makes an invalid value fail fast at the\n * service boundary with a clear error instead of surfacing a raw Postgres error\n * if a caller ever bypasses the route validation. Shares api-core's\n * REPORT_INTERVALS allow-list so the two can't drift.\n */\nexport function assertReportInterval(interval: string): void {\n  if (!(REPORT_INTERVALS as readonly string[]).includes(interval)) {\n    throw new Error(`Invalid report interval: ${interval}. Expected one of: ${REPORT_INTERVALS.join(', ')}`);\n  }\n}\n\n/**\n * The time-bucket expression for a report series: `DATE_TRUNC` in the REPORT'S\n * timezone, honouring the org's week start.\n *\n * Two things this fixes, both of which made a manager's report cover the wrong\n * days:\n *\n *  - Bucketing ran in the database session's timezone, which is UTC in every\n *    deploy. A Chicago team's \"week\" therefore began 18:00 Sunday local, so their\n *    Monday report cut off Sunday evening's work and attributed it to the previous\n *    week. `AT TIME ZONE` converts to local wall time BEFORE truncating.\n *  - Postgres `DATE_TRUNC('week', …)` is ISO-8601 and always starts Monday, with\n *    no setting. A Sunday-week org gets the boundary shifted a day either side of\n *    the truncation, which is the only way to move it.\n *\n * `interval` is asserted against the allow-list by {@link assertReportInterval};\n * `tz` rides as a BOUND parameter, never interpolated.\n *\n * Returns a `timestamp without time zone` in local wall time — which is what a\n * period label (\"2026-W38\", \"2026-08\") should read as.\n */\nexport function periodBucket(interval: string, column: SQL, tz: string, weekStart: WeekStart = 'monday'): SQL {\n  assertReportInterval(interval);\n  const local = sql`(${column} AT TIME ZONE ${tz})`;\n  if (interval === 'week' && weekStart === 'sunday') {\n    return sql`(DATE_TRUNC('week', ${local} + INTERVAL '1 day') - INTERVAL '1 day')`;\n  }\n  return sql`DATE_TRUNC(${interval}, ${local})`;\n}\n\n/**\n * Cache-key suffix for the bucketing settings. Report cache keys carried the\n * interval and the date range but NOT the timezone or week start, so once\n * bucketing became timezone-aware one org's Chicago buckets would have been\n * served to a request asking for UTC. Every keyed report must include this.\n */\nexport function bucketKey(tz: string, weekStart: WeekStart = 'monday'): string {\n  return `${tz}:${weekStart}`;\n}\n\n/**\n * Scrub AWS identifiers from an optional free-form string, preserving `undefined`\n * (so an absent field stays absent rather than becoming an empty scrubbed string).\n * The DURABLE persistence boundary for the ingest paths — every user/AWS-derived\n * string field is funneled through this before insert.\n */\nexport function scrubOptional(value: string | undefined): string | undefined {\n  return value !== undefined ? scrubAwsIdentifiersFromString(value) : undefined;\n}\n\n/**\n * Roll a group of deploy/stage events (grouped per execution) up to one terminal\n * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).\n * Shared by the three per-(env|stage, execution) rollup CTEs — DORA metrics, DORA\n * trend, and build health — so the precedence can't drift between them. Assumes the\n * grouped event alias is `e`.\n */\nexport const terminalStatusRollup = sql`CASE\n              WHEN bool_or(e.status = 'FAILED') THEN 'FAILED'\n              WHEN bool_or(e.status = 'SUCCEEDED') THEN 'SUCCEEDED'\n              ELSE 'OTHER'\n            END`;\n\n/** The report window on `e.started_at` (inclusive `[from, to]`). */\nexport function startedAtWindow(from: string, to: string): ReturnType<typeof sql> {\n  return sql`e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz`;\n}\n\n/** Optional `[from,to]` window on `e.started_at` for the execution reports —\n *  a no-op `sql` fragment when either bound is absent (all-time). Shared by the\n *  execution-count and per-pipeline-execution reports so they narrow identically. */\nexport function optionalStartedAtRange(range?: { from?: string; to?: string }): ReturnType<typeof sql> {\n  return range?.from && range?.to\n    ? sql`AND ${startedAtWindow(range.from, range.to)}`\n    : sql``;\n}\n\n/**\n * Per-execution terminal deploy row (one row per (environment, execution),\n * NOT per stage). The SQL rolls every deploy STAGE targeting an env within an\n * execution up to a single terminal status; the JS shaping buckets these by\n * environment. `commit_ts` is the execution's EARLIEST commit time across\n * all its events — commit enrichment rides the PIPELINE/source event, not the\n * deploy STAGE — joined by execution_id (null when unresolved → lead `unknown`).\n * `in_window` is false for a look-back-only row kept solely so incidents opened\n * near `from` can correlate to a deploy that completed just before the window.\n */\n"]}