@pipeline-builder/pipeline-data 4.1.24 → 4.1.26

package/lib/database/schema/reporting-analytics.js

@@ -0,0 +1,250 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The analytics layer every report section and dashboard reads instead of raw
+ * events.
+ *
+ * Reporting has been scanning `pipeline_events` directly. That worked while the
+ * only consumer was one dashboard over a 30-day window, and stops working for
+ * this feature: a quarterly report over a 90-day window, for an org with a
+ * thousand executions a day, re-derives the same aggregates on every read, and
+ * the retention sweep then deletes the rows the numbers came from. Two tables fix
+ * both problems:
+ *
+ *  - `dora_deployments` — ONE ROW PER DEPLOY, written at ingest. Lead time is
+ *    stored per execution here, never recomputed per event, because the
+ *    per-event form double-counts: a deploy stage emits a STAGE event and an
+ *    ACTION event, and both carry the same commit range.
+ *  - `execution_daily_rollups` — one row per org, pipeline, stage and day. Every
+ *    section that says "runs", "success rate", "p95" or "build minutes" reads
+ *    these, so a report costs a few hundred rows instead of a few hundred
+ *    thousand.
+ *
+ * Both are DERIVED: they can be rebuilt from events while the events exist, and
+ * they outlive them afterwards. That is the point — they are the retained form.
+ *
+ * The other two tables here answer "what is actually running", which the report's
+ * plugin sections need and no existing table can answer:
+ *
+ *  - `pipeline_plugin_resolution` — what a pipeline's DECLARED plugin versions
+ *    resolve to, recomputed on write rather than resolved per read.
+ *  - `plugin_vuln_exposure` — which pipelines are exposed to which vulnerable
+ *    plugin version, opened by a rescan and closed by a fixing deploy.
+ */
+import { sql } from 'drizzle-orm';
+import { boolean, index, integer, jsonb, pgTable, primaryKey, text, timestamp, uniqueIndex, varchar } from 'drizzle-orm/pg-core';
+/**
+ * Why a deploy's lead time could not be measured. Recorded rather than left NULL
+ * with no explanation, because the three causes need different fixes and the
+ * report shows the reason: no SCM token for the source, the provider rate-limited
+ * the range walk, or the source type has no range API at all.
+ */
+export const LEAD_TIME_GAPS = ['no_token', 'rate_limited', 'unsupported_source', 'no_commit_data'];
+/**
+ * How confidently an incident was attributed to a deploy. Shown beside change
+ * failure rate and time to restore, because "this deploy broke production" and
+ * "an incident opened some hours after this deploy" are different claims and a
+ * manager acts differently on each.
+ */
+export const CORRELATION_CONFIDENCES = ['high', 'medium', 'low'];
+/**
+ * How a pipeline came to exist. For the adoption section: an org whose pipelines
+ * are all hand-built is a different adoption story from one templating them.
+ */
+export const PIPELINE_CREATION_SOURCES = ['manual', 'template', 'ai', 'bulk', 'cdk'];
+/**
+ * What kind of thing broke. Assigned at ingest by the classifier
+ * (`api/reporting/src/services/failure-classifier.ts`), which is rules over the
+ * action's type and error text — deliberately data, not code, so the taxonomy can
+ * grow without a deploy.
+ *
+ * The categories overlap the plugin-build taxonomy on purpose: a dependency
+ * failure is a dependency failure whether it happened building a plugin or
+ * running one, and two vocabularies for the same thing would make the report and
+ * the build queue disagree.
+ */
+export const FAILURE_CATEGORIES = [
+    'source_checkout', 'dependency', 'build', 'unit_test', 'integration_test',
+    'security_scan', 'infrastructure', 'deployment', 'authentication', 'permissions',
+    'configuration', 'timeout', 'resource_exhaustion', 'external_service', 'other',
+];
+/** Where a plugin-version exposure was observed. */
+export const EXPOSURE_SOURCES = ['declared', 'deployed'];
+/**
+ * What an org decided about an exposure. `open` until someone looks;
+ * `accepted` is a time-boxed decision with a reason and an owner, never a
+ * permanent mute; `false_positive` is a scanner disagreement worth recording so
+ * the same finding stops being re-raised as news.
+ */
+export const EXPOSURE_TRIAGE_STATES = ['open', 'accepted', 'false_positive', 'fixed'];
+/**
+ * One deployment: an execution that reached an environment.
+ *
+ * Written at ingest, one row per (execution, environment). Everything DORA
+ * reports is here, so `/dora`, the trend and the report sections stop scanning
+ * raw events — and keep working after the events are swept.
+ *
+ * @table dora_deployments
+ */
+export const doraDeployment = pgTable('dora_deployments', {
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    executionId: varchar('execution_id', { length: 255 }).notNull(),
+    environment: varchar('environment', { length: 255 }).notNull(),
+    pipelineId: varchar('pipeline_id', { length: 255 }),
+    /** When the deploy stage completed. The deploy's own timestamp, not the run's. */
+    deployedAt: timestamp('deployed_at', { withTimezone: true }).notNull(),
+    succeeded: boolean('succeeded').notNull(),
+    /**
+     * The OLDEST unshipped commit in this deploy's range. Lead time is
+     * `deployedAt - earliestCommitAt`, computed once and stored, because the
+     * per-event form double-counts a deploy that emits both a STAGE and an ACTION
+     * event carrying the same range.
+     */
+    earliestCommitAt: timestamp('earliest_commit_at', { withTimezone: true }),
+    leadTimeSeconds: integer('lead_time_seconds'),
+    commitCount: integer('commit_count'),
+    commitSha: varchar('commit_sha', { length: 255 }),
+    /** Why lead time is absent, when it is. NULL when it was measured. */
+    leadTimeGap: varchar('lead_time_gap', { length: 30 }).$type(),
+    /**
+     * Post-deploy outcome markers, denormalized onto the deploy so change-failure
+     * rate and time-to-restore are one scan rather than a join per window.
+     */
+    failedAt: timestamp('failed_at', { withTimezone: true }),
+    restoredAt: timestamp('restored_at', { withTimezone: true }),
+    /** How the incident→deploy link was judged. NULL when nothing was correlated. */
+    correlationConfidence: varchar('correlation_confidence', { length: 10 }).$type(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    // One row per execution per environment: a redelivered event upserts rather
+    // than inserting a second deploy (EventBridge → SQS is at-least-once).
+    pk: primaryKey({ columns: [table.executionId, table.environment] }),
+    // The window scan every DORA read does.
+    orgEnvDeployedIdx: index('dora_deployment_org_env_deployed_idx')
+        .on(table.orgId, table.environment, table.deployedAt),
+    orgDeployedIdx: index('dora_deployment_org_deployed_idx').on(table.orgId, table.deployedAt),
+    pipelineIdx: index('dora_deployment_pipeline_idx').on(table.pipelineId, table.deployedAt),
+    // The promotion view: one commit's path across environments.
+    commitIdx: index('dora_deployment_commit_idx').on(table.orgId, table.commitSha)
+        .where(sql `commit_sha IS NOT NULL`),
+}));
+/**
+ * Pre-aggregated execution counts and timings, one row per org, pipeline, stage
+ * and UTC day.
+ *
+ * Rebuilt for a day when late events arrive, so the rollup and the events agree
+ * while both exist. `failuresByCategory` is a JSON map rather than a column per
+ * category because the taxonomy grows.
+ *
+ * @table execution_daily_rollups
+ */
+export const executionDailyRollup = pgTable('execution_daily_rollups', {
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    /** The UTC date this row aggregates. Report periods re-bucket in the report's
+     *  own timezone by summing days — which is why the grain is a DAY. */
+    day: timestamp('day', { withTimezone: true }).notNull(),
+    pipelineId: varchar('pipeline_id', { length: 255 }).notNull(),
+    /** `''` for the pipeline-level row; a stage name for a stage-level row. */
+    stageName: varchar('stage_name', { length: 255 }).default('').notNull(),
+    runs: integer('runs').default(0).notNull(),
+    succeeded: integer('succeeded').default(0).notNull(),
+    failed: integer('failed').default(0).notNull(),
+    /** category → count. Feeds the failure-analysis section. */
+    failuresByCategory: jsonb('failures_by_category').$type().default({}).notNull(),
+    p50Ms: integer('p50_ms'),
+    p90Ms: integer('p90_ms'),
+    p95Ms: integer('p95_ms'),
+    /** Summed execution duration, in seconds. The resource-consumption section's
+     *  only input; deliberately NOT converted to money anywhere. */
+    buildSeconds: integer('build_seconds').default(0).notNull(),
+    /** When this row was last rebuilt, so a late-event rebuild is visible. */
+    computedAt: timestamp('computed_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    pk: primaryKey({ columns: [table.orgId, table.day, table.pipelineId, table.stageName] }),
+    orgDayIdx: index('execution_rollup_org_day_idx').on(table.orgId, table.day),
+    pipelineDayIdx: index('execution_rollup_pipeline_day_idx').on(table.pipelineId, table.day),
+}));
+/**
+ * What a pipeline's declared plugin steps resolve to.
+ *
+ * Recomputed on pipeline write and on plugin publish, rather than resolved at
+ * read time: the outdated-plugin section compares "in use" against "latest
+ * available" for every step of every pipeline, and doing that resolution per read
+ * made it a query nobody could afford to put in a report.
+ *
+ * @table pipeline_plugin_resolution
+ */
+export const pipelinePluginResolution = pgTable('pipeline_plugin_resolution', {
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    pipelineId: varchar('pipeline_id', { length: 255 }).notNull(),
+    stageName: varchar('stage_name', { length: 255 }).notNull(),
+    stepName: varchar('step_name', { length: 255 }).notNull(),
+    pluginPublisher: varchar('plugin_publisher', { length: 39 }),
+    pluginName: varchar('plugin_name', { length: 255 }).notNull(),
+    /** What the config asked for — a range, a pin, or nothing. */
+    declaredVersion: varchar('declared_version', { length: 50 }),
+    /** What that resolves to today. NULL when nothing satisfies it. */
+    resolvedVersion: varchar('resolved_version', { length: 50 }),
+    /** The newest version the org is entitled to install, for the "gap" column. */
+    latestVersion: varchar('latest_version', { length: 50 }),
+    /** `major` / `minor` / `patch` / `none`, from resolved → latest. */
+    versionGap: varchar('version_gap', { length: 10 }),
+    /** False when the resolved version is outside the org's consumption policy. */
+    withinPolicy: boolean('within_policy').default(true).notNull(),
+    computedAt: timestamp('computed_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    pk: primaryKey({ columns: [table.pipelineId, table.stageName, table.stepName] }),
+    orgIdx: index('pipeline_plugin_resolution_org_idx').on(table.orgId),
+    pluginIdx: index('pipeline_plugin_resolution_plugin_idx').on(table.pluginPublisher, table.pluginName),
+    // "Which pipelines are behind?" — the outdated section's driving scan.
+    gapIdx: index('pipeline_plugin_resolution_gap_idx').on(table.orgId, table.versionGap),
+}));
+/**
+ * One pipeline's exposure to one vulnerable plugin version.
+ *
+ * Opened by the nightly rescan when a version in use has fixable Critical/High
+ * findings, and CLOSED by a deploy that moves the pipeline off it. It is a
+ * per-pipeline row rather than a per-version one because the question a manager
+ * asks is "which of our pipelines is exposed", and answering that from a
+ * version-level table means re-deriving the pipeline set on every read.
+ *
+ * Keyed by IMAGE DIGEST, not version string: a version rebuilt on a patched base
+ * image is a different artifact with different findings, and keying on the string
+ * would report the old one forever.
+ *
+ * @table plugin_vuln_exposure
+ */
+export const pluginVulnExposure = pgTable('plugin_vuln_exposure', {
+    id: varchar('id', { length: 255 }).primaryKey(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    pipelineId: varchar('pipeline_id', { length: 255 }).notNull(),
+    pluginPublisher: varchar('plugin_publisher', { length: 39 }),
+    pluginName: varchar('plugin_name', { length: 255 }).notNull(),
+    pluginVersion: varchar('plugin_version', { length: 50 }).notNull(),
+    imageDigest: varchar('image_digest', { length: 71 }),
+    source: varchar('source', { length: 10 }).$type().notNull(),
+    criticalCount: integer('critical_count').default(0).notNull(),
+    highCount: integer('high_count').default(0).notNull(),
+    /** The findings themselves: CVE id, package, fixed-in version. Capped by the writer. */
+    topFindings: jsonb('top_findings').$type().default([]).notNull(),
+    flaggedAt: timestamp('flagged_at', { withTimezone: true }).defaultNow().notNull(),
+    /** Set when a deploy moved the pipeline onto a version without the findings. */
+    fixedAt: timestamp('fixed_at', { withTimezone: true }),
+    triageState: varchar('triage_state', { length: 20 }).$type().default('open').notNull(),
+    /** An acceptance is time-boxed: a permanent mute is how a finding is forgotten. */
+    acceptedUntil: timestamp('accepted_until', { withTimezone: true }),
+    triageReason: text('triage_reason'),
+    triagedBy: text('triaged_by'),
+    triagedAt: timestamp('triaged_at', { withTimezone: true }),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    // One live exposure per (pipeline, plugin version, digest, source): a nightly
+    // rescan refreshes counts rather than opening a new row every night.
+    exposureUnique: uniqueIndex('plugin_vuln_exposure_unique')
+        .on(table.pipelineId, table.pluginName, table.pluginVersion, table.source),
+    orgOpenIdx: index('plugin_vuln_exposure_org_open_idx').on(table.orgId, table.triageState)
+        .where(sql `fixed_at IS NULL`),
+    digestIdx: index('plugin_vuln_exposure_digest_idx').on(table.imageDigest),
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting-analytics.js","sourceRoot":"","sources":["../../../src/database/schema/reporting-analytics.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The analytics layer every report section and dashboard reads instead of raw\n * events.\n *\n * Reporting has been scanning `pipeline_events` directly. That worked while the\n * only consumer was one dashboard over a 30-day window, and stops working for\n * this feature: a quarterly report over a 90-day window, for an org with a\n * thousand executions a day, re-derives the same aggregates on every read, and\n * the retention sweep then deletes the rows the numbers came from. Two tables fix\n * both problems:\n *\n *  - `dora_deployments` — ONE ROW PER DEPLOY, written at ingest. Lead time is\n *    stored per execution here, never recomputed per event, because the\n *    per-event form double-counts: a deploy stage emits a STAGE event and an\n *    ACTION event, and both carry the same commit range.\n *  - `execution_daily_rollups` — one row per org, pipeline, stage and day. Every\n *    section that says \"runs\", \"success rate\", \"p95\" or \"build minutes\" reads\n *    these, so a report costs a few hundred rows instead of a few hundred\n *    thousand.\n *\n * Both are DERIVED: they can be rebuilt from events while the events exist, and\n * they outlive them afterwards. That is the point — they are the retained form.\n *\n * The other two tables here answer \"what is actually running\", which the report's\n * plugin sections need and no existing table can answer:\n *\n *  - `pipeline_plugin_resolution` — what a pipeline's DECLARED plugin versions\n *    resolve to, recomputed on write rather than resolved per read.\n *  - `plugin_vuln_exposure` — which pipelines are exposed to which vulnerable\n *    plugin version, opened by a rescan and closed by a fixing deploy.\n */\n\nimport { sql } from 'drizzle-orm';\nimport { boolean, index, integer, jsonb, pgTable, primaryKey, text, timestamp, uniqueIndex, varchar } from 'drizzle-orm/pg-core';\n\n/**\n * Why a deploy's lead time could not be measured. Recorded rather than left NULL\n * with no explanation, because the three causes need different fixes and the\n * report shows the reason: no SCM token for the source, the provider rate-limited\n * the range walk, or the source type has no range API at all.\n */\nexport const LEAD_TIME_GAPS = ['no_token', 'rate_limited', 'unsupported_source', 'no_commit_data'] as const;\nexport type LeadTimeGap = (typeof LEAD_TIME_GAPS)[number];\n\n/**\n * How confidently an incident was attributed to a deploy. Shown beside change\n * failure rate and time to restore, because \"this deploy broke production\" and\n * \"an incident opened some hours after this deploy\" are different claims and a\n * manager acts differently on each.\n */\nexport const CORRELATION_CONFIDENCES = ['high', 'medium', 'low'] as const;\nexport type CorrelationConfidence = (typeof CORRELATION_CONFIDENCES)[number];\n\n/**\n * How a pipeline came to exist. For the adoption section: an org whose pipelines\n * are all hand-built is a different adoption story from one templating them.\n */\nexport const PIPELINE_CREATION_SOURCES = ['manual', 'template', 'ai', 'bulk', 'cdk'] as const;\nexport type PipelineCreationSource = (typeof PIPELINE_CREATION_SOURCES)[number];\n\n/**\n * What kind of thing broke. Assigned at ingest by the classifier\n * (`api/reporting/src/services/failure-classifier.ts`), which is rules over the\n * action's type and error text — deliberately data, not code, so the taxonomy can\n * grow without a deploy.\n *\n * The categories overlap the plugin-build taxonomy on purpose: a dependency\n * failure is a dependency failure whether it happened building a plugin or\n * running one, and two vocabularies for the same thing would make the report and\n * the build queue disagree.\n */\nexport const FAILURE_CATEGORIES = [\n  'source_checkout', 'dependency', 'build', 'unit_test', 'integration_test',\n  'security_scan', 'infrastructure', 'deployment', 'authentication', 'permissions',\n  'configuration', 'timeout', 'resource_exhaustion', 'external_service', 'other',\n] as const;\nexport type FailureCategory = (typeof FAILURE_CATEGORIES)[number];\n\n/** Where a plugin-version exposure was observed. */\nexport const EXPOSURE_SOURCES = ['declared', 'deployed'] as const;\nexport type ExposureSource = (typeof EXPOSURE_SOURCES)[number];\n\n/**\n * What an org decided about an exposure. `open` until someone looks;\n * `accepted` is a time-boxed decision with a reason and an owner, never a\n * permanent mute; `false_positive` is a scanner disagreement worth recording so\n * the same finding stops being re-raised as news.\n */\nexport const EXPOSURE_TRIAGE_STATES = ['open', 'accepted', 'false_positive', 'fixed'] as const;\nexport type ExposureTriageState = (typeof EXPOSURE_TRIAGE_STATES)[number];\n\n/**\n * One deployment: an execution that reached an environment.\n *\n * Written at ingest, one row per (execution, environment). Everything DORA\n * reports is here, so `/dora`, the trend and the report sections stop scanning\n * raw events — and keep working after the events are swept.\n *\n * @table dora_deployments\n */\nexport const doraDeployment = pgTable('dora_deployments', {\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  executionId: varchar('execution_id', { length: 255 }).notNull(),\n  environment: varchar('environment', { length: 255 }).notNull(),\n  pipelineId: varchar('pipeline_id', { length: 255 }),\n  /** When the deploy stage completed. The deploy's own timestamp, not the run's. */\n  deployedAt: timestamp('deployed_at', { withTimezone: true }).notNull(),\n  succeeded: boolean('succeeded').notNull(),\n  /**\n   * The OLDEST unshipped commit in this deploy's range. Lead time is\n   * `deployedAt - earliestCommitAt`, computed once and stored, because the\n   * per-event form double-counts a deploy that emits both a STAGE and an ACTION\n   * event carrying the same range.\n   */\n  earliestCommitAt: timestamp('earliest_commit_at', { withTimezone: true }),\n  leadTimeSeconds: integer('lead_time_seconds'),\n  commitCount: integer('commit_count'),\n  commitSha: varchar('commit_sha', { length: 255 }),\n  /** Why lead time is absent, when it is. NULL when it was measured. */\n  leadTimeGap: varchar('lead_time_gap', { length: 30 }).$type<LeadTimeGap>(),\n  /**\n   * Post-deploy outcome markers, denormalized onto the deploy so change-failure\n   * rate and time-to-restore are one scan rather than a join per window.\n   */\n  failedAt: timestamp('failed_at', { withTimezone: true }),\n  restoredAt: timestamp('restored_at', { withTimezone: true }),\n  /** How the incident→deploy link was judged. NULL when nothing was correlated. */\n  correlationConfidence: varchar('correlation_confidence', { length: 10 }).$type<CorrelationConfidence>(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  // One row per execution per environment: a redelivered event upserts rather\n  // than inserting a second deploy (EventBridge → SQS is at-least-once).\n  pk: primaryKey({ columns: [table.executionId, table.environment] }),\n  // The window scan every DORA read does.\n  orgEnvDeployedIdx: index('dora_deployment_org_env_deployed_idx')\n    .on(table.orgId, table.environment, table.deployedAt),\n  orgDeployedIdx: index('dora_deployment_org_deployed_idx').on(table.orgId, table.deployedAt),\n  pipelineIdx: index('dora_deployment_pipeline_idx').on(table.pipelineId, table.deployedAt),\n  // The promotion view: one commit's path across environments.\n  commitIdx: index('dora_deployment_commit_idx').on(table.orgId, table.commitSha)\n    .where(sql`commit_sha IS NOT NULL`),\n}));\n\n/**\n * Pre-aggregated execution counts and timings, one row per org, pipeline, stage\n * and UTC day.\n *\n * Rebuilt for a day when late events arrive, so the rollup and the events agree\n * while both exist. `failuresByCategory` is a JSON map rather than a column per\n * category because the taxonomy grows.\n *\n * @table execution_daily_rollups\n */\nexport const executionDailyRollup = pgTable('execution_daily_rollups', {\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  /** The UTC date this row aggregates. Report periods re-bucket in the report's\n   *  own timezone by summing days — which is why the grain is a DAY. */\n  day: timestamp('day', { withTimezone: true }).notNull(),\n  pipelineId: varchar('pipeline_id', { length: 255 }).notNull(),\n  /** `''` for the pipeline-level row; a stage name for a stage-level row. */\n  stageName: varchar('stage_name', { length: 255 }).default('').notNull(),\n  runs: integer('runs').default(0).notNull(),\n  succeeded: integer('succeeded').default(0).notNull(),\n  failed: integer('failed').default(0).notNull(),\n  /** category → count. Feeds the failure-analysis section. */\n  failuresByCategory: jsonb('failures_by_category').$type<Record<string, number>>().default({}).notNull(),\n  p50Ms: integer('p50_ms'),\n  p90Ms: integer('p90_ms'),\n  p95Ms: integer('p95_ms'),\n  /** Summed execution duration, in seconds. The resource-consumption section's\n   *  only input; deliberately NOT converted to money anywhere. */\n  buildSeconds: integer('build_seconds').default(0).notNull(),\n  /** When this row was last rebuilt, so a late-event rebuild is visible. */\n  computedAt: timestamp('computed_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  pk: primaryKey({ columns: [table.orgId, table.day, table.pipelineId, table.stageName] }),\n  orgDayIdx: index('execution_rollup_org_day_idx').on(table.orgId, table.day),\n  pipelineDayIdx: index('execution_rollup_pipeline_day_idx').on(table.pipelineId, table.day),\n}));\n\n/**\n * What a pipeline's declared plugin steps resolve to.\n *\n * Recomputed on pipeline write and on plugin publish, rather than resolved at\n * read time: the outdated-plugin section compares \"in use\" against \"latest\n * available\" for every step of every pipeline, and doing that resolution per read\n * made it a query nobody could afford to put in a report.\n *\n * @table pipeline_plugin_resolution\n */\nexport const pipelinePluginResolution = pgTable('pipeline_plugin_resolution', {\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  pipelineId: varchar('pipeline_id', { length: 255 }).notNull(),\n  stageName: varchar('stage_name', { length: 255 }).notNull(),\n  stepName: varchar('step_name', { length: 255 }).notNull(),\n  pluginPublisher: varchar('plugin_publisher', { length: 39 }),\n  pluginName: varchar('plugin_name', { length: 255 }).notNull(),\n  /** What the config asked for — a range, a pin, or nothing. */\n  declaredVersion: varchar('declared_version', { length: 50 }),\n  /** What that resolves to today. NULL when nothing satisfies it. */\n  resolvedVersion: varchar('resolved_version', { length: 50 }),\n  /** The newest version the org is entitled to install, for the \"gap\" column. */\n  latestVersion: varchar('latest_version', { length: 50 }),\n  /** `major` / `minor` / `patch` / `none`, from resolved → latest. */\n  versionGap: varchar('version_gap', { length: 10 }),\n  /** False when the resolved version is outside the org's consumption policy. */\n  withinPolicy: boolean('within_policy').default(true).notNull(),\n  computedAt: timestamp('computed_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  pk: primaryKey({ columns: [table.pipelineId, table.stageName, table.stepName] }),\n  orgIdx: index('pipeline_plugin_resolution_org_idx').on(table.orgId),\n  pluginIdx: index('pipeline_plugin_resolution_plugin_idx').on(table.pluginPublisher, table.pluginName),\n  // \"Which pipelines are behind?\" — the outdated section's driving scan.\n  gapIdx: index('pipeline_plugin_resolution_gap_idx').on(table.orgId, table.versionGap),\n}));\n\n/**\n * One pipeline's exposure to one vulnerable plugin version.\n *\n * Opened by the nightly rescan when a version in use has fixable Critical/High\n * findings, and CLOSED by a deploy that moves the pipeline off it. It is a\n * per-pipeline row rather than a per-version one because the question a manager\n * asks is \"which of our pipelines is exposed\", and answering that from a\n * version-level table means re-deriving the pipeline set on every read.\n *\n * Keyed by IMAGE DIGEST, not version string: a version rebuilt on a patched base\n * image is a different artifact with different findings, and keying on the string\n * would report the old one forever.\n *\n * @table plugin_vuln_exposure\n */\nexport const pluginVulnExposure = pgTable('plugin_vuln_exposure', {\n  id: varchar('id', { length: 255 }).primaryKey(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  pipelineId: varchar('pipeline_id', { length: 255 }).notNull(),\n  pluginPublisher: varchar('plugin_publisher', { length: 39 }),\n  pluginName: varchar('plugin_name', { length: 255 }).notNull(),\n  pluginVersion: varchar('plugin_version', { length: 50 }).notNull(),\n  imageDigest: varchar('image_digest', { length: 71 }),\n  source: varchar('source', { length: 10 }).$type<ExposureSource>().notNull(),\n  criticalCount: integer('critical_count').default(0).notNull(),\n  highCount: integer('high_count').default(0).notNull(),\n  /** The findings themselves: CVE id, package, fixed-in version. Capped by the writer. */\n  topFindings: jsonb('top_findings').$type<Array<Record<string, unknown>>>().default([]).notNull(),\n  flaggedAt: timestamp('flagged_at', { withTimezone: true }).defaultNow().notNull(),\n  /** Set when a deploy moved the pipeline onto a version without the findings. */\n  fixedAt: timestamp('fixed_at', { withTimezone: true }),\n  triageState: varchar('triage_state', { length: 20 }).$type<ExposureTriageState>().default('open').notNull(),\n  /** An acceptance is time-boxed: a permanent mute is how a finding is forgotten. */\n  acceptedUntil: timestamp('accepted_until', { withTimezone: true }),\n  triageReason: text('triage_reason'),\n  triagedBy: text('triaged_by'),\n  triagedAt: timestamp('triaged_at', { withTimezone: true }),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  // One live exposure per (pipeline, plugin version, digest, source): a nightly\n  // rescan refreshes counts rather than opening a new row every night.\n  exposureUnique: uniqueIndex('plugin_vuln_exposure_unique')\n    .on(table.pipelineId, table.pluginName, table.pluginVersion, table.source),\n  orgOpenIdx: index('plugin_vuln_exposure_org_open_idx').on(table.orgId, table.triageState)\n    .where(sql`fixed_at IS NULL`),\n  digestIdx: index('plugin_vuln_exposure_digest_idx').on(table.imageDigest),\n}));\n\nexport type DoraDeployment = typeof doraDeployment.$inferSelect;\nexport type DoraDeploymentInsert = typeof doraDeployment.$inferInsert;\nexport type ExecutionDailyRollup = typeof executionDailyRollup.$inferSelect;\nexport type ExecutionDailyRollupInsert = typeof executionDailyRollup.$inferInsert;\nexport type PipelinePluginResolution = typeof pipelinePluginResolution.$inferSelect;\nexport type PipelinePluginResolutionInsert = typeof pipelinePluginResolution.$inferInsert;\nexport type PluginVulnExposure = typeof pluginVulnExposure.$inferSelect;\nexport type PluginVulnExposureInsert = typeof pluginVulnExposure.$inferInsert;\n"]}