@pipeline-builder/pipeline-data 0.0.1

package/lib/database/schema/pipeline.js

@@ -0,0 +1,332 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { SYSTEM_ORG_ID, } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { bigint, boolean, integer, varchar, pgTable, text, timestamp, uuid, jsonb, index, uniqueIndex } from 'drizzle-orm/pg-core';
+/**
+ * Table for storing pipeline instances and their full configuration.
+ *
+ * Features * - Full BuilderProps serialization for reconstruction
+ * - Organization-level isolation
+ * - Pipeline status tracking
+ * - Execution history tracking
+ * - Flexible tagging system
+ *
+ * @table pipelines
+ */
+export const pipeline = pgTable('pipelines', {
+    // Primary key
+    id: uuid('id').primaryKey().defaultRandom(),
+    // Organization and access control
+    orgId: varchar('org_id', { length: 255 })
+        .default(SYSTEM_ORG_ID)
+        .notNull(),
+    // Audit fields
+    createdBy: text('created_by')
+        .default(SYSTEM_ORG_ID)
+        .notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedBy: text('updated_by')
+        .default(SYSTEM_ORG_ID)
+        .notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    // Core pipeline information
+    project: varchar('project', { length: 255 })
+        .notNull(),
+    organization: varchar('organization', { length: 255 })
+        .notNull(),
+    pipelineName: varchar('pipeline_name', { length: 255 }),
+    description: text('description'),
+    keywords: jsonb('keywords')
+        .$type()
+        .default([])
+        .notNull(),
+    // Pipeline configuration
+    props: jsonb('props')
+        .$type()
+        .notNull(),
+    // Developer-portal catalog metadata (ownership / lifecycle / classification).
+    // ownerId defaults to the creating user (set at insert), so every pipeline has
+    // an owner for "my services" views; ownerType distinguishes user vs team.
+    ownerId: text('owner_id'),
+    ownerType: varchar('owner_type', { length: 10 }).$type(),
+    lifecycle: varchar('lifecycle', { length: 20 })
+        .$type()
+        .default('production')
+        .notNull(),
+    criticality: varchar('criticality', { length: 10 }).$type(),
+    labels: jsonb('labels')
+        .$type()
+        .default({})
+        .notNull(),
+    links: jsonb('links')
+        .$type()
+        .default([])
+        .notNull(),
+    // Access and visibility — the shared three-rung ladder (see api-core's
+    // `Visibility`): `private` is author-only (`created_by`), `org` is the whole
+    // owning org, `public` reaches the org's teams and — from the system org —
+    // every org. Constrained at the SQL layer too via a CHECK in postgres-init.sql
+    // so a typo can't sneak past the application layer.
+    visibility: varchar('visibility', { length: 10 })
+        .$type()
+        .default('private')
+        .notNull(),
+    isDefault: boolean('is_default')
+        .default(false)
+        .notNull(),
+    isActive: boolean('is_active')
+        .default(true)
+        .notNull(),
+    // Deletion tracking (soft delete)
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+    // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned
+    // rows once `purge_after` has passed (set on delete alongside deleted_at).
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
+}, (table) => ({
+    // Partial index over just the tombstones — drives the retention purge sweep
+    // (`WHERE deleted_at IS NOT NULL AND purge_after < now`) without scanning live rows.
+    purgeIdx: index('pipeline_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
+    // Indexes for common queries
+    projectIdx: index('pipeline_project_idx').on(table.project),
+    // Developer-portal catalog indexes: "my services" (owner) + lifecycle filter.
+    ownerIdx: index('pipeline_owner_idx').on(table.orgId, table.ownerId),
+    lifecycleIdx: index('pipeline_lifecycle_idx').on(table.orgId, table.lifecycle),
+    organizationIdx: index('pipeline_organization_idx').on(table.organization),
+    orgIdIdx: index('pipeline_org_id_idx').on(table.orgId),
+    activeIdx: index('pipeline_active_idx').on(table.isActive),
+    createdAtIdx: index('pipeline_created_at_idx').on(table.createdAt),
+    updatedAtIdx: index('pipeline_updated_at_idx').on(table.updatedAt),
+    // Composite index for common access pattern (orgId + isActive)
+    orgActiveIdx: index('pipeline_org_active_idx').on(table.orgId, table.isActive),
+    // Composite index for filtered queries (orgId + visibility + isActive)
+    orgVisibilityActiveIdx: index('pipeline_org_visibility_active_idx').on(table.orgId, table.visibility, table.isActive),
+    // Drives the "my private drafts" leg of the visibility predicate.
+    createdByIdx: index('pipeline_created_by_idx').on(table.orgId, table.createdBy),
+    // Partial index for active-only queries (smaller, faster than full index)
+    activeOnlyOrgIdx: index('pipeline_active_only_org_idx').on(table.orgId, table.createdAt).where(sql `is_active = true`),
+    // Unique constraint on project + organization + orgId
+    projectOrgUnique: uniqueIndex('pipeline_project_org_unique')
+        .on(table.project, table.organization, table.orgId),
+}));
+/**
+ * Pipeline deployment registry.
+ * Maps deployed CodePipeline ARNs back to pipeline records and org IDs.
+ * Populated by the deploy command after successful CDK deploy.
+ * Used by the pipeline-events Lambda to resolve EventBridge events to org-scoped records.
+ *
+ * @table pipeline_registry
+ */
+export const pipelineRegistry = pgTable('pipeline_registry', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    // The platform's pipeline record id — a STABLE uuid created with the pipeline
+    // record, known at CDK synth, and applied to the live CodePipeline as the
+    // `pb.pipeline-id` tag. The events Lambda reads that tag and reports
+    // against this id, so it IS the event join key (replacing the masked ARN —
+    // it carries no AWS account/region, so no masking is needed). Unique: one
+    // registry row per pipeline + the upsert key for (re)registration.
+    pipelineId: uuid('pipeline_id').notNull().unique(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    pipelineName: varchar('pipeline_name', { length: 255 }).notNull(),
+    region: varchar('region', { length: 30 }),
+    project: varchar('project', { length: 255 }),
+    organization: varchar('organization', { length: 255 }),
+    lastDeployed: timestamp('last_deployed', { withTimezone: true }),
+    stackName: varchar('stack_name', { length: 255 }),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdIdx: index('registry_org_id_idx').on(table.orgId),
+    orgRegionIdx: index('registry_org_region_idx').on(table.orgId, table.region),
+}));
+/**
+ * Pipeline execution and build events.
+ * Captures CodePipeline/CodeBuild state changes from EventBridge
+ * and plugin Docker build outcomes from BullMQ.
+ * All events are org-scoped for multi-tenant reporting.
+ *
+ * @table pipeline_events
+ */
+export const pipelineEvent = pgTable('pipeline_events', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    pipelineId: uuid('pipeline_id'),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    eventSource: varchar('event_source', { length: 50 }).$type().notNull(),
+    eventType: varchar('event_type', { length: 50 }).$type().notNull(),
+    status: varchar('status', { length: 20 }).notNull(),
+    executionId: varchar('execution_id', { length: 255 }),
+    stageName: varchar('stage_name', { length: 255 }),
+    actionName: varchar('action_name', { length: 255 }),
+    errorMessage: text('error_message'),
+    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 }),
+    // DORA true-lead-time attribution (Phase 4). The forwarder resolves the source
+    // commit range in-account and reports the OLDEST unshipped commit's timestamp
+    // + how many commits shipped. Both nullable — events whose source type/token
+    // can't be resolved leave them NULL and lead time reports `unknown`.
+    commitTimestamp: timestamp('commit_timestamp', { withTimezone: true }),
+    commitCount: integer('commit_count'),
+    detail: jsonb('detail').$type(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    pipelineIdIdx: index('event_pipeline_id_idx').on(table.pipelineId),
+    orgIdIdx: index('event_org_id_idx').on(table.orgId),
+    eventTypeIdx: index('event_type_idx').on(table.eventType),
+    statusIdx: index('event_status_idx').on(table.status),
+    executionIdIdx: index('event_execution_id_idx').on(table.executionId),
+    createdAtIdx: index('event_created_at_idx').on(table.createdAt),
+    orgTypeCreatedIdx: index('event_org_type_created_idx').on(table.orgId, table.eventType, table.createdAt),
+    orgSourceStatusIdx: index('event_org_source_status_idx').on(table.orgId, table.eventSource, table.status),
+    // Idempotency: EventBridge → SQS is at-least-once, so the same state-change
+    // can be delivered twice. This partial unique index dedups re-deliveries
+    // (paired with `onConflictDoNothing` in reporting-service.ingestEvents).
+    // Partial (execution_id IS NOT NULL) because that's the natural per-event
+    // key; events without an executionId (rare) aren't deduped, which is safe.
+    // Includes pipeline_id so a (theoretical) execution-id reuse across pipelines
+    // can't collide now that the ARN is no longer part of the row.
+    //
+    // COALESCE the nullable parts to sentinels (expression index): PIPELINE/STAGE/
+    // BUILD events leave stage_name/action_name NULL (plugin-build also pipeline_id
+    // NULL), and Postgres treats NULLs as DISTINCT in a unique index — so the plain
+    // column index never matches for those types and onConflictDoNothing can't dedup
+    // their at-least-once re-deliveries. Collapsing NULL→'' makes equal events equal.
+    // (drizzle's uniqueIndex can't express NULLS NOT DISTINCT on a partial index, so
+    // we use the equivalent expression index.) MIGRATION REQUIRED: drizzle-kit generate.
+    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),
+    // DORA deploy-basis scan (Phase 1): deployment frequency / deploy-time CFR /
+    // lead time all group deploy-stage events by environment over a completed_at
+    // window. This composite serves that grouped org-scoped scan directly.
+    // MIGRATION REQUIRED: drizzle-kit generate.
+    orgEnvCompletedIdx: index('event_org_env_completed_idx')
+        .on(table.orgId, table.environment, table.completedAt),
+}));
+/**
+ * Manual post-deploy outcome markers (Phase 2). A user marks a deployment
+ * `failed` (production incident linked to a deploy) or `restored` (recovered).
+ * These feed the DORA post-deploy Change Failure Rate component and the real
+ * MTTR (restored − deployed). Correlated to a deploy execution by `executionId`.
+ *
+ * @table deployment_outcomes
+ */
+export const deploymentOutcome = pgTable('deployment_outcomes', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    executionId: varchar('execution_id', { length: 255 }).notNull(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    environment: varchar('environment', { length: 255 }),
+    outcome: varchar('outcome', { length: 20 }).$type().notNull(),
+    at: timestamp('at', { withTimezone: true }).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgEnvIdx: index('deployment_outcomes_org_env_idx').on(table.orgId, table.environment),
+    executionIdx: index('deployment_outcomes_execution_idx').on(table.executionId),
+    // Idempotent re-marking: one row per (execution, outcome). Re-posting the same
+    // outcome for a deploy is a no-op/refresh (onConflictDoUpdate the `at`), so a
+    // failed→restored pair is two rows while a duplicate POST doesn't double-count.
+    executionOutcomeUnique: uniqueIndex('deployment_outcomes_execution_outcome_unique')
+        .on(table.executionId, table.outcome),
+}));
+/**
+ * Per-org ingestion health (Phase 3). The AWS events Lambda periodically posts
+ * forwarded/dropped counters + the last event timestamp so the Reports UI can
+ * show whether events are flowing / stale / dropping. One row per org.
+ *
+ * @table ingest_health
+ */
+export const ingestHealth = pgTable('ingest_health', {
+    orgId: varchar('org_id', { length: 255 }).primaryKey(),
+    lastEventAt: timestamp('last_event_at', { withTimezone: true }),
+    forwarded: bigint('forwarded', { mode: 'number' }),
+    dropped: bigint('dropped', { mode: 'number' }),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+/**
+ * Production incidents ingested from the org's incident tooling (Phase 5). The
+ * user points their Alertmanager / PagerDuty / Datadog webhook at
+ * `POST /api/reports/incidents` (machine `reporting:ingest` scope). Each incident
+ * carries its external id, the affected `environment`, when it opened, and when
+ * it was resolved (nullable — a later resolve updates it). DORA correlates each
+ * incident to the most recent successful deploy to `environment` within
+ * `DORA_INCIDENT_WINDOW_HOURS`, turning it into an automated post-deploy failure
+ * (Change Failure Rate) and a real recovery time (`resolved_at − opened_at` MTTR).
+ * `incident_id` is UNIQUE per org so a resolve re-post is an idempotent upsert.
+ *
+ * @table incidents
+ */
+export const incident = pgTable('incidents', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    // External incident id from the source system (PagerDuty/Datadog/Alertmanager).
+    // Unique PER ORG (see incidentOrgUnique) — the idempotency + upsert key.
+    incidentId: varchar('incident_id', { length: 255 }).notNull(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    // Affected deploy environment (e.g. "production"). Correlated to a deploy env.
+    environment: varchar('environment', { length: 255 }).notNull(),
+    openedAt: timestamp('opened_at', { withTimezone: true }).notNull(),
+    // NULL while the incident is open; a later resolve webhook sets it (idempotent
+    // upsert). `resolved_at − opened_at` is the real MTTR for the correlated deploy.
+    resolvedAt: timestamp('resolved_at', { withTimezone: true }),
+    severity: varchar('severity', { length: 50 }).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    // Correlation scan: most-recent-deploy-before-open lookups group by (org, env)
+    // and range on opened_at.
+    orgEnvOpenedIdx: index('incidents_org_env_opened_idx').on(table.orgId, table.environment, table.openedAt),
+    // Idempotent upsert / dedup: one row per (org, incident_id). A resolve re-post
+    // updates resolved_at instead of inserting a duplicate.
+    orgIncidentUnique: uniqueIndex('incidents_org_incident_unique').on(table.orgId, table.incidentId),
+}));
+/**
+ * Per-org DORA computation + retention overrides. One row per org (org_id PK).
+ * `incidentWindowHours` (Phase 5b) overrides the global `DORA_INCIDENT_WINDOW_HOURS`
+ * used to correlate an ingested incident to the most recent successful deploy.
+ * `eventRetentionDays` / `doraRetentionDays` (Phase 7) override the global reporting
+ * retention windows for the split sweep — standard events (`environment IS NULL`)
+ * vs DORA source (deploy stages + `deployment_outcomes` + `incidents`). Any NULL /
+ * absent value falls back to its env default. Set self-serve by an org admin via
+ * `PUT /api/reports/settings/incidents`. This table is itself never purged.
+ *
+ * @table dora_settings
+ */
+export const doraSettings = pgTable('dora_settings', {
+    orgId: varchar('org_id', { length: 255 }).primaryKey(),
+    incidentWindowHours: integer('incident_window_hours'),
+    // Phase 7 retention overrides (days). NULL ⇒ use the global env default
+    // (REPORTING_EVENT_RETENTION_DAYS / REPORTING_DORA_RETENTION_DAYS).
+    eventRetentionDays: integer('event_retention_days'),
+    doraRetentionDays: integer('dora_retention_days'),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+//# 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 {\n  SYSTEM_ORG_ID, type Criticality, type EntityLabels, type EntityLink, type Lifecycle, type MetaDataType,\n  type OwnerType, type Visibility,\n} from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { bigint, 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  // Developer-portal catalog metadata (ownership / lifecycle / classification).\n  // ownerId defaults to the creating user (set at insert), so every pipeline has\n  // an owner for \"my services\" views; ownerType distinguishes user vs team.\n  ownerId: text('owner_id'),\n  ownerType: varchar('owner_type', { length: 10 }).$type<OwnerType>(),\n  lifecycle: varchar('lifecycle', { length: 20 })\n    .$type<Lifecycle>()\n    .default('production' as Lifecycle)\n    .notNull(),\n  criticality: varchar('criticality', { length: 10 }).$type<Criticality>(),\n  labels: jsonb('labels')\n    .$type<EntityLabels>()\n    .default({})\n    .notNull(),\n  links: jsonb('links')\n    .$type<EntityLink[]>()\n    .default([])\n    .notNull(),\n\n  // Access and visibility — the shared three-rung ladder (see api-core's\n  // `Visibility`): `private` is author-only (`created_by`), `org` is the whole\n  // owning org, `public` reaches the org's teams and — from the system org —\n  // every org. Constrained at the SQL layer too via a CHECK in postgres-init.sql\n  // so a typo can't sneak past the application layer.\n  visibility: varchar('visibility', { length: 10 })\n    .$type<Visibility>()\n    .default('private')\n    .notNull(),\n  isDefault: boolean('is_default')\n    .default(false)\n    .notNull(),\n  isActive: boolean('is_active')\n    .default(true)\n    .notNull(),\n\n  // Deletion tracking (soft delete)\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n  // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned\n  // rows once `purge_after` has passed (set on delete alongside deleted_at).\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // Partial index over just the tombstones — drives the retention purge sweep\n  // (`WHERE deleted_at IS NOT NULL AND purge_after < now`) without scanning live rows.\n  purgeIdx: index('pipeline_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\n  // Indexes for common queries\n  projectIdx: index('pipeline_project_idx').on(table.project),\n  // Developer-portal catalog indexes: \"my services\" (owner) + lifecycle filter.\n  ownerIdx: index('pipeline_owner_idx').on(table.orgId, table.ownerId),\n  lifecycleIdx: index('pipeline_lifecycle_idx').on(table.orgId, table.lifecycle),\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 + visibility + isActive)\n  orgVisibilityActiveIdx: index('pipeline_org_visibility_active_idx').on(table.orgId, table.visibility, table.isActive),\n  // Drives the \"my private drafts\" leg of the visibility predicate.\n  createdByIdx: index('pipeline_created_by_idx').on(table.orgId, table.createdBy),\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  // `pb.pipeline-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  // DORA true-lead-time attribution (Phase 4). The forwarder resolves the source\n  // commit range in-account and reports the OLDEST unshipped commit's timestamp\n  // + how many commits shipped. Both nullable — events whose source type/token\n  // can't be resolved leave them NULL and lead time reports `unknown`.\n  commitTimestamp: timestamp('commit_timestamp', { withTimezone: true }),\n  commitCount: integer('commit_count'),\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  // DORA deploy-basis scan (Phase 1): deployment frequency / deploy-time CFR /\n  // lead time all group deploy-stage events by environment over a completed_at\n  // window. This composite serves that grouped org-scoped scan directly.\n  // MIGRATION REQUIRED: drizzle-kit generate.\n  orgEnvCompletedIdx: index('event_org_env_completed_idx')\n    .on(table.orgId, table.environment, table.completedAt),\n}));\n\n/**\n * Manual post-deploy outcome markers (Phase 2). A user marks a deployment\n * `failed` (production incident linked to a deploy) or `restored` (recovered).\n * These feed the DORA post-deploy Change Failure Rate component and the real\n * MTTR (restored − deployed). Correlated to a deploy execution by `executionId`.\n *\n * @table deployment_outcomes\n */\nexport const deploymentOutcome = pgTable('deployment_outcomes', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  executionId: varchar('execution_id', { length: 255 }).notNull(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  environment: varchar('environment', { length: 255 }),\n  outcome: varchar('outcome', { length: 20 }).$type<'failed' | 'restored'>().notNull(),\n  at: timestamp('at', { withTimezone: true }).notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  orgEnvIdx: index('deployment_outcomes_org_env_idx').on(table.orgId, table.environment),\n  executionIdx: index('deployment_outcomes_execution_idx').on(table.executionId),\n  // Idempotent re-marking: one row per (execution, outcome). Re-posting the same\n  // outcome for a deploy is a no-op/refresh (onConflictDoUpdate the `at`), so a\n  // failed→restored pair is two rows while a duplicate POST doesn't double-count.\n  executionOutcomeUnique: uniqueIndex('deployment_outcomes_execution_outcome_unique')\n    .on(table.executionId, table.outcome),\n}));\n\n/**\n * Per-org ingestion health (Phase 3). The AWS events Lambda periodically posts\n * forwarded/dropped counters + the last event timestamp so the Reports UI can\n * show whether events are flowing / stale / dropping. One row per org.\n *\n * @table ingest_health\n */\nexport const ingestHealth = pgTable('ingest_health', {\n  orgId: varchar('org_id', { length: 255 }).primaryKey(),\n  lastEventAt: timestamp('last_event_at', { withTimezone: true }),\n  forwarded: bigint('forwarded', { mode: 'number' }),\n  dropped: bigint('dropped', { mode: 'number' }),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n});\n\n/**\n * Production incidents ingested from the org's incident tooling (Phase 5). The\n * user points their Alertmanager / PagerDuty / Datadog webhook at\n * `POST /api/reports/incidents` (machine `reporting:ingest` scope). Each incident\n * carries its external id, the affected `environment`, when it opened, and when\n * it was resolved (nullable — a later resolve updates it). DORA correlates each\n * incident to the most recent successful deploy to `environment` within\n * `DORA_INCIDENT_WINDOW_HOURS`, turning it into an automated post-deploy failure\n * (Change Failure Rate) and a real recovery time (`resolved_at − opened_at` MTTR).\n * `incident_id` is UNIQUE per org so a resolve re-post is an idempotent upsert.\n *\n * @table incidents\n */\nexport const incident = pgTable('incidents', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  // External incident id from the source system (PagerDuty/Datadog/Alertmanager).\n  // Unique PER ORG (see incidentOrgUnique) — the idempotency + upsert key.\n  incidentId: varchar('incident_id', { length: 255 }).notNull(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n  // Affected deploy environment (e.g. \"production\"). Correlated to a deploy env.\n  environment: varchar('environment', { length: 255 }).notNull(),\n  openedAt: timestamp('opened_at', { withTimezone: true }).notNull(),\n  // NULL while the incident is open; a later resolve webhook sets it (idempotent\n  // upsert). `resolved_at − opened_at` is the real MTTR for the correlated deploy.\n  resolvedAt: timestamp('resolved_at', { withTimezone: true }),\n  severity: varchar('severity', { length: 50 }).notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n}, (table) => ({\n  // Correlation scan: most-recent-deploy-before-open lookups group by (org, env)\n  // and range on opened_at.\n  orgEnvOpenedIdx: index('incidents_org_env_opened_idx').on(table.orgId, table.environment, table.openedAt),\n  // Idempotent upsert / dedup: one row per (org, incident_id). A resolve re-post\n  // updates resolved_at instead of inserting a duplicate.\n  orgIncidentUnique: uniqueIndex('incidents_org_incident_unique').on(table.orgId, table.incidentId),\n}));\n\n/**\n * Per-org DORA computation + retention overrides. One row per org (org_id PK).\n * `incidentWindowHours` (Phase 5b) overrides the global `DORA_INCIDENT_WINDOW_HOURS`\n * used to correlate an ingested incident to the most recent successful deploy.\n * `eventRetentionDays` / `doraRetentionDays` (Phase 7) override the global reporting\n * retention windows for the split sweep — standard events (`environment IS NULL`)\n * vs DORA source (deploy stages + `deployment_outcomes` + `incidents`). Any NULL /\n * absent value falls back to its env default. Set self-serve by an org admin via\n * `PUT /api/reports/settings/incidents`. This table is itself never purged.\n *\n * @table dora_settings\n */\nexport const doraSettings = pgTable('dora_settings', {\n  orgId: varchar('org_id', { length: 255 }).primaryKey(),\n  incidentWindowHours: integer('incident_window_hours'),\n  // Phase 7 retention overrides (days). NULL ⇒ use the global env default\n  // (REPORTING_EVENT_RETENTION_DAYS / REPORTING_DORA_RETENTION_DAYS).\n  eventRetentionDays: integer('event_retention_days'),\n  doraRetentionDays: integer('dora_retention_days'),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\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\nexport type DeploymentOutcome = typeof deploymentOutcome.$inferSelect;\nexport type DeploymentOutcomeInsert = typeof deploymentOutcome.$inferInsert;\n\nexport type IngestHealth = typeof ingestHealth.$inferSelect;\nexport type IngestHealthInsert = typeof ingestHealth.$inferInsert;\n\nexport type Incident = typeof incident.$inferSelect;\nexport type IncidentInsert = typeof incident.$inferInsert;\n\nexport type DoraSettings = typeof doraSettings.$inferSelect;\nexport type DoraSettingsInsert = typeof doraSettings.$inferInsert;\n\n/**\n * Helper types for working with partial updates\n */\nexport type PipelineUpdate = Partial<Omit<PipelineInsert, 'id' | 'createdAt' | 'createdBy'>>;\n"]}