@pipeline-builder/pipeline-data 3.4.95 → 3.4.97

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

@@ -100,6 +100,117 @@ interface BuildFailure {
     occurrences: number;
     lastSeen: string;
 }
+/**
+ * DORA performance band. `null` = insufficient data to classify (no
+ * deployments/failures/lead-time sample in the window), so the UI shows a
+ * neutral state rather than mislabeling an empty window as "low".
+ */
+export type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;
+/** Optional scoping for {@link ReportingService.getDoraMetrics}. */
+export interface DoraOptions {
+    /** Restrict to a single pipeline (per-pipeline DORA). */
+    pipelineId?: string;
+    /** Count only executions deployed to this environment (deploy-scoped). */
+    environment?: string;
+    /** Count only executions tagged with ANY environment (real deployments). */
+    deploysOnly?: boolean;
+}
+/**
+ * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).
+ *
+ * A "deployment" is a TERMINAL pipeline-level event, rolled up to one row per
+ * `execution_id` (FAILED wins, then SUCCEEDED, then CANCELED/STOPPED — same
+ * precedence as `listPipelineExecutions`).
+ *
+ * DISCLOSURE — these are RUN-BASED approximations of DORA. A "deployment" here
+ * is any successful pipeline RUN, not a verified production deployment: the
+ * event stream carries no deploy-stage/environment marker, so a CI-only
+ * build/test pipeline counts the same as one that ships to prod. That makes
+ * `deploymentFrequency` a pipeline-throughput signal and `changeFailureRate` a
+ * pipeline-failure rate (build/test failures caught in CI count too), and MTTR
+ * a pipeline-recovery time. Only `leadTime` carries an explicit `approx` flag
+ * (it is additionally a run-time proxy), but ALL four share the run≠deploy
+ * caveat until deploy/commit metadata is captured. See docs/dora-metrics.md.
+ */
+export interface DoraMetrics {
+    /** The [from,to] window echoed back (started_at range). */
+    window: {
+        from: string;
+        to: string;
+    };
+    /**
+     * Whether the numbers count real deployments or pipeline runs:
+     * - `'deploy'` — scoped to executions tagged with a deploy `environment`
+     *   (via `environment`/`deploysOnly`); a genuine deployment signal.
+     * - `'run'` — default: every successful PIPELINE run counts (no deploy
+     *   marker applied). DF/CFR/MTTR then reflect pipeline activity, not deploys.
+     */
+    basis: 'deploy' | 'run';
+    /** The scoping applied (echoed for the UI); `null` when unscoped. */
+    filters: {
+        pipelineId: string | null;
+        environment: string | null;
+    };
+    /** Deployment Frequency — SUCCEEDED terminal deployments in the window. */
+    deploymentFrequency: {
+        /** Count of successful deployments. */
+        deployments: number;
+        /** Successful deployments per day over the window. */
+        perDay: number;
+        /** Performance band, or null when there were no deployments. */
+        level: DoraLevel;
+    };
+    /** Change Failure Rate — failed / (succeeded + failed); CANCELED excluded. */
+    changeFailureRate: {
+        failed: number;
+        /** succeeded + failed (the CFR denominator). */
+        total: number;
+        /** failed/total as a percentage, 0–100, 1 decimal. */
+        pct: number;
+        /** Performance band, or null when there were no deployments to judge. */
+        level: DoraLevel;
+    };
+    /** Mean Time To Restore — avg gap from a failure INCIDENT to its recovery.
+     *  Consecutive failed runs of a pipeline (with no green run between) collapse
+     *  into one incident; the gap is measured from the first failure's END to the
+     *  recovering run's END. The recovery is visible up to a look-ahead past `to`
+     *  so a failure near the window edge isn't spuriously counted unrestored. */
+    meanTimeToRestore: {
+        /** Failure incidents in the window (maximal runs of consecutive failures). */
+        failures: number;
+        /** Incidents that were followed by a succeeded run (recovered). */
+        restored: number;
+        /** Average restore gap in seconds; null when there were no incidents. */
+        avgSeconds: number | null;
+        /** Performance band, or null when there were no incidents. */
+        level: DoraLevel;
+    };
+    /** Lead Time — PROXY: median pipeline RUN TIME of succeeded deployments.
+     *  NOT true commit→prod lead time (executions don't capture commit time),
+     *  hence `approx: true` so the UI/docs can label it. */
+    leadTime: {
+        /** Succeeded deployments with a duration (the median sample). */
+        deployments: number;
+        /** Median run time in seconds; null when no successful deployments. */
+        medianSeconds: number | null;
+        approx: true;
+        /** Performance band, or null when there were no successful deployments. */
+        level: DoraLevel;
+    };
+}
+/** One interval bucket of the DORA trend (deployment frequency + change failure). */
+export interface DoraTrendPoint {
+    /** Bucket start (DATE_TRUNC of started_at), ISO text. */
+    period: string;
+    /** Successful deployments in the bucket. */
+    deployments: number;
+    /** Failed deployments in the bucket. */
+    failed: number;
+    /** succeeded + failed in the bucket. */
+    total: number;
+    /** failed/total as a percent (0 when total is 0). */
+    changeFailurePct: number;
+}
 /** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */
 export interface IngestEvent {
     /** Stable pipeline id the events Lambda read from the `PIPELINE_EVENT_ID`
@@ -116,6 +227,12 @@ export interface IngestEvent {
     startedAt?: string;
     completedAt?: string;
     durationMs?: number;
+    /** Source commit id of the change being shipped (DORA deploy attribution). */
+    commitSha?: string;
+    /** Source ref/branch (DORA deploy attribution). */
+    commitRef?: string;
+    /** Deploy target (e.g. "production"). Its presence marks a real deployment. */
+    environment?: string;
     detail?: Record<string, unknown>;
 }
 /** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */
@@ -163,7 +280,10 @@ export declare class ReportingService {
      */
     private runReport;
     /** 1.1 Execution count per pipeline with status breakdown. */
-    getExecutionCount(orgId: string, orgIds?: string[]): Promise<ExecutionCount[]>;
+    getExecutionCount(orgId: string, orgIds?: string[], range?: {
+        from?: string;
+        to?: string;
+    }): Promise<ExecutionCount[]>;
     /**
      * 1.1b Per-pipeline execution history — DISTINCT executions for one pipeline,
      * newest first. Groups all events by `execution_id` in a single scan and
@@ -196,6 +316,44 @@ export declare class ReportingService {
     getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<ActionFailure[]>;
     /** 1.8 Error categorization — group failure messages. */
     getErrors(orgId: string, from: string, to: string, limit?: number): Promise<ErrorEntry[]>;
+    /**
+     * 1.9 DORA metrics over [from,to] (started_at range), org-scoped + rollup-aware.
+     *
+     * All four metrics derive from a per-execution roll-up of TERMINAL PIPELINE
+     * events (one row per execution_id+pipeline_id; FAILED wins, then SUCCEEDED,
+     * then CANCELED/STOPPED — mirroring `listPipelineExecutions`). The scan is
+     * gated by the `p.org_id ${pred}` join exactly like the sibling reports, so a
+     * rollup passes the org→team subtree and a foreign org's executions never
+     * enter the aggregate.
+     *
+     * DF/CFR/lead-time count only CORE-window executions ([from,to]). MTTR is
+     * per-INCIDENT: consecutive failures collapse into one incident and the
+     * recovery lookup may see the next success up to MTTR_RESTORE_LOOKAHEAD past
+     * `to`, so a failure near the edge isn't right-censored into "never restored".
+     * The scan bound is therefore `[from, to + look-ahead]`; the started_at range
+     * still rides the same index as the sibling reports.
+     *
+     * DISCLOSURE: by default DF/CFR/MTTR are RUN-based (any successful PIPELINE
+     * run = a "deployment"), and Lead Time is additionally a run-time PROXY
+     * flagged `approx: true`. Pass `environment` or `deploysOnly` to scope to
+     * executions tagged with a real deploy target — the response `basis` reports
+     * which was used. See the DoraMetrics doc + docs/dora-metrics.md.
+     *
+     * @param opts.pipelineId    restrict to one pipeline (per-pipeline DORA)
+     * @param opts.environment   count only executions deployed to this target
+     * @param opts.deploysOnly   count only executions tagged with ANY environment
+     */
+    getDoraMetrics(orgId: string, from: string, to: string, orgIds?: string[], opts?: DoraOptions): Promise<DoraMetrics>;
+    /** Shape a single DORA aggregate row into the public {@link DoraMetrics}. */
+    private shapeDora;
+    /**
+     * 1.9b DORA trend — deployment frequency + change-failure rate bucketed by
+     * `interval` (day/week/month) for a sparkline. Per-execution rollup (one row
+     * per execution, FAILED wins) bucketed on the execution's started_at. Shares
+     * the `getDoraMetrics` scoping (org/rollup, pipelineId, deploy-scoping); MTTR
+     * and lead time are intentionally omitted (too heavy to bucket meaningfully).
+     */
+    getDoraTrend(orgId: string, interval: string, from: string, to: string, orgIds?: string[], opts?: DoraOptions): Promise<DoraTrendPoint[]>;
     /** 2.1 Plugin summary — counts and breakdowns. */
     getPluginSummary(orgId: string): Promise<PluginSummary>;
     /** 2.2 Type & compute distribution. */

package/lib/api/reporting-service.js

@@ -13,6 +13,131 @@ const logger = createLogger('reporting-service');
  */
 const inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));
 const timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));
+/** Raw single-row shape returned by the DORA aggregate query (pre-shaping). */
+/**
+ * How far past the report's `to` bound the DORA MTTR query may look for a
+ * failure's recovering run. Bounds the scan while stopping a failure near the
+ * window edge from being spuriously scored "never restored". A failure that
+ * has not recovered within this window stays counted as an open incident.
+ */
+const MTTR_RESTORE_LOOKAHEAD = '30 days';
+// DORA performance bands (thresholds from the DORA/Accelerate reports). Each
+// helper returns `null` when there's no sample to classify.
+/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */
+function doraLevelForFrequency(perDay, deployments) {
+    if (deployments <= 0)
+        return null;
+    if (perDay >= 1)
+        return 'elite';
+    if (perDay >= 1 / 7)
+        return 'high';
+    if (perDay >= 1 / 30)
+        return 'medium';
+    return 'low';
+}
+/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */
+function doraLevelForChangeFailure(pct, total) {
+    if (total <= 0)
+        return null;
+    if (pct <= 5)
+        return 'elite';
+    if (pct <= 10)
+        return 'high';
+    if (pct <= 15)
+        return 'medium';
+    return 'low';
+}
+/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */
+function doraLevelForRestore(avgSeconds) {
+    if (avgSeconds == null)
+        return null;
+    if (avgSeconds < 3600)
+        return 'elite';
+    if (avgSeconds < 86400)
+        return 'high';
+    if (avgSeconds < 604800)
+        return 'medium';
+    return 'low';
+}
+/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */
+function doraLevelForLeadTime(medianSeconds) {
+    if (medianSeconds == null)
+        return null;
+    if (medianSeconds < 86400)
+        return 'elite';
+    if (medianSeconds < 604800)
+        return 'high';
+    if (medianSeconds < 2592000)
+        return 'medium';
+    return 'low';
+}
+/**
+ * Round `value` to `digits` decimal places, returning a real number. Small
+ * module-private helper so the DORA shaping doesn't repeat the
+ * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).
+ */
+function round(value, digits) {
+    return Number(value.toFixed(digits));
+}
+/**
+ * Shared per-execution terminal-status roll-up for the DORA `execs` CTEs:
+ * FAILED wins, then SUCCEEDED, else CANCELED/STOPPED. Kept in one place so
+ * getDoraMetrics and getDoraTrend can't drift on the precedence.
+ */
+const DORA_TERMINAL_STATUS_CASE = sql `
+            CASE
+              WHEN bool_or(e.status = 'FAILED') THEN 'FAILED'
+              WHEN bool_or(e.status = 'SUCCEEDED') THEN 'SUCCEEDED'
+              ELSE 'CANCELED'
+            END`;
+/**
+ * Optional per-pipeline / deploy-scoping predicates + the resulting `basis`,
+ * shared by getDoraMetrics and getDoraTrend so the env/deploysOnly precedence
+ * can't diverge. `environment` (one target) wins over `deploysOnly` (any env).
+ */
+function doraScopeClauses(opts) {
+    const { pipelineId, environment, deploysOnly } = opts;
+    const pipelineClause = pipelineId ? sql `AND e.pipeline_id = ${pipelineId}` : sql ``;
+    const deployClause = environment
+        ? sql `AND e.environment = ${environment}`
+        : deploysOnly ? sql `AND e.environment IS NOT NULL` : sql ``;
+    const basis = environment || deploysOnly ? 'deploy' : 'run';
+    return { pipelineClause, deployClause, basis };
+}
+/**
+ * Shared `execs` CTE body — the per-execution terminal roll-up that BOTH DORA
+ * methods scan. Only the SELECTed columns and the upper range bound differ
+ * (getDoraMetrics needs pipeline_id/ended_at/duration_ms plus a look-ahead tail
+ * for MTTR recovery; getDoraTrend needs only started_at over the core window),
+ * so those are the parameters. The `event_type='PIPELINE'` gate, the
+ * SUCCEEDED/FAILED/CANCELED/STOPPED status set, the `execution_id` filter, the
+ * org + deploy/pipeline scope clauses, and the `GROUP BY` all live here so the
+ * two callers can't drift on the status set or the predicate.
+ *
+ * @param columns  trailing SELECT columns (after `e.execution_id,`)
+ * @param toBound  the `<=` upper-bound expression on `e.started_at`
+ *                 (core window for the trend; core + look-ahead for metrics)
+ */
+function execsCte(args) {
+    const { pred, columns, pipelineClause, deployClause, from, toBound } = args;
+    return sql `
+        SELECT
+          e.execution_id,
+          ${columns}
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE'
+          -- STOPPED (manually aborted) joins CANCELED in the ELSE bucket; both
+          -- are terminal non-deploy outcomes. SUPERSEDED stays excluded (a
+          -- replaced execution, not an outcome).
+          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED', 'STOPPED')
+          AND e.execution_id IS NOT NULL
+          ${pipelineClause}
+          ${deployClause}
+          AND e.started_at >= ${from}::timestamptz
+          AND e.started_at <= ${toBound}
+        GROUP BY e.execution_id, e.pipeline_id`;
+}
 // ─── Service ────────────────────────────────────────────
 /**
  * Read-only reporting service for pipeline execution and plugin inventory aggregations.
@@ -98,6 +223,17 @@ export class ReportingService {
                     startedAt: event.startedAt ? new Date(event.startedAt) : undefined,
                     completedAt: event.completedAt ? new Date(event.completedAt) : undefined,
                     durationMs: event.durationMs,
+                    // Deploy-attribution fields — scrubbed like the other free-form strings
+                    // so an ARN/account id can never enter via a ref or environment name.
+                    commitSha: event.commitSha !== undefined
+                        ? scrubAwsIdentifiersFromString(event.commitSha)
+                        : undefined,
+                    commitRef: event.commitRef !== undefined
+                        ? scrubAwsIdentifiersFromString(event.commitRef)
+                        : undefined,
+                    environment: event.environment !== undefined
+                        ? scrubAwsIdentifiersFromString(event.environment)
+                        : undefined,
                     detail: event.detail !== undefined
                         ? scrubAwsIdentifiers(event.detail)
                         : undefined,
@@ -169,8 +305,17 @@ export class ReportingService {
             : timeseriesCache.getOrSet(cacheKey, exec);
     }
     /** 1.1 Execution count per pipeline with status breakdown. */
-    async getExecutionCount(orgId, orgIds) {
+    async getExecutionCount(orgId, orgIds, range) {
         const { pred, multi } = this.orgScope(orgId, orgIds);
+        // Optional [from,to] window on the execution's started_at, mirroring the
+        // sibling timeseries reports so the dashboard date-range picker narrows the
+        // count too (an empty range = all-time, preserving the prior behavior). The
+        // range rides the JOIN so pipelines with no in-window events still list
+        // (LEFT semantics preserved via the inner-join filter — a pipeline with zero
+        // matching events drops from the count, same as before for its window).
+        const rangeClause = range?.from && range?.to
+            ? sql `AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`
+            : sql ``;
         const exec = () => withTenantTx((tx) => tx.execute(sql `
         SELECT
           p.id, p.project, p.organization, p.pipeline_name,
@@ -183,11 +328,12 @@ export class ReportingService {
         FROM ${schema.pipeline} p
         JOIN ${schema.pipelineEvent} e ON e.pipeline_id = p.id
           AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'
+          ${rangeClause}
         WHERE p.org_id ${pred} AND p.is_active = true
         GROUP BY p.id
         ORDER BY total DESC
       `).then(r => drizzleRows(r.rows)));
-        return this.runReport(`${orgId}:exec-count`, multi, exec);
+        return this.runReport(`${orgId}:exec-count:${range?.from ?? ''}:${range?.to ?? ''}`, multi, exec);
     }
     /**
      * 1.1b Per-pipeline execution history — DISTINCT executions for one pipeline,
@@ -341,6 +487,239 @@ export class ReportingService {
         LIMIT ${limit}
       `).then(r => drizzleRows(r.rows))));
     }
+    /**
+     * 1.9 DORA metrics over [from,to] (started_at range), org-scoped + rollup-aware.
+     *
+     * All four metrics derive from a per-execution roll-up of TERMINAL PIPELINE
+     * events (one row per execution_id+pipeline_id; FAILED wins, then SUCCEEDED,
+     * then CANCELED/STOPPED — mirroring `listPipelineExecutions`). The scan is
+     * gated by the `p.org_id ${pred}` join exactly like the sibling reports, so a
+     * rollup passes the org→team subtree and a foreign org's executions never
+     * enter the aggregate.
+     *
+     * DF/CFR/lead-time count only CORE-window executions ([from,to]). MTTR is
+     * per-INCIDENT: consecutive failures collapse into one incident and the
+     * recovery lookup may see the next success up to MTTR_RESTORE_LOOKAHEAD past
+     * `to`, so a failure near the edge isn't right-censored into "never restored".
+     * The scan bound is therefore `[from, to + look-ahead]`; the started_at range
+     * still rides the same index as the sibling reports.
+     *
+     * DISCLOSURE: by default DF/CFR/MTTR are RUN-based (any successful PIPELINE
+     * run = a "deployment"), and Lead Time is additionally a run-time PROXY
+     * flagged `approx: true`. Pass `environment` or `deploysOnly` to scope to
+     * executions tagged with a real deploy target — the response `basis` reports
+     * which was used. See the DoraMetrics doc + docs/dora-metrics.md.
+     *
+     * @param opts.pipelineId    restrict to one pipeline (per-pipeline DORA)
+     * @param opts.environment   count only executions deployed to this target
+     * @param opts.deploysOnly   count only executions tagged with ANY environment
+     */
+    async getDoraMetrics(orgId, from, to, orgIds, opts = {}) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const { pipelineId, environment, deploysOnly } = opts;
+        // Optional deploy-scoping / per-pipeline predicates, folded into the execs
+        // scan so failures AND their recovery successes are filtered consistently.
+        const { pipelineClause, deployClause, basis } = doraScopeClauses(opts);
+        // Scan the CORE window plus a look-ahead tail: the extra tail exists only
+        // so a late failure can still find its recovery (see the restore CTE).
+        const execs = execsCte({
+            pred,
+            pipelineClause,
+            deployClause,
+            from,
+            columns: sql `
+            e.pipeline_id,
+            ${DORA_TERMINAL_STATUS_CASE} AS status,
+            MIN(e.started_at) AS started_at,
+            MAX(e.completed_at) AS ended_at,
+            MAX(e.duration_ms) AS duration_ms`,
+            toBound: sql `${to}::timestamptz + ${MTTR_RESTORE_LOOKAHEAD}::interval`,
+        });
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        WITH execs AS (${execs}
+        ),
+        -- Core-window executions ([from,to]); DF/CFR/lead-time count only these.
+        -- The look-ahead rows above are used ONLY as MTTR recovery candidates.
+        core AS (
+          SELECT * FROM execs WHERE started_at <= ${to}::timestamptz
+        ),
+        df AS (
+          SELECT COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS deployments
+          FROM core
+        ),
+        cfr AS (
+          SELECT
+            COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failed,
+            COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED'))::int AS total
+          FROM core
+        ),
+        lt AS (
+          SELECT
+            COUNT(*)::int AS deployments,
+            PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY duration_ms)::float AS median_ms
+          FROM core
+          WHERE status = 'SUCCEEDED' AND duration_ms IS NOT NULL
+        ),
+        -- For each core-window failure, find the END of its recovering run: the
+        -- next SUCCEEDED run of the same pipeline that ENDED after this failure
+        -- ended (visible into the look-ahead tail). SELECT and MEASURE both key
+        -- off ended_at so they stay consistent -- the incident gap is
+        -- restored_at (success end) minus incident_started (first failure end),
+        -- so picking the recovery by ended_at (not started_at) rules out the
+        -- negative gap that a concurrent success which STARTED after the failure
+        -- but ENDED before it would otherwise fold into AVG. Measuring from the
+        -- failure's END (not start) also keeps the failed run's own duration out
+        -- of restore time. Ordering by ended_at makes the incident collapse fall
+        -- out naturally: a green run ending between two failures splits them.
+        restore AS (
+          SELECT
+            f.pipeline_id,
+            f.ended_at AS fail_ended,
+            (SELECT s.ended_at FROM execs s
+              WHERE s.pipeline_id = f.pipeline_id AND s.status = 'SUCCEEDED'
+                AND s.ended_at > f.ended_at
+              ORDER BY s.ended_at ASC LIMIT 1) AS restored_at
+          FROM core f
+          WHERE f.status = 'FAILED'
+        ),
+        -- Collapse to INCIDENTS: failures sharing the same recovery (i.e. with
+        -- no green run between them) are one incident, starting at the first
+        -- failure's end. Unrecovered failures share restored_at = NULL and form
+        -- the single trailing open incident per pipeline.
+        incidents AS (
+          SELECT pipeline_id, restored_at, MIN(fail_ended) AS incident_started
+          FROM restore
+          GROUP BY pipeline_id, restored_at
+        ),
+        mttr AS (
+          SELECT
+            COUNT(*)::int AS failures,
+            -- restored must equal the count of incidents that actually
+            -- contribute to avg_seconds. Guard on incident_started too: a
+            -- failure with a NULL completed_at yields a NULL incident_started
+            -- that contributes NULL (not a real gap) to AVG, so it must not be
+            -- counted as restored either -- otherwise restored could exceed
+            -- the number of measured incidents.
+            COUNT(*) FILTER (
+              WHERE restored_at IS NOT NULL AND incident_started IS NOT NULL
+            )::int AS restored,
+            AVG(EXTRACT(EPOCH FROM (restored_at - incident_started)))
+              FILTER (WHERE restored_at IS NOT NULL AND incident_started IS NOT NULL)::float AS avg_seconds
+          FROM incidents
+        )
+        SELECT
+          df.deployments AS df_deployments,
+          cfr.failed AS cfr_failed,
+          cfr.total AS cfr_total,
+          lt.deployments AS lt_deployments,
+          lt.median_ms AS lt_median_ms,
+          mttr.failures AS mttr_failures,
+          mttr.restored AS mttr_restored,
+          mttr.avg_seconds AS mttr_avg_seconds
+        FROM df, cfr, lt, mttr
+      `).then(r => this.shapeDora(drizzleRows(r.rows)[0], from, to, basis, { pipelineId, environment })));
+        // `environment` WINS over `deploysOnly` in doraScopeClauses, so with an
+        // environment set the deploysOnly flag never affects the SQL — append the
+        // 'd' marker only when it genuinely changes the query (environment absent),
+        // otherwise `{environment:'prod', deploysOnly:true}` would mint a redundant
+        // cache entry identical to `{environment:'prod'}`.
+        const deployMarker = !environment && deploysOnly ? 'd' : '';
+        const key = `${orgId}:dora:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}:${deployMarker}`;
+        return this.runReport(key, multi, exec);
+    }
+    /** Shape a single DORA aggregate row into the public {@link DoraMetrics}. */
+    shapeDora(row, from, to, basis, filters) {
+        // `FROM df, cfr, lt, mttr` always yields exactly one row (each CTE is a
+        // single-row aggregate), but guard against an empty result defensively.
+        const r = row ?? {};
+        const deployments = Number(r.df_deployments) || 0;
+        // Floor the divisor at one day: a window shorter than a day (incl. the
+        // degenerate from==to) has no meaningful sub-day rate, so it's treated as a
+        // single day rather than extrapolated or mislabeled as a raw count.
+        // Floor at one day and guard against unparseable dates (Date.parse → NaN,
+        // which would otherwise propagate through perDay). Falls back to a 1-day
+        // window so a bad range yields the raw count as the rate, never NaN.
+        const spanDays = (Date.parse(to) - Date.parse(from)) / 86400000;
+        const days = Number.isFinite(spanDays) ? Math.max(spanDays, 1) : 1;
+        // Band on the UNROUNDED rate; round only for display. Rounding first would
+        // mislabel exact weekly/monthly boundaries (e.g. 1 deploy / 30 days →
+        // 0.0333 rounds to 0.03 < 1/30 → wrongly "low" instead of "medium").
+        const rawPerDay = deployments / days;
+        const perDay = round(rawPerDay, 2);
+        const failed = Number(r.cfr_failed) || 0;
+        const total = Number(r.cfr_total) || 0;
+        const rawPct = total > 0 ? (failed / total) * 100 : 0;
+        const pct = round(rawPct, 1);
+        // Band restore/lead-time on the RAW (pre-round) seconds, the same "band on
+        // the unrounded value" principle used for perDay/pct above; keep the rounded
+        // values for the response fields. Immaterial at the hour/day thresholds, but
+        // it makes the principle uniform across all four metrics.
+        const failures = Number(r.mttr_failures) || 0;
+        const restored = Number(r.mttr_restored) || 0;
+        const rawAvgSeconds = failures > 0 && r.mttr_avg_seconds != null
+            ? Number(r.mttr_avg_seconds)
+            : null;
+        const avgSeconds = rawAvgSeconds != null ? round(rawAvgSeconds, 1) : null;
+        const ltDeployments = Number(r.lt_deployments) || 0;
+        const rawMedianSeconds = r.lt_median_ms != null
+            ? Number(r.lt_median_ms) / 1000
+            : null;
+        const medianSeconds = rawMedianSeconds != null ? round(rawMedianSeconds, 1) : null;
+        return {
+            window: { from, to },
+            basis,
+            filters: { pipelineId: filters.pipelineId ?? null, environment: filters.environment ?? null },
+            deploymentFrequency: { deployments, perDay, level: doraLevelForFrequency(rawPerDay, deployments) },
+            changeFailureRate: { failed, total, pct, level: doraLevelForChangeFailure(rawPct, total) },
+            meanTimeToRestore: { failures, restored, avgSeconds, level: doraLevelForRestore(rawAvgSeconds) },
+            leadTime: { deployments: ltDeployments, medianSeconds, approx: true, level: doraLevelForLeadTime(rawMedianSeconds) },
+        };
+    }
+    /**
+     * 1.9b DORA trend — deployment frequency + change-failure rate bucketed by
+     * `interval` (day/week/month) for a sparkline. Per-execution rollup (one row
+     * per execution, FAILED wins) bucketed on the execution's started_at. Shares
+     * the `getDoraMetrics` scoping (org/rollup, pipelineId, deploy-scoping); MTTR
+     * and lead time are intentionally omitted (too heavy to bucket meaningfully).
+     */
+    async getDoraTrend(orgId, interval, from, to, orgIds, opts = {}) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const { pipelineId, environment, deploysOnly } = opts;
+        const { pipelineClause, deployClause } = doraScopeClauses(opts);
+        // Same execs roll-up as getDoraMetrics (shared builder — status set +
+        // predicate can't drift); the trend needs only started_at over the core
+        // window (no MTTR look-ahead, no ended_at/duration columns).
+        const execs = execsCte({
+            pred,
+            pipelineClause,
+            deployClause,
+            from,
+            columns: sql `
+            ${DORA_TERMINAL_STATUS_CASE} AS status,
+            MIN(e.started_at) AS started_at`,
+            toBound: sql `${to}::timestamptz`,
+        });
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        WITH execs AS (${execs}
+        )
+        SELECT
+          DATE_TRUNC(${interval}, started_at)::text AS period,
+          COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS deployments,
+          COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failed,
+          COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED'))::int AS total,
+          -- quoted alias so the raw row key is exactly the DoraTrendPoint field
+          COALESCE(ROUND(COUNT(*) FILTER (WHERE status = 'FAILED')::numeric
+            / NULLIF(COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED')), 0) * 100, 1), 0)::float AS "changeFailurePct"
+        FROM execs
+        GROUP BY period ORDER BY period
+      `).then(r => drizzleRows(r.rows)));
+        // Omit the deploysOnly marker when environment is set: it wins in
+        // doraScopeClauses, so the SQL (and thus the correct cache key) is identical
+        // to the environment-only case. Only append 'd' when it changes the query.
+        const deployMarker = !environment && deploysOnly ? 'd' : '';
+        const key = `${orgId}:dora-trend:${interval}:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}:${deployMarker}`;
+        return this.runReport(key, multi, exec);
+    }
     // ── Category 2: Plugin Inventory & Builds ──
     /** 2.1 Plugin summary — counts and breakdowns. */
     async getPluginSummary(orgId) {
@@ -447,4 +826,4 @@ export class ReportingService {
     }
 }
 export const reportingService = new ReportingService();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting-service.js","sourceRoot":"","sources":["../../src/api/reporting-service.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAChJ,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE5E,MAAM,MAAM,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAEjD;;;;GAIG;AACH,MAAM,cAAc,GAAG,kBAAkB,CAAC,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,0BAA0B,IAAI,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;AACxH,MAAM,eAAe,GAAG,kBAAkB,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,2BAA2B,IAAI,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;AAkJzH,2DAA2D;AAE3D;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAgB;IAE3B,0EAA0E;IAC1E,KAAK,CAAC,aAAa,CAAC,KAAa;QAC/B,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,cAAc,CAAC,iBAAiB,CAAC,GAAG,KAAK,IAAI,CAAC;YAC9C,eAAe,CAAC,iBAAiB,CAAC,GAAG,KAAK,IAAI,CAAC;SAChD,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,YAAY,CAAC,MAAqB;QACtC,uEAAuE;QACvE,sEAAsE;QACtE,2EAA2E;QAC3E,sEAAsE;QACtE,qEAAqE;QACrE,qEAAqE;QACrE,4DAA4D;QAC5D,qEAAqE;QACrE,wEAAwE;QACxE,wEAAwE;QACxE,uEAAuE;QACvE,sEAAsE;QACtE,gDAAgD;QAChD,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,GAAG,MAAM,YAAY,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACnG,qDAAqD;YACrD,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC9D,MAAM,YAAY,GAAG,MAAM,EAAE;iBAC1B,MAAM,CAAC;gBACN,UAAU,EAAE,MAAM,CAAC,gBAAgB,CAAC,UAAU;gBAC9C,KAAK,EAAE,MAAM,CAAC,gBAAgB,CAAC,KAAK;aACrC,CAAC;iBACD,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;iBAC7B,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;YAEjE,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAEhE,mEAAmE;YACnE,MAAM,IAAI,GAAoD,EAAE,CAAC;YACjE,IAAI,YAAY,GAAG,CAAC,CAAC;YACrB,MAAM,iBAAiB,GAAa,EAAE,CAAC;YAEvC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;gBAC7C,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,YAAY,EAAE,CAAC;oBACf,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;oBACzC,SAAS;gBACX,CAAC;gBAED,IAAI,CAAC,IAAI,CAAC;oBACR,sEAAsE;oBACtE,uEAAuE;oBACvE,kDAAkD;oBAClD,UAAU,EAAE,QAAQ,CAAC,UAAU;oBAC/B,KAAK,EAAE,QAAQ,CAAC,KAAK;oBACrB,WAAW,EAAE,KAAK,CAAC,WAAW;oBAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,WAAW,EAAE,KAAK,CAAC,WAAW;oBAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;oBAC5B,sEAAsE;oBACtE,gEAAgE;oBAChE,mEAAmE;oBACnE,uEAAuE;oBACvE,sEAAsE;oBACtE,YAAY,EAAE,KAAK,CAAC,YAAY,KAAK,SAAS;wBAC5C,CAAC,CAAC,6BAA6B,CAAC,KAAK,CAAC,YAAY,CAAC;wBACnD,CAAC,CAAC,SAAS;oBACb,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;oBAClE,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS;oBACxE,UAAU,EAAE,KAAK,CAAC,UAAU;oBAC5B,MAAM,EAAE,KAAK,CAAC,MAAM,KAAK,SAAS;wBAChC,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC;wBACnC,CAAC,CAAC,SAAS;iBACd,CAAC,CAAC;YACL,CAAC;YAED,yEAAyE;YACzE,6DAA6D;YAC7D,2EAA2E;YAC3E,2EAA2E;YAC3E,iDAAiD;YACjD,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC;gBAClC,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;qBACjD,mBAAmB,EAAE;qBACrB,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;gBACnD,CAAC,CAAC,EAAE,CAAC;YAEP,OAAO;gBACL,QAAQ,EAAE,YAAY,CAAC,MAAM;gBAC7B,OAAO,EAAE,YAAY;gBACrB,uBAAuB,EAAE,iBAAiB;gBAC1C,YAAY,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;aAC3D,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,yEAAyE;QACzE,8DAA8D;QAC9D,yEAAyE;QACzE,qEAAqE;QACrE,IAAI,uBAAuB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvC,MAAM,CAAC,IAAI,CAAC,4DAA4D,EAAE;gBACxE,KAAK,EAAE,uBAAuB,CAAC,MAAM;gBACrC,MAAM,EAAE,uBAAuB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;aAC5C,CAAC,CAAC;QACL,CAAC;QAED,wEAAwE;QACxE,sDAAsD;QACtD,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,KAAK,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACxC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;gBACpC,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC/F,CAAC,CAAC,CACH,CAAC,CAAC;QACL,CAAC;QAED,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACxD,CAAC;IAED,qDAAqD;IAErD;;;;;;;OAOG;IACK,QAAQ,CAAC,KAAa,EAAE,MAAiB;QAC/C,MAAM,GAAG,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC3D,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;QAC7B,MAAM,IAAI,GAAG,KAAK;YAChB,CAAC,CAAC,GAAG,CAAA,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAA,GAAG,EAAE,EAAE,CAAC,EAAE,GAAG,CAAA,IAAI,CAAC,GAAG;YAC7D,CAAC,CAAC,GAAG,CAAA,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACK,SAAS,CAAI,QAAgB,EAAE,KAAc,EAAE,IAAsB;QAC3E,OAAO,KAAK;YACV,CAAC,CAAC,oBAAoB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC;YACpD,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED,8DAA8D;IAC9D,KAAK,CAAC,iBAAiB,CAAC,KAAa,EAAE,MAAiB;QACtD,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;;;eAS3C,MAAM,CAAC,QAAQ;eACf,MAAM,CAAC,aAAa;;yBAEV,IAAI;;;OAGtB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,aAAa,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,sBAAsB,CAC1B,KAAa,EACb,UAAkB,EAClB,MAAiB,EACjB,KAAsC,EACtC,QAAgB,EAAE;QAElB,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,WAAW,GAAG,KAAK,EAAE,IAAI,IAAI,KAAK,EAAE,EAAE;YAC1C,CAAC,CAAC,GAAG,CAAA,uBAAuB,KAAK,CAAC,IAAI,qCAAqC,KAAK,CAAC,EAAE,eAAe;YAClG,CAAC,CAAC,GAAG,CAAA,EAAE,CAAC;QACV,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;;;;;;;;eAc3C,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;yBACL,IAAI,wBAAwB,UAAU;YACnD,WAAW;;;gBAGP,KAAK;OACd,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAoB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,wBAAwB,UAAU,IAAI,KAAK,EAAE,IAAI,IAAI,EAAE,IAAI,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACpI,CAAC;IAED,6CAA6C;IAC7C,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,QAAgB,EAAE,IAAY,EAAE,EAAU,EAAE,MAAiB;QAC/F,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;uBAEnC,QAAQ;;;;;;eAMhB,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;yBACL,IAAI;;gCAEG,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,iBAAiB,QAAQ,IAAI,IAAI,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACxF,CAAC;IAED,yCAAyC;IACzC,KAAK,CAAC,kBAAkB,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU,EAAE,MAAiB;QACjF,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;;eAQ3C,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;yBACL,IAAI;gCACG,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,iBAAiB,IAAI,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC5E,CAAC;IAED,0DAA0D;IAC1D,KAAK,CAAC,gBAAgB,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU,EAAE,MAAiB;QAC/E,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;eAO3C,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;yBACL,IAAI;gCACG,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAe,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,mBAAmB,IAAI,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9E,CAAC;IAED,2DAA2D;IAC3D,KAAK,CAAC,mBAAmB,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU,EAAE,MAAiB;QAClF,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;eAK3C,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;yBACL,IAAI;gCACG,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,sBAAsB,IAAI,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACjF,CAAC;IAED,8DAA8D;IAC9D,KAAK,CAAC,iBAAiB,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU,EAAE,MAAiB;QAChF,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;eAO3C,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;yBACL,IAAI;gCACG,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,oBAAoB,IAAI,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC/E,CAAC;IAED,yDAAyD;IACzD,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU,EAAE,QAAgB,EAAE;QACzE,OAAO,eAAe,CAAC,QAAQ,CAAC,GAAG,KAAK,WAAW,IAAI,IAAI,EAAE,IAAI,KAAK,EAAE,EAAE,GAAG,EAAE,CAC7E,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;eAM1B,MAAM,CAAC,aAAa;eACpB,MAAM,CAAC,QAAQ;2BACH,KAAK;gCACA,IAAI,qCAAqC,EAAE;;gBAE3D,KAAK;OACd,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAa,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAC/C,CAAC;IACJ,CAAC;IAED,8CAA8C;IAE9C,kDAAkD;IAClD,KAAK,CAAC,gBAAgB,CAAC,KAAa;QAClC,OAAO,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,iBAAiB,EAAE,KAAK,IAAI,EAAE;YACnE,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;mCAGzB,MAAM,CAAC,MAAM,CAAC,QAAQ;uCAClB,MAAM,CAAC,MAAM,CAAC,QAAQ;mCAC1B,MAAM,CAAC,MAAM,CAAC,cAAc;mCAC5B,MAAM,CAAC,MAAM,CAAC,cAAc;2BACpC,MAAM,CAAC,MAAM,CAAC,IAAI;eAC9B,MAAM,CAAC,MAAM;gBACZ,MAAM,CAAC,MAAM,CAAC,KAAK,MAAM,KAAK;OACvC,CAAC,CAAC,CAAC;YACJ,OAAO,CAAC,WAAW,CAAgB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;QACnI,CAAC,CAAC,CAAC;IACL,CAAC;IAED,uCAAuC;IACvC,KAAK,CAAC,qBAAqB,CAAC,KAAa;QACvC,OAAO,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,sBAAsB,EAAE,GAAG,EAAE,CAClE,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;YAE7B,MAAM,CAAC,MAAM,CAAC,UAAU;YACxB,MAAM,CAAC,MAAM,CAAC,WAAW;;eAEtB,MAAM,CAAC,MAAM;gBACZ,MAAM,CAAC,MAAM,CAAC,KAAK,MAAM,KAAK,QAAQ,MAAM,CAAC,MAAM,CAAC,QAAQ;mBACzD,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW;;OAElE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAA0B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAC5D,CAAC;IACJ,CAAC;IAED,0CAA0C;IAC1C,KAAK,CAAC,iBAAiB,CAAC,KAAa;QACnC,OAAO,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,kBAAkB,EAAE,GAAG,EAAE,CAC9D,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;YAE7B,MAAM,CAAC,MAAM,CAAC,IAAI;;gBAEd,MAAM,CAAC,MAAM,CAAC,OAAO;oBACjB,MAAM,CAAC,MAAM,CAAC,SAAS;eAC5B,MAAM,CAAC,MAAM;gBACZ,MAAM,CAAC,MAAM,CAAC,KAAK,MAAM,KAAK,QAAQ,MAAM,CAAC,MAAM,CAAC,QAAQ;mBACzD,MAAM,CAAC,MAAM,CAAC,IAAI;;OAE9B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAe,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CACjD,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,mBAAmB,CAAC,KAAa,EAAE,QAAgB,EAAE,IAAY,EAAE,EAAU;QACjF,OAAO,eAAe,CAAC,QAAQ,CAAC,GAAG,KAAK,kBAAkB,QAAQ,IAAI,IAAI,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,CACvF,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;uBAElB,QAAQ;;;;;eAKhB,MAAM,CAAC,aAAa;2BACR,KAAK;;gCAEA,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAuB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CACzD,CAAC;IACJ,CAAC;IAED,qCAAqC;IACrC,KAAK,CAAC,gBAAgB,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU;QAC5D,OAAO,eAAe,CAAC,QAAQ,CAAC,GAAG,KAAK,mBAAmB,IAAI,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,CAC5E,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;eAM1B,MAAM,CAAC,aAAa;2BACR,KAAK;gCACA,IAAI,qCAAqC,EAAE;;OAEpE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAClD,CAAC;IACJ,CAAC;IAED,+CAA+C;IAC/C,KAAK,CAAC,gBAAgB,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU,EAAE,QAAgB,EAAE;QAChF,OAAO,eAAe,CAAC,QAAQ,CAAC,GAAG,KAAK,mBAAmB,IAAI,IAAI,EAAE,IAAI,KAAK,EAAE,EAAE,GAAG,EAAE,CACrF,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;eAM1B,MAAM,CAAC,aAAa;2BACR,KAAK;gCACA,IAAI,qCAAqC,EAAE;;;gBAG3D,KAAK;OACd,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAe,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CACjD,CAAC;IACJ,CAAC;CACF;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,EAAE,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createCacheService, createLogger, errorMessage, scrubAwsIdentifiers, scrubAwsIdentifiersFromString } from '@pipeline-builder/api-core';\nimport { inArray, sql } from 'drizzle-orm';\nimport { drizzleRows } from './crud-service.js';\nimport { schema } from '../database/drizzle-schema.js';\nimport { withTenantTx, runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('reporting-service');\n\n/**\n * Cache for reporting aggregations. Two tiers:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD\n * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously\n */\nconst inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));\nconst timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));\n\n// ─── Types ──────────────────────────────────────────────\n\ninterface ExecutionCount {\n  id: string;\n  project: string;\n  organization: string;\n  pipelineName: string | null;\n  total: number;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  firstExecution: string | null;\n  lastExecution: string | null;\n}\n\ninterface TimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  successPct: number;\n}\n\ninterface DurationStats {\n  id: string;\n  project: string;\n  pipelineName: string | null;\n  avgMs: number;\n  minMs: number;\n  maxMs: number;\n  p95Ms: number;\n  executions: number;\n}\n\ninterface PipelineExecution {\n  executionId: string;\n  /** Rolled-up terminal status: succeeded | failed | canceled | in-progress. */\n  status: string;\n  startedAt: string | null;\n  endedAt: string | null;\n  durationMs: number | null;\n  /** First failing stage/action for the execution (null when it didn't fail). */\n  failingStage: string | null;\n  failingAction: string | null;\n}\n\ninterface StageFailure {\n  stageName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface StageBottleneck {\n  id: string;\n  pipelineName: string | null;\n  stageName: string;\n  avgMs: number;\n  maxMs: number;\n}\n\ninterface ActionFailure {\n  actionName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface ErrorEntry {\n  errorPattern: string;\n  occurrences: number;\n  affectedPipelines: number;\n  lastSeen: string;\n}\n\ninterface PluginSummary {\n  total: number;\n  active: number;\n  inactive: number;\n  public: number;\n  private: number;\n  uniqueNames: number;\n}\n\ninterface TypeComputeDistribution {\n  pluginType: string;\n  computeType: string;\n  count: number;\n}\n\ninterface VersionCount {\n  name: string;\n  versionCount: number;\n  latestVersion: string;\n  hasDefault: boolean;\n}\n\ninterface BuildTimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  successPct: number;\n}\n\ninterface BuildDuration {\n  pluginName: string;\n  avgMs: number;\n  maxMs: number;\n  builds: number;\n}\n\ninterface BuildFailure {\n  pluginName: string;\n  errorMessage: string;\n  occurrences: number;\n  lastSeen: string;\n}\n\n/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */\nexport interface IngestEvent {\n  /** Stable pipeline id the events Lambda read from the `PIPELINE_EVENT_ID`\n   *  tag (= the platform pipelineId). The registry join key. */\n  pipelineId: string;\n  eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';\n  eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason (Action events). */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  detail?: Record<string, unknown>;\n}\n\n/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */\nexport interface IngestResult {\n  inserted: number;\n  skipped: number;\n  unregisteredPipelineIds: string[];\n}\n\n// ─── Service ────────────────────────────────────────────\n\n/**\n * Read-only reporting service for pipeline execution and plugin inventory aggregations.\n * Does not extend CrudService — reports are aggregate queries, not entity CRUD.\n *\n * All queries are cached in-memory to avoid repeated expensive SQL aggregations:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL\n * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL\n */\nexport class ReportingService {\n\n  /** Invalidate all cached reports for an org (call after event ingest). */\n  async invalidateOrg(orgId: string): Promise<void> {\n    await Promise.all([\n      inventoryCache.invalidatePattern(`${orgId}:*`),\n      timeseriesCache.invalidatePattern(`${orgId}:*`),\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   */\n  async ingestEvents(events: IngestEvent[]): 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 method. 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    // Run insert inside the tx, but COLLECT affected orgs and invalidate\n    // caches AFTER the tx resolves. Keeping invalidation inside the tx held\n    // the pg locks open for the duration of the cache round-trips (Redis or\n    // in-memory invalidations are unrelated to the tx but still serialized\n    // its commit). Cache TTL is 2-5 min so fire-and-forget post-commit is\n    // an acceptable trade for tighter lock windows.\n    const { inserted, skipped, unregisteredPipelineIds, affectedOrgs } = 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\n      // Build insert batch (skip events whose pipeline isn't registered)\n      const rows: Array<typeof schema.pipelineEvent.$inferInsert> = [];\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\n        rows.push({\n          // registry.pipelineId === event.pipelineId; use the registry's so the\n          // FK is always a row that exists, and pull orgId from the registry for\n          // tenancy (never trust the caller's claimed org).\n          pipelineId: registry.pipelineId,\n          orgId: registry.orgId,\n          eventSource: event.eventSource,\n          eventType: event.eventType,\n          status: event.status,\n          executionId: event.executionId,\n          stageName: event.stageName,\n          actionName: event.actionName,\n          // HARD CONSTRAINT: an AWS account id must NEVER be persisted. This is\n          // the DURABLE persistence boundary and must not trust upstream:\n          // CodePipeline/CodeBuild failure detail & messages routinely carry\n          // ARNs (arn:aws:…:<account-id>:…) and bare 12-digit account ids. Scrub\n          // both free-form fields here before insert (per-event, non-mutating).\n          errorMessage: event.errorMessage !== undefined\n            ? scrubAwsIdentifiersFromString(event.errorMessage)\n            : undefined,\n          startedAt: event.startedAt ? new Date(event.startedAt) : undefined,\n          completedAt: event.completedAt ? new Date(event.completedAt) : undefined,\n          durationMs: event.durationMs,\n          detail: event.detail !== undefined\n            ? scrubAwsIdentifiers(event.detail)\n            : undefined,\n        });\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 + cache invalidation ignore duplicates.\n      const insertedRows = rows.length > 0\n        ? await tx.insert(schema.pipelineEvent).values(rows)\n          .onConflictDoNothing()\n          .returning({ orgId: schema.pipelineEvent.orgId })\n        : [];\n\n      return {\n        inserted: insertedRows.length,\n        skipped: skippedLocal,\n        unregisteredPipelineIds: unregisteredLocal,\n        affectedOrgs: [...new Set(insertedRows.map(r => r.orgId))],\n      };\n    });\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    // PIPELINE_EVENT_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        this.invalidateOrg(org).catch((err) => {\n          logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });\n        }),\n      ));\n    }\n\n    return { inserted, skipped, unregisteredPipelineIds };\n  }\n\n  // ── Category 1: Pipeline Execution & Performance ──\n\n  /**\n   * Build the org-scope predicate for a report query. With `orgIds` (the\n   * org → team rollup — a parent's `[self, ...descendants]`) it becomes an\n   * `IN (...)` over the subtree; otherwise the single-org `= $org`. Returns a\n   * `multi` flag so callers can run multi-org reads under sysadmin context\n   * (the subtree spans orgs outside the request's RLS scope) and salt the\n   * cache key.\n   */\n  private orgScope(orgId: string, orgIds?: string[]) {\n    const ids = orgIds && orgIds.length > 0 ? orgIds : [orgId];\n    const multi = ids.length > 1;\n    const pred = multi\n      ? sql`IN (${sql.join(ids.map((id) => sql`${id}`), sql`, `)})`\n      : sql`= ${ids[0]}`;\n    return { pred, multi };\n  }\n\n  /**\n   * Run a report read. Single-org reads use the per-org cache (invalidated on\n   * that org's event ingest). Rollup (multi-org) reads **bypass the cache** and\n   * run under sysadmin context: they're admin-only and lower-frequency, and a\n   * child org's event ingest can't invalidate a parent's rollup entry (reporting\n   * has no org tree), so caching them would serve stale aggregates. Always fresh.\n   */\n  private runReport<T>(cacheKey: string, multi: boolean, exec: () => Promise<T>): Promise<T> {\n    return multi\n      ? runWithTenantContext({ isSuperAdmin: true }, exec)\n      : timeseriesCache.getOrSet(cacheKey, exec);\n  }\n\n  /** 1.1 Execution count per pipeline with status breakdown. */\n  async getExecutionCount(orgId: string, orgIds?: string[]): Promise<ExecutionCount[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.project, p.organization, p.pipeline_name,\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          MIN(e.started_at)::text AS first_execution,\n          MAX(e.started_at)::text AS last_execution\n        FROM ${schema.pipeline} p\n        JOIN ${schema.pipelineEvent} e ON e.pipeline_id = p.id\n          AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'\n        WHERE p.org_id ${pred} AND p.is_active = true\n        GROUP BY p.id\n        ORDER BY total DESC\n      `).then(r => drizzleRows<ExecutionCount>(r.rows)));\n    return this.runReport(`${orgId}:exec-count`, multi, exec);\n  }\n\n  /**\n   * 1.1b Per-pipeline execution history — DISTINCT executions for one pipeline,\n   * newest first. Groups all events by `execution_id` in a single scan and\n   * rolls each execution up to one row:\n   *   - status: derived from the PIPELINE-type events. FAILED wins, then\n   *     SUCCEEDED, then CANCELED; an execution with no terminal PIPELINE event\n   *     is still `in-progress`.\n   *   - startedAt/endedAt/durationMs: from the PIPELINE lifecycle events.\n   *   - failingStage/failingAction: the first FAILED STAGE/ACTION event (cheap —\n   *     same scan, no extra query).\n   *\n   * ORG-SCOPING: identical to the sibling execution reports — joins the pipeline\n   * registry table (`pipeline`) and gates on `p.org_id ${pred}`, where `pred` is\n   * the single-org `= $org` or (with a rollup) an `IN (...)` over the org→team\n   * subtree. A pipelineId belonging to another org yields zero rows.\n   */\n  async listPipelineExecutions(\n    orgId: string,\n    pipelineId: string,\n    orgIds?: string[],\n    range?: { from?: string; to?: string },\n    limit: number = 50,\n  ): Promise<PipelineExecution[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const rangeClause = range?.from && range?.to\n      ? sql`AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`\n      : sql``;\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.execution_id,\n          CASE\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'FAILED') THEN 'failed'\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'SUCCEEDED') THEN 'succeeded'\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'CANCELED') THEN 'canceled'\n            ELSE 'in-progress'\n          END AS status,\n          MIN(e.started_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS started_at,\n          MAX(e.completed_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS ended_at,\n          MAX(e.duration_ms) FILTER (WHERE e.event_type = 'PIPELINE')::int AS duration_ms,\n          (ARRAY_AGG(e.stage_name) FILTER (WHERE e.event_type = 'STAGE' AND e.status = 'FAILED'))[1] AS failing_stage,\n          (ARRAY_AGG(e.action_name) FILTER (WHERE e.event_type = 'ACTION' AND e.status = 'FAILED'))[1] AS failing_action\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.pipeline_id = ${pipelineId} AND e.execution_id IS NOT NULL\n          ${rangeClause}\n        GROUP BY e.execution_id\n        ORDER BY MAX(e.created_at) DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<PipelineExecution>(r.rows)));\n    return this.runReport(`${orgId}:pipeline-executions:${pipelineId}:${range?.from ?? ''}:${range?.to ?? ''}:${limit}`, multi, exec);\n  }\n\n  /** 1.2 Success rate over time for an org. */\n  async getSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[]): Promise<TimeSeriesEntry[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE'\n          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<TimeSeriesEntry>(r.rows)));\n    return this.runReport(`${orgId}:success-rate:${interval}:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.3 Average duration per pipeline. */\n  async getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<DurationStats[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.project, p.pipeline_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MIN(e.duration_ms)::int AS min_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS p95_ms,\n          COUNT(*)::int AS executions\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<DurationStats>(r.rows)));\n    return this.runReport(`${orgId}:avg-duration:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.5 Stage failure heatmap — which stages fail most. */\n  async getStageFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.stage_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.stage_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.stage_name ORDER BY failures DESC\n      `).then(r => drizzleRows<StageFailure>(r.rows)));\n    return this.runReport(`${orgId}:stage-failures:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.6 Stage bottlenecks — slowest stages per pipeline. */\n  async getStageBottlenecks(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageBottleneck[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.pipeline_name, e.stage_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<StageBottleneck>(r.rows)));\n    return this.runReport(`${orgId}:stage-bottlenecks:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.7 Action failure rate — which plugin steps fail most. */\n  async getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<ActionFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.action_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'ACTION' AND e.action_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.action_name ORDER BY failures DESC\n      `).then(r => drizzleRows<ActionFailure>(r.rows)));\n    return this.runReport(`${orgId}:action-failures:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.8 Error categorization — group failure messages. */\n  async getErrors(orgId: string, from: string, to: string, limit: number = 20): Promise<ErrorEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:errors:${from}:${to}:${limit}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          SUBSTRING(e.error_message FROM 1 FOR 200) AS error_pattern,\n          COUNT(*)::int AS occurrences,\n          COUNT(DISTINCT e.pipeline_id)::int AS affected_pipelines,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.status = 'FAILED' AND e.error_message IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY error_pattern ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<ErrorEntry>(r.rows))),\n    );\n  }\n\n  // ── Category 2: Plugin Inventory & Builds ──\n\n  /** 2.1 Plugin summary — counts and breakdowns. */\n  async getPluginSummary(orgId: string): Promise<PluginSummary> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-summary`, async () => {\n      const rows = await withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE ${schema.plugin.isActive})::int AS active,\n          COUNT(*) FILTER (WHERE NOT ${schema.plugin.isActive})::int AS inactive,\n          COUNT(*) FILTER (WHERE ${schema.plugin.accessModifier} = 'public')::int AS public,\n          COUNT(*) FILTER (WHERE ${schema.plugin.accessModifier} = 'private')::int AS private,\n          COUNT(DISTINCT ${schema.plugin.name})::int AS unique_names\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId}\n      `));\n      return (drizzleRows<PluginSummary>(rows.rows)[0] || { total: 0, active: 0, inactive: 0, public: 0, private: 0, uniqueNames: 0 });\n    });\n  }\n\n  /** 2.2 Type & compute distribution. */\n  async getPluginDistribution(orgId: string): Promise<TypeComputeDistribution[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-distribution`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          ${schema.plugin.pluginType} AS plugin_type,\n          ${schema.plugin.computeType} AS compute_type,\n          COUNT(*)::int AS count\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.pluginType}, ${schema.plugin.computeType}\n        ORDER BY count DESC\n      `).then(r => drizzleRows<TypeComputeDistribution>(r.rows))),\n    );\n  }\n\n  /** 2.3 Version counts per plugin name. */\n  async getPluginVersions(orgId: string): Promise<VersionCount[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-versions`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          ${schema.plugin.name},\n          COUNT(*)::int AS version_count,\n          MAX(${schema.plugin.version}) AS latest_version,\n          bool_or(${schema.plugin.isDefault}) AS has_default\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.name}\n        ORDER BY version_count DESC\n      `).then(r => drizzleRows<VersionCount>(r.rows))),\n    );\n  }\n\n  /**\n   * 2.4 Build success rate over time.\n   *\n   * STATUS CASING NOTE: This query filters by `event_source = 'plugin-build'`\n   * and uses lowercase status values (`'completed'`, `'failed'`), while\n   * `getSuccessRate` (1.2) filters by `event_type = 'PIPELINE'` with\n   * uppercase AWS-style statuses (`'SUCCEEDED'`, `'FAILED'`, `'CANCELED'`).\n   * The casing drift is intentional and tracks the producer:\n   *   - `plugin-build` events come from our own build pipeline (lowercase)\n   *   - `PIPELINE` events come from AWS CodePipeline (uppercase)\n   * The ingest Zod schema at api/reporting/src/routes/event-ingest.ts\n   * SHOULD enum these per-eventSource so we catch drift at ingest rather\n   * than silently producing zero rows here. See findings N71.\n   */\n  async getBuildSuccessRate(orgId: string, interval: string, from: string, to: string): Promise<BuildTimeSeriesEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-success:${interval}:${from}:${to}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'completed')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'failed')::int AS failed,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'completed')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build'\n          AND e.status IN ('completed', 'failed')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<BuildTimeSeriesEntry>(r.rows))),\n    );\n  }\n\n  /** 2.5 Build duration per plugin. */\n  async getBuildDuration(orgId: string, from: string, to: string): Promise<BuildDuration[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-duration:${from}:${to}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          COUNT(*)::int AS builds\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<BuildDuration>(r.rows))),\n    );\n  }\n\n  /** 2.6 Build failures — top error messages. */\n  async getBuildFailures(orgId: string, from: string, to: string, limit: number = 20): Promise<BuildFailure[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-failures:${from}:${to}:${limit}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          e.error_message,\n          COUNT(*)::int AS occurrences,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.status = 'failed'\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name, e.error_message\n        ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<BuildFailure>(r.rows))),\n    );\n  }\n}\n\nexport const reportingService = new ReportingService();\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting-service.js","sourceRoot":"","sources":["../../src/api/reporting-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createCacheService, createLogger, errorMessage, scrubAwsIdentifiers, scrubAwsIdentifiersFromString } from '@pipeline-builder/api-core';\nimport { inArray, sql, type SQL } from 'drizzle-orm';\nimport { drizzleRows } from './crud-service.js';\nimport { schema } from '../database/drizzle-schema.js';\nimport { withTenantTx, runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('reporting-service');\n\n/**\n * Cache for reporting aggregations. Two tiers:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD\n * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously\n */\nconst inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));\nconst timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));\n\n// ─── Types ──────────────────────────────────────────────\n\ninterface ExecutionCount {\n  id: string;\n  project: string;\n  organization: string;\n  pipelineName: string | null;\n  total: number;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  firstExecution: string | null;\n  lastExecution: string | null;\n}\n\ninterface TimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  successPct: number;\n}\n\ninterface DurationStats {\n  id: string;\n  project: string;\n  pipelineName: string | null;\n  avgMs: number;\n  minMs: number;\n  maxMs: number;\n  p95Ms: number;\n  executions: number;\n}\n\ninterface PipelineExecution {\n  executionId: string;\n  /** Rolled-up terminal status: succeeded | failed | canceled | in-progress. */\n  status: string;\n  startedAt: string | null;\n  endedAt: string | null;\n  durationMs: number | null;\n  /** First failing stage/action for the execution (null when it didn't fail). */\n  failingStage: string | null;\n  failingAction: string | null;\n}\n\ninterface StageFailure {\n  stageName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface StageBottleneck {\n  id: string;\n  pipelineName: string | null;\n  stageName: string;\n  avgMs: number;\n  maxMs: number;\n}\n\ninterface ActionFailure {\n  actionName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface ErrorEntry {\n  errorPattern: string;\n  occurrences: number;\n  affectedPipelines: number;\n  lastSeen: string;\n}\n\ninterface PluginSummary {\n  total: number;\n  active: number;\n  inactive: number;\n  public: number;\n  private: number;\n  uniqueNames: number;\n}\n\ninterface TypeComputeDistribution {\n  pluginType: string;\n  computeType: string;\n  count: number;\n}\n\ninterface VersionCount {\n  name: string;\n  versionCount: number;\n  latestVersion: string;\n  hasDefault: boolean;\n}\n\ninterface BuildTimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  successPct: number;\n}\n\ninterface BuildDuration {\n  pluginName: string;\n  avgMs: number;\n  maxMs: number;\n  builds: number;\n}\n\ninterface BuildFailure {\n  pluginName: string;\n  errorMessage: string;\n  occurrences: number;\n  lastSeen: string;\n}\n\n/** Raw single-row shape returned by the DORA aggregate query (pre-shaping). */\n/**\n * How far past the report's `to` bound the DORA MTTR query may look for a\n * failure's recovering run. Bounds the scan while stopping a failure near the\n * window edge from being spuriously scored \"never restored\". A failure that\n * has not recovered within this window stays counted as an open incident.\n */\nconst MTTR_RESTORE_LOOKAHEAD = '30 days';\n\n/**\n * DORA performance band. `null` = insufficient data to classify (no\n * deployments/failures/lead-time sample in the window), so the UI shows a\n * neutral state rather than mislabeling an empty window as \"low\".\n */\nexport type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;\n\n/** Optional scoping for {@link ReportingService.getDoraMetrics}. */\nexport interface DoraOptions {\n  /** Restrict to a single pipeline (per-pipeline DORA). */\n  pipelineId?: string;\n  /** Count only executions deployed to this environment (deploy-scoped). */\n  environment?: string;\n  /** Count only executions tagged with ANY environment (real deployments). */\n  deploysOnly?: boolean;\n}\n\n// DORA performance bands (thresholds from the DORA/Accelerate reports). Each\n// helper returns `null` when there's no sample to classify.\n/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */\nfunction doraLevelForFrequency(perDay: number, deployments: number): DoraLevel {\n  if (deployments <= 0) return null;\n  if (perDay >= 1) return 'elite';\n  if (perDay >= 1 / 7) return 'high';\n  if (perDay >= 1 / 30) return 'medium';\n  return 'low';\n}\n/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */\nfunction doraLevelForChangeFailure(pct: number, total: number): DoraLevel {\n  if (total <= 0) return null;\n  if (pct <= 5) return 'elite';\n  if (pct <= 10) return 'high';\n  if (pct <= 15) return 'medium';\n  return 'low';\n}\n/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */\nfunction doraLevelForRestore(avgSeconds: number | null): DoraLevel {\n  if (avgSeconds == null) return null;\n  if (avgSeconds < 3600) return 'elite';\n  if (avgSeconds < 86400) return 'high';\n  if (avgSeconds < 604800) return 'medium';\n  return 'low';\n}\n/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */\nfunction doraLevelForLeadTime(medianSeconds: number | null): DoraLevel {\n  if (medianSeconds == null) return null;\n  if (medianSeconds < 86400) return 'elite';\n  if (medianSeconds < 604800) return 'high';\n  if (medianSeconds < 2592000) return 'medium';\n  return 'low';\n}\n\n/**\n * Round `value` to `digits` decimal places, returning a real number. Small\n * module-private helper so the DORA shaping doesn't repeat the\n * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).\n */\nfunction round(value: number, digits: number): number {\n  return Number(value.toFixed(digits));\n}\n\n/**\n * Shared per-execution terminal-status roll-up for the DORA `execs` CTEs:\n * FAILED wins, then SUCCEEDED, else CANCELED/STOPPED. Kept in one place so\n * getDoraMetrics and getDoraTrend can't drift on the precedence.\n */\nconst DORA_TERMINAL_STATUS_CASE = sql`\n            CASE\n              WHEN bool_or(e.status = 'FAILED') THEN 'FAILED'\n              WHEN bool_or(e.status = 'SUCCEEDED') THEN 'SUCCEEDED'\n              ELSE 'CANCELED'\n            END`;\n\n/**\n * Optional per-pipeline / deploy-scoping predicates + the resulting `basis`,\n * shared by getDoraMetrics and getDoraTrend so the env/deploysOnly precedence\n * can't diverge. `environment` (one target) wins over `deploysOnly` (any env).\n */\nfunction doraScopeClauses(opts: DoraOptions) {\n  const { pipelineId, environment, deploysOnly } = opts;\n  const pipelineClause = pipelineId ? sql`AND e.pipeline_id = ${pipelineId}` : sql``;\n  const deployClause = environment\n    ? sql`AND e.environment = ${environment}`\n    : deploysOnly ? sql`AND e.environment IS NOT NULL` : sql``;\n  const basis: 'deploy' | 'run' = environment || deploysOnly ? 'deploy' : 'run';\n  return { pipelineClause, deployClause, basis };\n}\n\n/**\n * Shared `execs` CTE body — the per-execution terminal roll-up that BOTH DORA\n * methods scan. Only the SELECTed columns and the upper range bound differ\n * (getDoraMetrics needs pipeline_id/ended_at/duration_ms plus a look-ahead tail\n * for MTTR recovery; getDoraTrend needs only started_at over the core window),\n * so those are the parameters. The `event_type='PIPELINE'` gate, the\n * SUCCEEDED/FAILED/CANCELED/STOPPED status set, the `execution_id` filter, the\n * org + deploy/pipeline scope clauses, and the `GROUP BY` all live here so the\n * two callers can't drift on the status set or the predicate.\n *\n * @param columns  trailing SELECT columns (after `e.execution_id,`)\n * @param toBound  the `<=` upper-bound expression on `e.started_at`\n *                 (core window for the trend; core + look-ahead for metrics)\n */\nfunction execsCte(args: {\n  pred: SQL;\n  columns: SQL;\n  pipelineClause: SQL;\n  deployClause: SQL;\n  from: string;\n  toBound: SQL;\n}): SQL {\n  const { pred, columns, pipelineClause, deployClause, from, toBound } = args;\n  return sql`\n        SELECT\n          e.execution_id,\n          ${columns}\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE'\n          -- STOPPED (manually aborted) joins CANCELED in the ELSE bucket; both\n          -- are terminal non-deploy outcomes. SUPERSEDED stays excluded (a\n          -- replaced execution, not an outcome).\n          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED', 'STOPPED')\n          AND e.execution_id IS NOT NULL\n          ${pipelineClause}\n          ${deployClause}\n          AND e.started_at >= ${from}::timestamptz\n          AND e.started_at <= ${toBound}\n        GROUP BY e.execution_id, e.pipeline_id`;\n}\n\ninterface DoraRow {\n  df_deployments?: number | string | null;\n  cfr_failed?: number | string | null;\n  cfr_total?: number | string | null;\n  lt_deployments?: number | string | null;\n  lt_median_ms?: number | string | null;\n  mttr_failures?: number | string | null;\n  mttr_restored?: number | string | null;\n  mttr_avg_seconds?: number | string | null;\n}\n\n/**\n * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).\n *\n * A \"deployment\" is a TERMINAL pipeline-level event, rolled up to one row per\n * `execution_id` (FAILED wins, then SUCCEEDED, then CANCELED/STOPPED — same\n * precedence as `listPipelineExecutions`).\n *\n * DISCLOSURE — these are RUN-BASED approximations of DORA. A \"deployment\" here\n * is any successful pipeline RUN, not a verified production deployment: the\n * event stream carries no deploy-stage/environment marker, so a CI-only\n * build/test pipeline counts the same as one that ships to prod. That makes\n * `deploymentFrequency` a pipeline-throughput signal and `changeFailureRate` a\n * pipeline-failure rate (build/test failures caught in CI count too), and MTTR\n * a pipeline-recovery time. Only `leadTime` carries an explicit `approx` flag\n * (it is additionally a run-time proxy), but ALL four share the run≠deploy\n * caveat until deploy/commit metadata is captured. See docs/dora-metrics.md.\n */\nexport interface DoraMetrics {\n  /** The [from,to] window echoed back (started_at range). */\n  window: { from: string; to: string };\n  /**\n   * Whether the numbers count real deployments or pipeline runs:\n   * - `'deploy'` — scoped to executions tagged with a deploy `environment`\n   *   (via `environment`/`deploysOnly`); a genuine deployment signal.\n   * - `'run'` — default: every successful PIPELINE run counts (no deploy\n   *   marker applied). DF/CFR/MTTR then reflect pipeline activity, not deploys.\n   */\n  basis: 'deploy' | 'run';\n  /** The scoping applied (echoed for the UI); `null` when unscoped. */\n  filters: { pipelineId: string | null; environment: string | null };\n  /** Deployment Frequency — SUCCEEDED terminal deployments in the window. */\n  deploymentFrequency: {\n    /** Count of successful deployments. */\n    deployments: number;\n    /** Successful deployments per day over the window. */\n    perDay: number;\n    /** Performance band, or null when there were no deployments. */\n    level: DoraLevel;\n  };\n  /** Change Failure Rate — failed / (succeeded + failed); CANCELED excluded. */\n  changeFailureRate: {\n    failed: number;\n    /** succeeded + failed (the CFR denominator). */\n    total: number;\n    /** failed/total as a percentage, 0–100, 1 decimal. */\n    pct: number;\n    /** Performance band, or null when there were no deployments to judge. */\n    level: DoraLevel;\n  };\n  /** Mean Time To Restore — avg gap from a failure INCIDENT to its recovery.\n   *  Consecutive failed runs of a pipeline (with no green run between) collapse\n   *  into one incident; the gap is measured from the first failure's END to the\n   *  recovering run's END. The recovery is visible up to a look-ahead past `to`\n   *  so a failure near the window edge isn't spuriously counted unrestored. */\n  meanTimeToRestore: {\n    /** Failure incidents in the window (maximal runs of consecutive failures). */\n    failures: number;\n    /** Incidents that were followed by a succeeded run (recovered). */\n    restored: number;\n    /** Average restore gap in seconds; null when there were no incidents. */\n    avgSeconds: number | null;\n    /** Performance band, or null when there were no incidents. */\n    level: DoraLevel;\n  };\n  /** Lead Time — PROXY: median pipeline RUN TIME of succeeded deployments.\n   *  NOT true commit→prod lead time (executions don't capture commit time),\n   *  hence `approx: true` so the UI/docs can label it. */\n  leadTime: {\n    /** Succeeded deployments with a duration (the median sample). */\n    deployments: number;\n    /** Median run time in seconds; null when no successful deployments. */\n    medianSeconds: number | null;\n    approx: true;\n    /** Performance band, or null when there were no successful deployments. */\n    level: DoraLevel;\n  };\n}\n\n/** One interval bucket of the DORA trend (deployment frequency + change failure). */\nexport interface DoraTrendPoint {\n  /** Bucket start (DATE_TRUNC of started_at), ISO text. */\n  period: string;\n  /** Successful deployments in the bucket. */\n  deployments: number;\n  /** Failed deployments in the bucket. */\n  failed: number;\n  /** succeeded + failed in the bucket. */\n  total: number;\n  /** failed/total as a percent (0 when total is 0). */\n  changeFailurePct: number;\n}\n\n/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */\nexport interface IngestEvent {\n  /** Stable pipeline id the events Lambda read from the `PIPELINE_EVENT_ID`\n   *  tag (= the platform pipelineId). The registry join key. */\n  pipelineId: string;\n  eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';\n  eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason (Action events). */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id of the change being shipped (DORA deploy attribution). */\n  commitSha?: string;\n  /** Source ref/branch (DORA deploy attribution). */\n  commitRef?: string;\n  /** Deploy target (e.g. \"production\"). Its presence marks a real deployment. */\n  environment?: string;\n  detail?: Record<string, unknown>;\n}\n\n/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */\nexport interface IngestResult {\n  inserted: number;\n  skipped: number;\n  unregisteredPipelineIds: string[];\n}\n\n// ─── Service ────────────────────────────────────────────\n\n/**\n * Read-only reporting service for pipeline execution and plugin inventory aggregations.\n * Does not extend CrudService — reports are aggregate queries, not entity CRUD.\n *\n * All queries are cached in-memory to avoid repeated expensive SQL aggregations:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL\n * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL\n */\nexport class ReportingService {\n\n  /** Invalidate all cached reports for an org (call after event ingest). */\n  async invalidateOrg(orgId: string): Promise<void> {\n    await Promise.all([\n      inventoryCache.invalidatePattern(`${orgId}:*`),\n      timeseriesCache.invalidatePattern(`${orgId}:*`),\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   */\n  async ingestEvents(events: IngestEvent[]): 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 method. 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    // Run insert inside the tx, but COLLECT affected orgs and invalidate\n    // caches AFTER the tx resolves. Keeping invalidation inside the tx held\n    // the pg locks open for the duration of the cache round-trips (Redis or\n    // in-memory invalidations are unrelated to the tx but still serialized\n    // its commit). Cache TTL is 2-5 min so fire-and-forget post-commit is\n    // an acceptable trade for tighter lock windows.\n    const { inserted, skipped, unregisteredPipelineIds, affectedOrgs } = 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\n      // Build insert batch (skip events whose pipeline isn't registered)\n      const rows: Array<typeof schema.pipelineEvent.$inferInsert> = [];\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\n        rows.push({\n          // registry.pipelineId === event.pipelineId; use the registry's so the\n          // FK is always a row that exists, and pull orgId from the registry for\n          // tenancy (never trust the caller's claimed org).\n          pipelineId: registry.pipelineId,\n          orgId: registry.orgId,\n          eventSource: event.eventSource,\n          eventType: event.eventType,\n          status: event.status,\n          executionId: event.executionId,\n          stageName: event.stageName,\n          actionName: event.actionName,\n          // HARD CONSTRAINT: an AWS account id must NEVER be persisted. This is\n          // the DURABLE persistence boundary and must not trust upstream:\n          // CodePipeline/CodeBuild failure detail & messages routinely carry\n          // ARNs (arn:aws:…:<account-id>:…) and bare 12-digit account ids. Scrub\n          // both free-form fields here before insert (per-event, non-mutating).\n          errorMessage: event.errorMessage !== undefined\n            ? scrubAwsIdentifiersFromString(event.errorMessage)\n            : undefined,\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 fields — scrubbed like the other free-form strings\n          // so an ARN/account id can never enter via a ref or environment name.\n          commitSha: event.commitSha !== undefined\n            ? scrubAwsIdentifiersFromString(event.commitSha)\n            : undefined,\n          commitRef: event.commitRef !== undefined\n            ? scrubAwsIdentifiersFromString(event.commitRef)\n            : undefined,\n          environment: event.environment !== undefined\n            ? scrubAwsIdentifiersFromString(event.environment)\n            : undefined,\n          detail: event.detail !== undefined\n            ? scrubAwsIdentifiers(event.detail)\n            : undefined,\n        });\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 + cache invalidation ignore duplicates.\n      const insertedRows = rows.length > 0\n        ? await tx.insert(schema.pipelineEvent).values(rows)\n          .onConflictDoNothing()\n          .returning({ orgId: schema.pipelineEvent.orgId })\n        : [];\n\n      return {\n        inserted: insertedRows.length,\n        skipped: skippedLocal,\n        unregisteredPipelineIds: unregisteredLocal,\n        affectedOrgs: [...new Set(insertedRows.map(r => r.orgId))],\n      };\n    });\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    // PIPELINE_EVENT_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        this.invalidateOrg(org).catch((err) => {\n          logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });\n        }),\n      ));\n    }\n\n    return { inserted, skipped, unregisteredPipelineIds };\n  }\n\n  // ── Category 1: Pipeline Execution & Performance ──\n\n  /**\n   * Build the org-scope predicate for a report query. With `orgIds` (the\n   * org → team rollup — a parent's `[self, ...descendants]`) it becomes an\n   * `IN (...)` over the subtree; otherwise the single-org `= $org`. Returns a\n   * `multi` flag so callers can run multi-org reads under sysadmin context\n   * (the subtree spans orgs outside the request's RLS scope) and salt the\n   * cache key.\n   */\n  private orgScope(orgId: string, orgIds?: string[]) {\n    const ids = orgIds && orgIds.length > 0 ? orgIds : [orgId];\n    const multi = ids.length > 1;\n    const pred = multi\n      ? sql`IN (${sql.join(ids.map((id) => sql`${id}`), sql`, `)})`\n      : sql`= ${ids[0]}`;\n    return { pred, multi };\n  }\n\n  /**\n   * Run a report read. Single-org reads use the per-org cache (invalidated on\n   * that org's event ingest). Rollup (multi-org) reads **bypass the cache** and\n   * run under sysadmin context: they're admin-only and lower-frequency, and a\n   * child org's event ingest can't invalidate a parent's rollup entry (reporting\n   * has no org tree), so caching them would serve stale aggregates. Always fresh.\n   */\n  private runReport<T>(cacheKey: string, multi: boolean, exec: () => Promise<T>): Promise<T> {\n    return multi\n      ? runWithTenantContext({ isSuperAdmin: true }, exec)\n      : timeseriesCache.getOrSet(cacheKey, exec);\n  }\n\n  /** 1.1 Execution count per pipeline with status breakdown. */\n  async getExecutionCount(orgId: string, orgIds?: string[], range?: { from?: string; to?: string }): Promise<ExecutionCount[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    // Optional [from,to] window on the execution's started_at, mirroring the\n    // sibling timeseries reports so the dashboard date-range picker narrows the\n    // count too (an empty range = all-time, preserving the prior behavior). The\n    // range rides the JOIN so pipelines with no in-window events still list\n    // (LEFT semantics preserved via the inner-join filter — a pipeline with zero\n    // matching events drops from the count, same as before for its window).\n    const rangeClause = range?.from && range?.to\n      ? sql`AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`\n      : sql``;\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.project, p.organization, p.pipeline_name,\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          MIN(e.started_at)::text AS first_execution,\n          MAX(e.started_at)::text AS last_execution\n        FROM ${schema.pipeline} p\n        JOIN ${schema.pipelineEvent} e ON e.pipeline_id = p.id\n          AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'\n          ${rangeClause}\n        WHERE p.org_id ${pred} AND p.is_active = true\n        GROUP BY p.id\n        ORDER BY total DESC\n      `).then(r => drizzleRows<ExecutionCount>(r.rows)));\n    return this.runReport(`${orgId}:exec-count:${range?.from ?? ''}:${range?.to ?? ''}`, multi, exec);\n  }\n\n  /**\n   * 1.1b Per-pipeline execution history — DISTINCT executions for one pipeline,\n   * newest first. Groups all events by `execution_id` in a single scan and\n   * rolls each execution up to one row:\n   *   - status: derived from the PIPELINE-type events. FAILED wins, then\n   *     SUCCEEDED, then CANCELED; an execution with no terminal PIPELINE event\n   *     is still `in-progress`.\n   *   - startedAt/endedAt/durationMs: from the PIPELINE lifecycle events.\n   *   - failingStage/failingAction: the first FAILED STAGE/ACTION event (cheap —\n   *     same scan, no extra query).\n   *\n   * ORG-SCOPING: identical to the sibling execution reports — joins the pipeline\n   * registry table (`pipeline`) and gates on `p.org_id ${pred}`, where `pred` is\n   * the single-org `= $org` or (with a rollup) an `IN (...)` over the org→team\n   * subtree. A pipelineId belonging to another org yields zero rows.\n   */\n  async listPipelineExecutions(\n    orgId: string,\n    pipelineId: string,\n    orgIds?: string[],\n    range?: { from?: string; to?: string },\n    limit: number = 50,\n  ): Promise<PipelineExecution[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const rangeClause = range?.from && range?.to\n      ? sql`AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`\n      : sql``;\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.execution_id,\n          CASE\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'FAILED') THEN 'failed'\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'SUCCEEDED') THEN 'succeeded'\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'CANCELED') THEN 'canceled'\n            ELSE 'in-progress'\n          END AS status,\n          MIN(e.started_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS started_at,\n          MAX(e.completed_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS ended_at,\n          MAX(e.duration_ms) FILTER (WHERE e.event_type = 'PIPELINE')::int AS duration_ms,\n          (ARRAY_AGG(e.stage_name) FILTER (WHERE e.event_type = 'STAGE' AND e.status = 'FAILED'))[1] AS failing_stage,\n          (ARRAY_AGG(e.action_name) FILTER (WHERE e.event_type = 'ACTION' AND e.status = 'FAILED'))[1] AS failing_action\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.pipeline_id = ${pipelineId} AND e.execution_id IS NOT NULL\n          ${rangeClause}\n        GROUP BY e.execution_id\n        ORDER BY MAX(e.created_at) DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<PipelineExecution>(r.rows)));\n    return this.runReport(`${orgId}:pipeline-executions:${pipelineId}:${range?.from ?? ''}:${range?.to ?? ''}:${limit}`, multi, exec);\n  }\n\n  /** 1.2 Success rate over time for an org. */\n  async getSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[]): Promise<TimeSeriesEntry[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE'\n          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<TimeSeriesEntry>(r.rows)));\n    return this.runReport(`${orgId}:success-rate:${interval}:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.3 Average duration per pipeline. */\n  async getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<DurationStats[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.project, p.pipeline_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MIN(e.duration_ms)::int AS min_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS p95_ms,\n          COUNT(*)::int AS executions\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<DurationStats>(r.rows)));\n    return this.runReport(`${orgId}:avg-duration:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.5 Stage failure heatmap — which stages fail most. */\n  async getStageFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.stage_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.stage_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.stage_name ORDER BY failures DESC\n      `).then(r => drizzleRows<StageFailure>(r.rows)));\n    return this.runReport(`${orgId}:stage-failures:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.6 Stage bottlenecks — slowest stages per pipeline. */\n  async getStageBottlenecks(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageBottleneck[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.pipeline_name, e.stage_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<StageBottleneck>(r.rows)));\n    return this.runReport(`${orgId}:stage-bottlenecks:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.7 Action failure rate — which plugin steps fail most. */\n  async getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<ActionFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.action_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'ACTION' AND e.action_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.action_name ORDER BY failures DESC\n      `).then(r => drizzleRows<ActionFailure>(r.rows)));\n    return this.runReport(`${orgId}:action-failures:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.8 Error categorization — group failure messages. */\n  async getErrors(orgId: string, from: string, to: string, limit: number = 20): Promise<ErrorEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:errors:${from}:${to}:${limit}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          SUBSTRING(e.error_message FROM 1 FOR 200) AS error_pattern,\n          COUNT(*)::int AS occurrences,\n          COUNT(DISTINCT e.pipeline_id)::int AS affected_pipelines,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.status = 'FAILED' AND e.error_message IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY error_pattern ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<ErrorEntry>(r.rows))),\n    );\n  }\n\n  /**\n   * 1.9 DORA metrics over [from,to] (started_at range), org-scoped + rollup-aware.\n   *\n   * All four metrics derive from a per-execution roll-up of TERMINAL PIPELINE\n   * events (one row per execution_id+pipeline_id; FAILED wins, then SUCCEEDED,\n   * then CANCELED/STOPPED — mirroring `listPipelineExecutions`). The scan is\n   * gated by the `p.org_id ${pred}` join exactly like the sibling reports, so a\n   * rollup passes the org→team subtree and a foreign org's executions never\n   * enter the aggregate.\n   *\n   * DF/CFR/lead-time count only CORE-window executions ([from,to]). MTTR is\n   * per-INCIDENT: consecutive failures collapse into one incident and the\n   * recovery lookup may see the next success up to MTTR_RESTORE_LOOKAHEAD past\n   * `to`, so a failure near the edge isn't right-censored into \"never restored\".\n   * The scan bound is therefore `[from, to + look-ahead]`; the started_at range\n   * still rides the same index as the sibling reports.\n   *\n   * DISCLOSURE: by default DF/CFR/MTTR are RUN-based (any successful PIPELINE\n   * run = a \"deployment\"), and Lead Time is additionally a run-time PROXY\n   * flagged `approx: true`. Pass `environment` or `deploysOnly` to scope to\n   * executions tagged with a real deploy target — the response `basis` reports\n   * which was used. See the DoraMetrics doc + docs/dora-metrics.md.\n   *\n   * @param opts.pipelineId    restrict to one pipeline (per-pipeline DORA)\n   * @param opts.environment   count only executions deployed to this target\n   * @param opts.deploysOnly   count only executions tagged with ANY environment\n   */\n  async getDoraMetrics(\n    orgId: string,\n    from: string,\n    to: string,\n    orgIds?: string[],\n    opts: DoraOptions = {},\n  ): Promise<DoraMetrics> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const { pipelineId, environment, deploysOnly } = opts;\n    // Optional deploy-scoping / per-pipeline predicates, folded into the execs\n    // scan so failures AND their recovery successes are filtered consistently.\n    const { pipelineClause, deployClause, basis } = doraScopeClauses(opts);\n    // Scan the CORE window plus a look-ahead tail: the extra tail exists only\n    // so a late failure can still find its recovery (see the restore CTE).\n    const execs = execsCte({\n      pred,\n      pipelineClause,\n      deployClause,\n      from,\n      columns: sql`\n            e.pipeline_id,\n            ${DORA_TERMINAL_STATUS_CASE} AS status,\n            MIN(e.started_at) AS started_at,\n            MAX(e.completed_at) AS ended_at,\n            MAX(e.duration_ms) AS duration_ms`,\n      toBound: sql`${to}::timestamptz + ${MTTR_RESTORE_LOOKAHEAD}::interval`,\n    });\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        WITH execs AS (${execs}\n        ),\n        -- Core-window executions ([from,to]); DF/CFR/lead-time count only these.\n        -- The look-ahead rows above are used ONLY as MTTR recovery candidates.\n        core AS (\n          SELECT * FROM execs WHERE started_at <= ${to}::timestamptz\n        ),\n        df AS (\n          SELECT COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS deployments\n          FROM core\n        ),\n        cfr AS (\n          SELECT\n            COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failed,\n            COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED'))::int AS total\n          FROM core\n        ),\n        lt AS (\n          SELECT\n            COUNT(*)::int AS deployments,\n            PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY duration_ms)::float AS median_ms\n          FROM core\n          WHERE status = 'SUCCEEDED' AND duration_ms IS NOT NULL\n        ),\n        -- For each core-window failure, find the END of its recovering run: the\n        -- next SUCCEEDED run of the same pipeline that ENDED after this failure\n        -- ended (visible into the look-ahead tail). SELECT and MEASURE both key\n        -- off ended_at so they stay consistent -- the incident gap is\n        -- restored_at (success end) minus incident_started (first failure end),\n        -- so picking the recovery by ended_at (not started_at) rules out the\n        -- negative gap that a concurrent success which STARTED after the failure\n        -- but ENDED before it would otherwise fold into AVG. Measuring from the\n        -- failure's END (not start) also keeps the failed run's own duration out\n        -- of restore time. Ordering by ended_at makes the incident collapse fall\n        -- out naturally: a green run ending between two failures splits them.\n        restore AS (\n          SELECT\n            f.pipeline_id,\n            f.ended_at AS fail_ended,\n            (SELECT s.ended_at FROM execs s\n              WHERE s.pipeline_id = f.pipeline_id AND s.status = 'SUCCEEDED'\n                AND s.ended_at > f.ended_at\n              ORDER BY s.ended_at ASC LIMIT 1) AS restored_at\n          FROM core f\n          WHERE f.status = 'FAILED'\n        ),\n        -- Collapse to INCIDENTS: failures sharing the same recovery (i.e. with\n        -- no green run between them) are one incident, starting at the first\n        -- failure's end. Unrecovered failures share restored_at = NULL and form\n        -- the single trailing open incident per pipeline.\n        incidents AS (\n          SELECT pipeline_id, restored_at, MIN(fail_ended) AS incident_started\n          FROM restore\n          GROUP BY pipeline_id, restored_at\n        ),\n        mttr AS (\n          SELECT\n            COUNT(*)::int AS failures,\n            -- restored must equal the count of incidents that actually\n            -- contribute to avg_seconds. Guard on incident_started too: a\n            -- failure with a NULL completed_at yields a NULL incident_started\n            -- that contributes NULL (not a real gap) to AVG, so it must not be\n            -- counted as restored either -- otherwise restored could exceed\n            -- the number of measured incidents.\n            COUNT(*) FILTER (\n              WHERE restored_at IS NOT NULL AND incident_started IS NOT NULL\n            )::int AS restored,\n            AVG(EXTRACT(EPOCH FROM (restored_at - incident_started)))\n              FILTER (WHERE restored_at IS NOT NULL AND incident_started IS NOT NULL)::float AS avg_seconds\n          FROM incidents\n        )\n        SELECT\n          df.deployments AS df_deployments,\n          cfr.failed AS cfr_failed,\n          cfr.total AS cfr_total,\n          lt.deployments AS lt_deployments,\n          lt.median_ms AS lt_median_ms,\n          mttr.failures AS mttr_failures,\n          mttr.restored AS mttr_restored,\n          mttr.avg_seconds AS mttr_avg_seconds\n        FROM df, cfr, lt, mttr\n      `).then(r => this.shapeDora(drizzleRows<DoraRow>(r.rows)[0], from, to, basis, { pipelineId, environment })));\n    // `environment` WINS over `deploysOnly` in doraScopeClauses, so with an\n    // environment set the deploysOnly flag never affects the SQL — append the\n    // 'd' marker only when it genuinely changes the query (environment absent),\n    // otherwise `{environment:'prod', deploysOnly:true}` would mint a redundant\n    // cache entry identical to `{environment:'prod'}`.\n    const deployMarker = !environment && deploysOnly ? 'd' : '';\n    const key = `${orgId}:dora:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}:${deployMarker}`;\n    return this.runReport(key, multi, exec);\n  }\n\n  /** Shape a single DORA aggregate row into the public {@link DoraMetrics}. */\n  private shapeDora(\n    row: DoraRow | undefined,\n    from: string,\n    to: string,\n    basis: DoraMetrics['basis'],\n    filters: { pipelineId?: string; environment?: string },\n  ): DoraMetrics {\n    // `FROM df, cfr, lt, mttr` always yields exactly one row (each CTE is a\n    // single-row aggregate), but guard against an empty result defensively.\n    const r: DoraRow = row ?? {};\n\n    const deployments = Number(r.df_deployments) || 0;\n    // Floor the divisor at one day: a window shorter than a day (incl. the\n    // degenerate from==to) has no meaningful sub-day rate, so it's treated as a\n    // single day rather than extrapolated or mislabeled as a raw count.\n    // Floor at one day and guard against unparseable dates (Date.parse → NaN,\n    // which would otherwise propagate through perDay). Falls back to a 1-day\n    // window so a bad range yields the raw count as the rate, never NaN.\n    const spanDays = (Date.parse(to) - Date.parse(from)) / 86400000;\n    const days = Number.isFinite(spanDays) ? Math.max(spanDays, 1) : 1;\n    // Band on the UNROUNDED rate; round only for display. Rounding first would\n    // mislabel exact weekly/monthly boundaries (e.g. 1 deploy / 30 days →\n    // 0.0333 rounds to 0.03 < 1/30 → wrongly \"low\" instead of \"medium\").\n    const rawPerDay = deployments / days;\n    const perDay = round(rawPerDay, 2);\n\n    const failed = Number(r.cfr_failed) || 0;\n    const total = Number(r.cfr_total) || 0;\n    const rawPct = total > 0 ? (failed / total) * 100 : 0;\n    const pct = round(rawPct, 1);\n\n    // Band restore/lead-time on the RAW (pre-round) seconds, the same \"band on\n    // the unrounded value\" principle used for perDay/pct above; keep the rounded\n    // values for the response fields. Immaterial at the hour/day thresholds, but\n    // it makes the principle uniform across all four metrics.\n    const failures = Number(r.mttr_failures) || 0;\n    const restored = Number(r.mttr_restored) || 0;\n    const rawAvgSeconds = failures > 0 && r.mttr_avg_seconds != null\n      ? Number(r.mttr_avg_seconds)\n      : null;\n    const avgSeconds = rawAvgSeconds != null ? round(rawAvgSeconds, 1) : null;\n\n    const ltDeployments = Number(r.lt_deployments) || 0;\n    const rawMedianSeconds = r.lt_median_ms != null\n      ? Number(r.lt_median_ms) / 1000\n      : null;\n    const medianSeconds = rawMedianSeconds != null ? round(rawMedianSeconds, 1) : null;\n\n    return {\n      window: { from, to },\n      basis,\n      filters: { pipelineId: filters.pipelineId ?? null, environment: filters.environment ?? null },\n      deploymentFrequency: { deployments, perDay, level: doraLevelForFrequency(rawPerDay, deployments) },\n      changeFailureRate: { failed, total, pct, level: doraLevelForChangeFailure(rawPct, total) },\n      meanTimeToRestore: { failures, restored, avgSeconds, level: doraLevelForRestore(rawAvgSeconds) },\n      leadTime: { deployments: ltDeployments, medianSeconds, approx: true, level: doraLevelForLeadTime(rawMedianSeconds) },\n    };\n  }\n\n  /**\n   * 1.9b DORA trend — deployment frequency + change-failure rate bucketed by\n   * `interval` (day/week/month) for a sparkline. Per-execution rollup (one row\n   * per execution, FAILED wins) bucketed on the execution's started_at. Shares\n   * the `getDoraMetrics` scoping (org/rollup, pipelineId, deploy-scoping); MTTR\n   * and lead time are intentionally omitted (too heavy to bucket meaningfully).\n   */\n  async getDoraTrend(\n    orgId: string,\n    interval: string,\n    from: string,\n    to: string,\n    orgIds?: string[],\n    opts: DoraOptions = {},\n  ): Promise<DoraTrendPoint[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const { pipelineId, environment, deploysOnly } = opts;\n    const { pipelineClause, deployClause } = doraScopeClauses(opts);\n    // Same execs roll-up as getDoraMetrics (shared builder — status set +\n    // predicate can't drift); the trend needs only started_at over the core\n    // window (no MTTR look-ahead, no ended_at/duration columns).\n    const execs = execsCte({\n      pred,\n      pipelineClause,\n      deployClause,\n      from,\n      columns: sql`\n            ${DORA_TERMINAL_STATUS_CASE} AS status,\n            MIN(e.started_at) AS started_at`,\n      toBound: sql`${to}::timestamptz`,\n    });\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        WITH execs AS (${execs}\n        )\n        SELECT\n          DATE_TRUNC(${interval}, started_at)::text AS period,\n          COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS deployments,\n          COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED'))::int AS total,\n          -- quoted alias so the raw row key is exactly the DoraTrendPoint field\n          COALESCE(ROUND(COUNT(*) FILTER (WHERE status = 'FAILED')::numeric\n            / NULLIF(COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED')), 0) * 100, 1), 0)::float AS \"changeFailurePct\"\n        FROM execs\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<DoraTrendPoint>(r.rows)));\n    // Omit the deploysOnly marker when environment is set: it wins in\n    // doraScopeClauses, so the SQL (and thus the correct cache key) is identical\n    // to the environment-only case. Only append 'd' when it changes the query.\n    const deployMarker = !environment && deploysOnly ? 'd' : '';\n    const key = `${orgId}:dora-trend:${interval}:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}:${deployMarker}`;\n    return this.runReport(key, multi, exec);\n  }\n\n  // ── Category 2: Plugin Inventory & Builds ──\n\n  /** 2.1 Plugin summary — counts and breakdowns. */\n  async getPluginSummary(orgId: string): Promise<PluginSummary> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-summary`, async () => {\n      const rows = await withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE ${schema.plugin.isActive})::int AS active,\n          COUNT(*) FILTER (WHERE NOT ${schema.plugin.isActive})::int AS inactive,\n          COUNT(*) FILTER (WHERE ${schema.plugin.accessModifier} = 'public')::int AS public,\n          COUNT(*) FILTER (WHERE ${schema.plugin.accessModifier} = 'private')::int AS private,\n          COUNT(DISTINCT ${schema.plugin.name})::int AS unique_names\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId}\n      `));\n      return (drizzleRows<PluginSummary>(rows.rows)[0] || { total: 0, active: 0, inactive: 0, public: 0, private: 0, uniqueNames: 0 });\n    });\n  }\n\n  /** 2.2 Type & compute distribution. */\n  async getPluginDistribution(orgId: string): Promise<TypeComputeDistribution[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-distribution`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          ${schema.plugin.pluginType} AS plugin_type,\n          ${schema.plugin.computeType} AS compute_type,\n          COUNT(*)::int AS count\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.pluginType}, ${schema.plugin.computeType}\n        ORDER BY count DESC\n      `).then(r => drizzleRows<TypeComputeDistribution>(r.rows))),\n    );\n  }\n\n  /** 2.3 Version counts per plugin name. */\n  async getPluginVersions(orgId: string): Promise<VersionCount[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-versions`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          ${schema.plugin.name},\n          COUNT(*)::int AS version_count,\n          MAX(${schema.plugin.version}) AS latest_version,\n          bool_or(${schema.plugin.isDefault}) AS has_default\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.name}\n        ORDER BY version_count DESC\n      `).then(r => drizzleRows<VersionCount>(r.rows))),\n    );\n  }\n\n  /**\n   * 2.4 Build success rate over time.\n   *\n   * STATUS CASING NOTE: This query filters by `event_source = 'plugin-build'`\n   * and uses lowercase status values (`'completed'`, `'failed'`), while\n   * `getSuccessRate` (1.2) filters by `event_type = 'PIPELINE'` with\n   * uppercase AWS-style statuses (`'SUCCEEDED'`, `'FAILED'`, `'CANCELED'`).\n   * The casing drift is intentional and tracks the producer:\n   *   - `plugin-build` events come from our own build pipeline (lowercase)\n   *   - `PIPELINE` events come from AWS CodePipeline (uppercase)\n   * The ingest Zod schema at api/reporting/src/routes/event-ingest.ts\n   * SHOULD enum these per-eventSource so we catch drift at ingest rather\n   * than silently producing zero rows here. See findings N71.\n   */\n  async getBuildSuccessRate(orgId: string, interval: string, from: string, to: string): Promise<BuildTimeSeriesEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-success:${interval}:${from}:${to}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'completed')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'failed')::int AS failed,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'completed')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build'\n          AND e.status IN ('completed', 'failed')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<BuildTimeSeriesEntry>(r.rows))),\n    );\n  }\n\n  /** 2.5 Build duration per plugin. */\n  async getBuildDuration(orgId: string, from: string, to: string): Promise<BuildDuration[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-duration:${from}:${to}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          COUNT(*)::int AS builds\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<BuildDuration>(r.rows))),\n    );\n  }\n\n  /** 2.6 Build failures — top error messages. */\n  async getBuildFailures(orgId: string, from: string, to: string, limit: number = 20): Promise<BuildFailure[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-failures:${from}:${to}:${limit}`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          e.error_message,\n          COUNT(*)::int AS occurrences,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.status = 'failed'\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name, e.error_message\n        ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<BuildFailure>(r.rows))),\n    );\n  }\n}\n\nexport const reportingService = new ReportingService();\n"]}

package/lib/database/drizzle-schema.d.ts

@@ -1701,6 +1701,63 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            commitSha: import("drizzle-orm/pg-core").PgColumn<{
+                name: "commit_sha";
+                tableName: "pipeline_events";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 255;
+            }>;
+            commitRef: import("drizzle-orm/pg-core").PgColumn<{
+                name: "commit_ref";
+                tableName: "pipeline_events";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 255;
+            }>;
+            environment: import("drizzle-orm/pg-core").PgColumn<{
+                name: "environment";
+                tableName: "pipeline_events";
+                dataType: "string";
+                columnType: "PgVarchar";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: 255;
+            }>;
             detail: import("drizzle-orm/pg-core").PgColumn<{
                 name: "detail";
                 tableName: "pipeline_events";

package/lib/database/schema/pipeline.d.ts

@@ -814,6 +814,63 @@ export declare const pipelineEvent: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        commitSha: import("drizzle-orm/pg-core").PgColumn<{
+            name: "commit_sha";
+            tableName: "pipeline_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        commitRef: import("drizzle-orm/pg-core").PgColumn<{
+            name: "commit_ref";
+            tableName: "pipeline_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        environment: import("drizzle-orm/pg-core").PgColumn<{
+            name: "environment";
+            tableName: "pipeline_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
         detail: import("drizzle-orm/pg-core").PgColumn<{
             name: "detail";
             tableName: "pipeline_events";

package/lib/database/schema/pipeline.js

@@ -133,6 +133,14 @@ export const pipelineEvent = pgTable('pipeline_events', {
     startedAt: timestamp('started_at', { withTimezone: true }),
     completedAt: timestamp('completed_at', { withTimezone: true }),
     durationMs: integer('duration_ms'),
+    // DORA deploy-attribution (all nullable; populated at ingest when the source
+    // event carries them — legacy/CI-only events leave them NULL). `environment`
+    // is the deploy target (e.g. "production"); its presence marks an execution
+    // as a real deployment, letting DORA scope past generic pipeline runs.
+    // `commitSha`/`commitRef` capture the source revision for lead-time work.
+    commitSha: varchar('commit_sha', { length: 255 }),
+    commitRef: varchar('commit_ref', { length: 255 }),
+    environment: varchar('environment', { length: 255 }),
     detail: jsonb('detail').$type(),
     createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
 }, (table) => ({
@@ -162,5 +170,23 @@ export const pipelineEvent = pgTable('pipeline_events', {
     dedupIdx: uniqueIndex('event_dedup_idx')
         .on(sql `coalesce(${table.pipelineId}::text, '')`, table.executionId, table.eventType, table.status, sql `coalesce(${table.stageName}, '')`, sql `coalesce(${table.actionName}, '')`)
         .where(sql `execution_id IS NOT NULL`),
+    // DORA deploy-scoped reads: only PIPELINE-level executions tagged with a
+    // deploy environment. `event_type` is in the index because the events Lambda
+    // tags EVERY event of a deployed pipeline (STAGE/ACTION too), while the DORA
+    // scan wants only `event_type='PIPELINE'` — including it restores selectivity.
+    // Partial (environment IS NOT NULL) keeps it small — legacy/CI-only events
+    // aren't indexed. The default run-based DORA path (no environment) can't use
+    // this partial index; it relies on event_pipeline_type_started_idx below.
+    // MIGRATION REQUIRED: drizzle-kit generate.
+    envTypeStartedIdx: index('event_env_type_started_idx')
+        .on(table.environment, table.eventType, table.startedAt)
+        .where(sql `environment IS NOT NULL`),
+    // started_at range scans: every Category-1 report and the default run-based
+    // DORA path filters `event_type='PIPELINE' AND started_at BETWEEN …` joined on
+    // pipeline_id, but the other event composite index is on created_at, not
+    // started_at — so the range scan had no ideal index. This composite serves the
+    // join-driven scan by pipeline_id. MIGRATION REQUIRED: drizzle-kit generate.
+    pipelineTypeStartedIdx: index('event_pipeline_type_started_idx')
+        .on(table.pipelineId, table.eventType, table.startedAt),
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../../src/database/schema/pipeline.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccessModifier, SYSTEM_ORG_ID, type MetaDataType } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { boolean, integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex } from 'drizzle-orm/pg-core';\n\n/**\n * Pipeline builder configuration properties stored in database.\n * Mirrors the canonical BuilderProps from pipeline-core (JSON-serializable form).\n */\nexport interface PipelineBuilderConfig {\n  readonly project: string;\n  readonly organization: string;\n  readonly pipelineName?: string;\n  readonly global?: MetaDataType;\n  readonly synth: Record<string, unknown>;\n  readonly defaults?: Record<string, unknown>;\n  readonly role?: Record<string, unknown>;\n  readonly stages?: PipelineStageConfig[];\n}\n\n/**\n * Stage configuration stored in database (JSON-serializable).\n */\nexport interface PipelineStageConfig {\n  readonly stageName: string;\n  readonly alias?: string;\n  readonly steps: Record<string, unknown>[];\n}\n\n/**\n * Table for storing pipeline instances and their full configuration.\n *\n * Features * - Full BuilderProps serialization for reconstruction\n * - Organization-level isolation\n * - Pipeline status tracking\n * - Execution history tracking\n * - Flexible tagging system\n *\n * @table pipelines\n */\nexport const pipeline = pgTable('pipelines', {\n  // Primary key\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Organization and access control\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n\n  // Audit fields\n  createdBy: text('created_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n  updatedBy: text('updated_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n\n  // Core pipeline information\n  project: varchar('project', { length: 255 })\n    .notNull(),\n  organization: varchar('organization', { length: 255 })\n    .notNull(),\n  pipelineName: varchar('pipeline_name', { length: 255 }),\n  description: text('description'),\n  keywords: jsonb('keywords')\n    .$type<string[]>()\n    .default([])\n    .notNull(),\n\n  // Pipeline configuration\n  props: jsonb('props')\n    .$type<PipelineBuilderConfig>()\n    .notNull(),\n\n  // Access and visibility\n  accessModifier: varchar('access_modifier', { length: 10 })\n    .$type<AccessModifier>()\n    .default('private' as AccessModifier)\n    .notNull(),\n  isDefault: boolean('is_default')\n    .default(false)\n    .notNull(),\n  isActive: boolean('is_active')\n    .default(true)\n    .notNull(),\n\n  // Deletion tracking (soft delete)\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n}, (table) => ({\n  // Indexes for common queries\n  projectIdx: index('pipeline_project_idx').on(table.project),\n  organizationIdx: index('pipeline_organization_idx').on(table.organization),\n  orgIdIdx: index('pipeline_org_id_idx').on(table.orgId),\n  activeIdx: index('pipeline_active_idx').on(table.isActive),\n  createdAtIdx: index('pipeline_created_at_idx').on(table.createdAt),\n  updatedAtIdx: index('pipeline_updated_at_idx').on(table.updatedAt),\n\n  // Composite index for common access pattern (orgId + isActive)\n  orgActiveIdx: index('pipeline_org_active_idx').on(table.orgId, table.isActive),\n\n  // Composite index for filtered queries (orgId + accessModifier + isActive)\n  orgAccessActiveIdx: index('pipeline_org_access_active_idx').on(table.orgId, table.accessModifier, table.isActive),\n\n  // Partial index for active-only queries (smaller, faster than full index)\n  activeOnlyOrgIdx: index('pipeline_active_only_org_idx').on(table.orgId, table.createdAt).where(sql`is_active = true`),\n\n  // Unique constraint on project + organization + orgId\n  projectOrgUnique: uniqueIndex('pipeline_project_org_unique')\n    .on(table.project, table.organization, table.orgId),\n}));\n\n/**\n * Pipeline deployment registry.\n * Maps deployed CodePipeline ARNs back to pipeline records and org IDs.\n * Populated by the deploy command after successful CDK deploy.\n * Used by the pipeline-events Lambda to resolve EventBridge events to org-scoped records.\n *\n * @table pipeline_registry\n */\nexport const pipelineRegistry = pgTable('pipeline_registry', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  // The platform's pipeline record id — a STABLE uuid created with the pipeline\n  // record, known at CDK synth, and applied to the live CodePipeline as the\n  // `PIPELINE_EVENT_ID` tag. The events Lambda reads that tag and reports\n  // against this id, so it IS the event join key (replacing the masked ARN —\n  // it carries no AWS account/region, so no masking is needed). Unique: one\n  // registry row per pipeline + the upsert key for (re)registration.\n  pipelineId: uuid('pipeline_id').notNull().unique(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  pipelineName: varchar('pipeline_name', { length: 255 }).notNull(),\n  region: varchar('region', { length: 30 }),\n  project: varchar('project', { length: 255 }),\n  organization: varchar('organization', { length: 255 }),\n  lastDeployed: timestamp('last_deployed', { withTimezone: true }),\n  stackName: varchar('stack_name', { length: 255 }),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  orgIdIdx: index('registry_org_id_idx').on(table.orgId),\n  orgRegionIdx: index('registry_org_region_idx').on(table.orgId, table.region),\n}));\n\n/**\n * Event source identifiers for pipeline_events.\n */\nexport type EventSource = 'codepipeline' | 'codebuild' | 'plugin-build';\n\n/**\n * Event type granularity levels for pipeline_events.\n */\nexport type EventType = 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n\n/**\n * Pipeline execution and build events.\n * Captures CodePipeline/CodeBuild state changes from EventBridge\n * and plugin Docker build outcomes from BullMQ.\n * All events are org-scoped for multi-tenant reporting.\n *\n * @table pipeline_events\n */\nexport const pipelineEvent = pgTable('pipeline_events', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  pipelineId: uuid('pipeline_id'),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  eventSource: varchar('event_source', { length: 50 }).$type<EventSource>().notNull(),\n  eventType: varchar('event_type', { length: 50 }).$type<EventType>().notNull(),\n  status: varchar('status', { length: 20 }).notNull(),\n  executionId: varchar('execution_id', { length: 255 }),\n  stageName: varchar('stage_name', { length: 255 }),\n  actionName: varchar('action_name', { length: 255 }),\n  errorMessage: text('error_message'),\n  startedAt: timestamp('started_at', { withTimezone: true }),\n  completedAt: timestamp('completed_at', { withTimezone: true }),\n  durationMs: integer('duration_ms'),\n  detail: jsonb('detail').$type<Record<string, unknown>>(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  pipelineIdIdx: index('event_pipeline_id_idx').on(table.pipelineId),\n  orgIdIdx: index('event_org_id_idx').on(table.orgId),\n  eventTypeIdx: index('event_type_idx').on(table.eventType),\n  statusIdx: index('event_status_idx').on(table.status),\n  executionIdIdx: index('event_execution_id_idx').on(table.executionId),\n  createdAtIdx: index('event_created_at_idx').on(table.createdAt),\n  orgTypeCreatedIdx: index('event_org_type_created_idx').on(table.orgId, table.eventType, table.createdAt),\n  orgSourceStatusIdx: index('event_org_source_status_idx').on(table.orgId, table.eventSource, table.status),\n  // Idempotency: EventBridge → SQS is at-least-once, so the same state-change\n  // can be delivered twice. This partial unique index dedups re-deliveries\n  // (paired with `onConflictDoNothing` in reporting-service.ingestEvents).\n  // Partial (execution_id IS NOT NULL) because that's the natural per-event\n  // key; events without an executionId (rare) aren't deduped, which is safe.\n  // Includes pipeline_id so a (theoretical) execution-id reuse across pipelines\n  // can't collide now that the ARN is no longer part of the row.\n  //\n  // COALESCE the nullable parts to sentinels (expression index): PIPELINE/STAGE/\n  // BUILD events leave stage_name/action_name NULL (plugin-build also pipeline_id\n  // NULL), and Postgres treats NULLs as DISTINCT in a unique index — so the plain\n  // column index never matches for those types and onConflictDoNothing can't dedup\n  // their at-least-once re-deliveries. Collapsing NULL→'' makes equal events equal.\n  // (drizzle's uniqueIndex can't express NULLS NOT DISTINCT on a partial index, so\n  // we use the equivalent expression index.) MIGRATION REQUIRED: drizzle-kit generate.\n  dedupIdx: uniqueIndex('event_dedup_idx')\n    .on(\n      sql`coalesce(${table.pipelineId}::text, '')`,\n      table.executionId,\n      table.eventType,\n      table.status,\n      sql`coalesce(${table.stageName}, '')`,\n      sql`coalesce(${table.actionName}, '')`,\n    )\n    .where(sql`execution_id IS NOT NULL`),\n}));\n\n/**\n * TypeScript types representing database rows\n */\nexport type Pipeline = typeof pipeline.$inferSelect;\nexport type PipelineInsert = typeof pipeline.$inferInsert;\n\nexport type PipelineRegistry = typeof pipelineRegistry.$inferSelect;\nexport type PipelineRegistryInsert = typeof pipelineRegistry.$inferInsert;\n\nexport type PipelineEvent = typeof pipelineEvent.$inferSelect;\nexport type PipelineEventInsert = typeof pipelineEvent.$inferInsert;\n\n/**\n * Helper types for working with partial updates\n */\nexport type PipelineUpdate = Partial<Omit<PipelineInsert, 'id' | 'createdAt' | 'createdBy'>>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../../src/database/schema/pipeline.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAqB,MAAM,4BAA4B,CAAC;AAC9F,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AA0B3H;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,EAAE;IAC3C,cAAc;IACd,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE;IAE3C,kCAAkC;IAClC,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;SACtC,OAAO,CAAC,aAAa,CAAC;SACtB,OAAO,EAAE;IAEZ,eAAe;IACf,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC;SAC1B,OAAO,CAAC,aAAa,CAAC;SACtB,OAAO,EAAE;IACZ,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;SACvD,UAAU,EAAE;SACZ,OAAO,EAAE;IACZ,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC;SAC1B,OAAO,CAAC,aAAa,CAAC;SACtB,OAAO,EAAE;IACZ,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;SACvD,UAAU,EAAE;SACZ,OAAO,EAAE;IAEZ,4BAA4B;IAC5B,OAAO,EAAE,OAAO,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;SACzC,OAAO,EAAE;IACZ,YAAY,EAAE,OAAO,CAAC,cAAc,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;SACnD,OAAO,EAAE;IACZ,YAAY,EAAE,OAAO,CAAC,eAAe,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACvD,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC;IAChC,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC;SACxB,KAAK,EAAY;SACjB,OAAO,CAAC,EAAE,CAAC;SACX,OAAO,EAAE;IAEZ,yBAAyB;IACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;SAClB,KAAK,EAAyB;SAC9B,OAAO,EAAE;IAEZ,wBAAwB;IACxB,cAAc,EAAE,OAAO,CAAC,iBAAiB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;SACvD,KAAK,EAAkB;SACvB,OAAO,CAAC,SAA2B,CAAC;SACpC,OAAO,EAAE;IACZ,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC;SAC7B,OAAO,CAAC,KAAK,CAAC;SACd,OAAO,EAAE;IACZ,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC;SAC3B,OAAO,CAAC,IAAI,CAAC;SACb,OAAO,EAAE;IAEZ,kCAAkC;IAClC,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;IAC1D,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC;CAC9B,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACb,6BAA6B;IAC7B,UAAU,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC;IAC3D,eAAe,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC;IAC1E,QAAQ,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;IACtD,SAAS,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;IAC1D,YAAY,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAClE,YAAY,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAElE,+DAA+D;IAC/D,YAAY,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC;IAE9E,2EAA2E;IAC3E,kBAAkB,EAAE,KAAK,CAAC,gCAAgC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,QAAQ,CAAC;IAEjH,0EAA0E;IAC1E,gBAAgB,EAAE,KAAK,CAAC,8BAA8B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,CAAA,kBAAkB,CAAC;IAErH,sDAAsD;IACtD,gBAAgB,EAAE,WAAW,CAAC,6BAA6B,CAAC;SACzD,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC;CACtD,CAAC,CAAC,CAAC;AAEJ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,EAAE;IAC3D,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE;IAC3C,8EAA8E;IAC9E,0EAA0E;IAC1E,wEAAwE;IACxE,2EAA2E;IAC3E,0EAA0E;IAC1E,mEAAmE;IACnE,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE;IAClD,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE;IACnD,YAAY,EAAE,OAAO,CAAC,eAAe,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE;IACjE,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACzC,OAAO,EAAE,OAAO,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IAC5C,YAAY,EAAE,OAAO,CAAC,cAAc,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACtD,YAAY,EAAE,SAAS,CAAC,eAAe,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;IAChE,SAAS,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACjD,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE;IACjF,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE;CAClF,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;IACtD,YAAY,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;CAC7E,CAAC,CAAC,CAAC;AAYJ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC,iBAAiB,EAAE;IACtD,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE;IAC3C,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC;IAC/B,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,EAAE;IACnD,WAAW,EAAE,OAAO,CAAC,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAe,CAAC,OAAO,EAAE;IACnF,SAAS,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAa,CAAC,OAAO,EAAE;IAC7E,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE;IACnD,WAAW,EAAE,OAAO,CAAC,cAAc,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACrD,SAAS,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACjD,UAAU,EAAE,OAAO,CAAC,aAAa,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACnD,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC;IACnC,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;IAC1D,WAAW,EAAE,SAAS,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;IAC9D,UAAU,EAAE,OAAO,CAAC,aAAa,CAAC;IAClC,6EAA6E;IAC7E,6EAA6E;IAC7E,4EAA4E;IAC5E,uEAAuE;IACvE,0EAA0E;IAC1E,SAAS,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACjD,SAAS,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACjD,WAAW,EAAE,OAAO,CAAC,aAAa,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACpD,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,KAAK,EAA2B;IACxD,SAAS,EAAE,SAAS,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE;CAClF,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACb,aAAa,EAAE,KAAK,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC;IAClE,QAAQ,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;IACnD,YAAY,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IACzD,SAAS,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC;IACrD,cAAc,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC;IACrE,YAAY,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAC/D,iBAAiB,EAAE,KAAK,CAAC,4BAA4B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC;IACxG,kBAAkB,EAAE,KAAK,CAAC,6BAA6B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC;IACzG,4EAA4E;IAC5E,yEAAyE;IACzE,yEAAyE;IACzE,0EAA0E;IAC1E,2EAA2E;IAC3E,8EAA8E;IAC9E,+DAA+D;IAC/D,EAAE;IACF,+EAA+E;IAC/E,gFAAgF;IAChF,gFAAgF;IAChF,iFAAiF;IACjF,kFAAkF;IAClF,iFAAiF;IACjF,qFAAqF;IACrF,QAAQ,EAAE,WAAW,CAAC,iBAAiB,CAAC;SACrC,EAAE,CACD,GAAG,CAAA,YAAY,KAAK,CAAC,UAAU,aAAa,EAC5C,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,SAAS,EACf,KAAK,CAAC,MAAM,EACZ,GAAG,CAAA,YAAY,KAAK,CAAC,SAAS,OAAO,EACrC,GAAG,CAAA,YAAY,KAAK,CAAC,UAAU,OAAO,CACvC;SACA,KAAK,CAAC,GAAG,CAAA,0BAA0B,CAAC;IACvC,yEAAyE;IACzE,6EAA6E;IAC7E,6EAA6E;IAC7E,+EAA+E;IAC/E,2EAA2E;IAC3E,6EAA6E;IAC7E,0EAA0E;IAC1E,4CAA4C;IAC5C,iBAAiB,EAAE,KAAK,CAAC,4BAA4B,CAAC;SACnD,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC;SACvD,KAAK,CAAC,GAAG,CAAA,yBAAyB,CAAC;IACtC,4EAA4E;IAC5E,+EAA+E;IAC/E,yEAAyE;IACzE,+EAA+E;IAC/E,6EAA6E;IAC7E,sBAAsB,EAAE,KAAK,CAAC,iCAAiC,CAAC;SAC7D,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1D,CAAC,CAAC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccessModifier, SYSTEM_ORG_ID, type MetaDataType } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { boolean, integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex } from 'drizzle-orm/pg-core';\n\n/**\n * Pipeline builder configuration properties stored in database.\n * Mirrors the canonical BuilderProps from pipeline-core (JSON-serializable form).\n */\nexport interface PipelineBuilderConfig {\n  readonly project: string;\n  readonly organization: string;\n  readonly pipelineName?: string;\n  readonly global?: MetaDataType;\n  readonly synth: Record<string, unknown>;\n  readonly defaults?: Record<string, unknown>;\n  readonly role?: Record<string, unknown>;\n  readonly stages?: PipelineStageConfig[];\n}\n\n/**\n * Stage configuration stored in database (JSON-serializable).\n */\nexport interface PipelineStageConfig {\n  readonly stageName: string;\n  readonly alias?: string;\n  readonly steps: Record<string, unknown>[];\n}\n\n/**\n * Table for storing pipeline instances and their full configuration.\n *\n * Features * - Full BuilderProps serialization for reconstruction\n * - Organization-level isolation\n * - Pipeline status tracking\n * - Execution history tracking\n * - Flexible tagging system\n *\n * @table pipelines\n */\nexport const pipeline = pgTable('pipelines', {\n  // Primary key\n  id: uuid('id').primaryKey().defaultRandom(),\n\n  // Organization and access control\n  orgId: varchar('org_id', { length: 255 })\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n\n  // Audit fields\n  createdBy: text('created_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n  updatedBy: text('updated_by')\n    .default(SYSTEM_ORG_ID)\n    .notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n\n  // Core pipeline information\n  project: varchar('project', { length: 255 })\n    .notNull(),\n  organization: varchar('organization', { length: 255 })\n    .notNull(),\n  pipelineName: varchar('pipeline_name', { length: 255 }),\n  description: text('description'),\n  keywords: jsonb('keywords')\n    .$type<string[]>()\n    .default([])\n    .notNull(),\n\n  // Pipeline configuration\n  props: jsonb('props')\n    .$type<PipelineBuilderConfig>()\n    .notNull(),\n\n  // Access and visibility\n  accessModifier: varchar('access_modifier', { length: 10 })\n    .$type<AccessModifier>()\n    .default('private' as AccessModifier)\n    .notNull(),\n  isDefault: boolean('is_default')\n    .default(false)\n    .notNull(),\n  isActive: boolean('is_active')\n    .default(true)\n    .notNull(),\n\n  // Deletion tracking (soft delete)\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n}, (table) => ({\n  // Indexes for common queries\n  projectIdx: index('pipeline_project_idx').on(table.project),\n  organizationIdx: index('pipeline_organization_idx').on(table.organization),\n  orgIdIdx: index('pipeline_org_id_idx').on(table.orgId),\n  activeIdx: index('pipeline_active_idx').on(table.isActive),\n  createdAtIdx: index('pipeline_created_at_idx').on(table.createdAt),\n  updatedAtIdx: index('pipeline_updated_at_idx').on(table.updatedAt),\n\n  // Composite index for common access pattern (orgId + isActive)\n  orgActiveIdx: index('pipeline_org_active_idx').on(table.orgId, table.isActive),\n\n  // Composite index for filtered queries (orgId + accessModifier + isActive)\n  orgAccessActiveIdx: index('pipeline_org_access_active_idx').on(table.orgId, table.accessModifier, table.isActive),\n\n  // Partial index for active-only queries (smaller, faster than full index)\n  activeOnlyOrgIdx: index('pipeline_active_only_org_idx').on(table.orgId, table.createdAt).where(sql`is_active = true`),\n\n  // Unique constraint on project + organization + orgId\n  projectOrgUnique: uniqueIndex('pipeline_project_org_unique')\n    .on(table.project, table.organization, table.orgId),\n}));\n\n/**\n * Pipeline deployment registry.\n * Maps deployed CodePipeline ARNs back to pipeline records and org IDs.\n * Populated by the deploy command after successful CDK deploy.\n * Used by the pipeline-events Lambda to resolve EventBridge events to org-scoped records.\n *\n * @table pipeline_registry\n */\nexport const pipelineRegistry = pgTable('pipeline_registry', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  // The platform's pipeline record id — a STABLE uuid created with the pipeline\n  // record, known at CDK synth, and applied to the live CodePipeline as the\n  // `PIPELINE_EVENT_ID` tag. The events Lambda reads that tag and reports\n  // against this id, so it IS the event join key (replacing the masked ARN —\n  // it carries no AWS account/region, so no masking is needed). Unique: one\n  // registry row per pipeline + the upsert key for (re)registration.\n  pipelineId: uuid('pipeline_id').notNull().unique(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  pipelineName: varchar('pipeline_name', { length: 255 }).notNull(),\n  region: varchar('region', { length: 30 }),\n  project: varchar('project', { length: 255 }),\n  organization: varchar('organization', { length: 255 }),\n  lastDeployed: timestamp('last_deployed', { withTimezone: true }),\n  stackName: varchar('stack_name', { length: 255 }),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  orgIdIdx: index('registry_org_id_idx').on(table.orgId),\n  orgRegionIdx: index('registry_org_region_idx').on(table.orgId, table.region),\n}));\n\n/**\n * Event source identifiers for pipeline_events.\n */\nexport type EventSource = 'codepipeline' | 'codebuild' | 'plugin-build';\n\n/**\n * Event type granularity levels for pipeline_events.\n */\nexport type EventType = 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n\n/**\n * Pipeline execution and build events.\n * Captures CodePipeline/CodeBuild state changes from EventBridge\n * and plugin Docker build outcomes from BullMQ.\n * All events are org-scoped for multi-tenant reporting.\n *\n * @table pipeline_events\n */\nexport const pipelineEvent = pgTable('pipeline_events', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  pipelineId: uuid('pipeline_id'),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  eventSource: varchar('event_source', { length: 50 }).$type<EventSource>().notNull(),\n  eventType: varchar('event_type', { length: 50 }).$type<EventType>().notNull(),\n  status: varchar('status', { length: 20 }).notNull(),\n  executionId: varchar('execution_id', { length: 255 }),\n  stageName: varchar('stage_name', { length: 255 }),\n  actionName: varchar('action_name', { length: 255 }),\n  errorMessage: text('error_message'),\n  startedAt: timestamp('started_at', { withTimezone: true }),\n  completedAt: timestamp('completed_at', { withTimezone: true }),\n  durationMs: integer('duration_ms'),\n  // DORA deploy-attribution (all nullable; populated at ingest when the source\n  // event carries them — legacy/CI-only events leave them NULL). `environment`\n  // is the deploy target (e.g. \"production\"); its presence marks an execution\n  // as a real deployment, letting DORA scope past generic pipeline runs.\n  // `commitSha`/`commitRef` capture the source revision for lead-time work.\n  commitSha: varchar('commit_sha', { length: 255 }),\n  commitRef: varchar('commit_ref', { length: 255 }),\n  environment: varchar('environment', { length: 255 }),\n  detail: jsonb('detail').$type<Record<string, unknown>>(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  pipelineIdIdx: index('event_pipeline_id_idx').on(table.pipelineId),\n  orgIdIdx: index('event_org_id_idx').on(table.orgId),\n  eventTypeIdx: index('event_type_idx').on(table.eventType),\n  statusIdx: index('event_status_idx').on(table.status),\n  executionIdIdx: index('event_execution_id_idx').on(table.executionId),\n  createdAtIdx: index('event_created_at_idx').on(table.createdAt),\n  orgTypeCreatedIdx: index('event_org_type_created_idx').on(table.orgId, table.eventType, table.createdAt),\n  orgSourceStatusIdx: index('event_org_source_status_idx').on(table.orgId, table.eventSource, table.status),\n  // Idempotency: EventBridge → SQS is at-least-once, so the same state-change\n  // can be delivered twice. This partial unique index dedups re-deliveries\n  // (paired with `onConflictDoNothing` in reporting-service.ingestEvents).\n  // Partial (execution_id IS NOT NULL) because that's the natural per-event\n  // key; events without an executionId (rare) aren't deduped, which is safe.\n  // Includes pipeline_id so a (theoretical) execution-id reuse across pipelines\n  // can't collide now that the ARN is no longer part of the row.\n  //\n  // COALESCE the nullable parts to sentinels (expression index): PIPELINE/STAGE/\n  // BUILD events leave stage_name/action_name NULL (plugin-build also pipeline_id\n  // NULL), and Postgres treats NULLs as DISTINCT in a unique index — so the plain\n  // column index never matches for those types and onConflictDoNothing can't dedup\n  // their at-least-once re-deliveries. Collapsing NULL→'' makes equal events equal.\n  // (drizzle's uniqueIndex can't express NULLS NOT DISTINCT on a partial index, so\n  // we use the equivalent expression index.) MIGRATION REQUIRED: drizzle-kit generate.\n  dedupIdx: uniqueIndex('event_dedup_idx')\n    .on(\n      sql`coalesce(${table.pipelineId}::text, '')`,\n      table.executionId,\n      table.eventType,\n      table.status,\n      sql`coalesce(${table.stageName}, '')`,\n      sql`coalesce(${table.actionName}, '')`,\n    )\n    .where(sql`execution_id IS NOT NULL`),\n  // DORA deploy-scoped reads: only PIPELINE-level executions tagged with a\n  // deploy environment. `event_type` is in the index because the events Lambda\n  // tags EVERY event of a deployed pipeline (STAGE/ACTION too), while the DORA\n  // scan wants only `event_type='PIPELINE'` — including it restores selectivity.\n  // Partial (environment IS NOT NULL) keeps it small — legacy/CI-only events\n  // aren't indexed. The default run-based DORA path (no environment) can't use\n  // this partial index; it relies on event_pipeline_type_started_idx below.\n  // MIGRATION REQUIRED: drizzle-kit generate.\n  envTypeStartedIdx: index('event_env_type_started_idx')\n    .on(table.environment, table.eventType, table.startedAt)\n    .where(sql`environment IS NOT NULL`),\n  // started_at range scans: every Category-1 report and the default run-based\n  // DORA path filters `event_type='PIPELINE' AND started_at BETWEEN …` joined on\n  // pipeline_id, but the other event composite index is on created_at, not\n  // started_at — so the range scan had no ideal index. This composite serves the\n  // join-driven scan by pipeline_id. MIGRATION REQUIRED: drizzle-kit generate.\n  pipelineTypeStartedIdx: index('event_pipeline_type_started_idx')\n    .on(table.pipelineId, table.eventType, table.startedAt),\n}));\n\n/**\n * TypeScript types representing database rows\n */\nexport type Pipeline = typeof pipeline.$inferSelect;\nexport type PipelineInsert = typeof pipeline.$inferInsert;\n\nexport type PipelineRegistry = typeof pipelineRegistry.$inferSelect;\nexport type PipelineRegistryInsert = typeof pipelineRegistry.$inferInsert;\n\nexport type PipelineEvent = typeof pipelineEvent.$inferSelect;\nexport type PipelineEventInsert = typeof pipelineEvent.$inferInsert;\n\n/**\n * Helper types for working with partial updates\n */\nexport type PipelineUpdate = Partial<Omit<PipelineInsert, 'id' | 'createdAt' | 'createdBy'>>;\n"]}

package/package.json

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