@southwind-ai/database 0.1.0

package/src/schema/durable-jobs.ts

@@ -0,0 +1,266 @@
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  check,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const durableJobs = pgTable(
+  "durable_jobs",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    handlerKey: varchar("handler_key", { length: 160 }).notNull(),
+    queue: varchar("queue", { length: 80 }).notNull().default("default"),
+    status: varchar("status", { length: 32 }).notNull().default("queued"),
+    idempotencyKey: varchar("idempotency_key", { length: 160 }).notNull(),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+    priority: integer("priority").notNull().default(0),
+    requestedBy: varchar("requested_by", { length: 64 }).notNull(),
+    maxAttempts: integer("max_attempts").notNull().default(3),
+    timeoutSeconds: integer("timeout_seconds").notNull().default(900),
+    availableAt: timestamp("available_at", { withTimezone: true }).notNull(),
+    cancelRequestedAt: timestamp("cancel_requested_at", { withTimezone: true }),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_jobs_idempotency").on(
+      table.requestedBy,
+      table.handlerKey,
+      table.idempotencyKey,
+    ),
+    index("idx_durable_jobs_claim").on(
+      table.queue,
+      table.status,
+      table.availableAt,
+      table.priority,
+    ),
+    index("idx_durable_jobs_actor_created").on(
+      table.requestedBy,
+      table.createdAt,
+    ),
+    check("ck_durable_jobs_attempts", sql`${table.maxAttempts} > 0`),
+    check("ck_durable_jobs_timeout", sql`${table.timeoutSeconds} > 0`),
+  ],
+);
+
+export const durableJobStages = pgTable(
+  "durable_job_stages",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    key: varchar("key", { length: 160 }).notNull(),
+    ordinal: integer("ordinal").notNull(),
+    status: varchar("status", { length: 32 }).notNull().default("pending"),
+    currentAttempt: integer("current_attempt").notNull().default(0),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_job_stages_key").on(table.jobId, table.key),
+    uniqueIndex("uk_durable_job_stages_ordinal").on(table.jobId, table.ordinal),
+    check("ck_durable_job_stages_ordinal", sql`${table.ordinal} >= 0`),
+    check("ck_durable_job_stages_attempt", sql`${table.currentAttempt} >= 0`),
+  ],
+);
+
+export const durableJobAttempts = pgTable(
+  "durable_job_attempts",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    stageId: varchar("stage_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobStages.id, { onDelete: "restrict" }),
+    attemptNumber: integer("attempt_number").notNull(),
+    status: varchar("status", { length: 32 }).notNull().default("running"),
+    handlerKey: varchar("handler_key", { length: 160 }).notNull(),
+    workerId: varchar("worker_id", { length: 160 }).notNull(),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull(),
+    timeoutAt: timestamp("timeout_at", { withTimezone: true }).notNull(),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_job_attempts_number").on(
+      table.stageId,
+      table.attemptNumber,
+    ),
+    index("idx_durable_job_attempts_job").on(table.jobId, table.startedAt),
+    check("ck_durable_job_attempts_number", sql`${table.attemptNumber} > 0`),
+  ],
+);
+
+export const durableJobLeases = pgTable(
+  "durable_job_leases",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    stageId: varchar("stage_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobStages.id, { onDelete: "restrict" }),
+    attemptId: varchar("attempt_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobAttempts.id, { onDelete: "restrict" }),
+    workerId: varchar("worker_id", { length: 160 }).notNull(),
+    tokenHash: varchar("token_hash", { length: 64 }).notNull(),
+    fencingToken: integer("fencing_token").notNull(),
+    status: varchar("status", { length: 24 }).notNull().default("active"),
+    acquiredAt: timestamp("acquired_at", { withTimezone: true }).notNull(),
+    heartbeatAt: timestamp("heartbeat_at", { withTimezone: true }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    releasedAt: timestamp("released_at", { withTimezone: true }),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_job_leases_active_stage")
+      .on(table.stageId)
+      .where(sql`${table.status} = 'active'`),
+    index("idx_durable_job_leases_expiry").on(table.status, table.expiresAt),
+    check("ck_durable_job_leases_fencing", sql`${table.fencingToken} > 0`),
+  ],
+);
+
+export const durableJobProgress = pgTable(
+  "durable_job_progress",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    stageId: varchar("stage_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobStages.id, { onDelete: "restrict" }),
+    attemptId: varchar("attempt_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobAttempts.id, { onDelete: "restrict" }),
+    sequence: integer("sequence").notNull(),
+    completedUnits: integer("completed_units").notNull(),
+    totalUnits: integer("total_units"),
+    message: varchar("message", { length: 500 }),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    recordedAt: timestamp("recorded_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_job_progress_sequence").on(
+      table.attemptId,
+      table.sequence,
+    ),
+    index("idx_durable_job_progress_job").on(table.jobId, table.recordedAt),
+    check("ck_durable_job_progress_sequence", sql`${table.sequence} > 0`),
+    check(
+      "ck_durable_job_progress_completed",
+      sql`${table.completedUnits} >= 0`,
+    ),
+  ],
+);
+
+export const durableJobArtifacts = pgTable(
+  "durable_job_artifacts",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    stageId: varchar("stage_id", { length: 64 }).references(
+      () => durableJobStages.id,
+      { onDelete: "restrict" },
+    ),
+    kind: varchar("kind", { length: 80 }).notNull(),
+    artifactRef: varchar("artifact_ref", { length: 37 }).notNull(),
+    filename: varchar("filename", { length: 240 }).notNull(),
+    contentType: varchar("content_type", { length: 120 }).notNull(),
+    byteSize: integer("byte_size").notNull(),
+    sha256: varchar("sha256", { length: 64 }).notNull(),
+    ownerId: varchar("owner_id", { length: 64 }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_job_artifacts_kind").on(table.jobId, table.kind),
+    index("idx_durable_job_artifacts_expiry").on(table.expiresAt),
+    check("ck_durable_job_artifacts_size", sql`${table.byteSize} >= 0`),
+  ],
+);
+
+export const durableJobFailures = pgTable(
+  "durable_job_failures",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    stageId: varchar("stage_id", { length: 64 }).references(
+      () => durableJobStages.id,
+      { onDelete: "restrict" },
+    ),
+    attemptId: varchar("attempt_id", { length: 64 }).references(
+      () => durableJobAttempts.id,
+      { onDelete: "restrict" },
+    ),
+    code: varchar("code", { length: 120 }).notNull(),
+    message: text("message").notNull(),
+    retryable: boolean("retryable").notNull(),
+    details: jsonb("details").$type<Record<string, unknown>>(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    index("idx_durable_job_failures_job").on(table.jobId, table.occurredAt),
+  ],
+);
+
+export const durableJobRecoveries = pgTable(
+  "durable_job_recoveries",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    jobId: varchar("job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    fromStatus: varchar("from_status", { length: 32 }).notNull(),
+    requestedBy: varchar("requested_by", { length: 64 }).notNull(),
+    reason: varchar("reason", { length: 500 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 160 }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_durable_job_recoveries_idempotency").on(
+      table.jobId,
+      table.idempotencyKey,
+    ),
+    index("idx_durable_job_recoveries_job").on(table.jobId, table.createdAt),
+  ],
+);

package/src/schema/file-storage.ts

@@ -0,0 +1,94 @@
+import {
+  bigint,
+  index,
+  integer,
+  pgTable,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const fileUploadSessions = pgTable(
+  "file_upload_sessions",
+  {
+    id: varchar("id", { length: 40 }).primaryKey(),
+    ownerId: varchar("owner_id", { length: 64 }).notNull(),
+    purpose: varchar("purpose", { length: 80 }).notNull(),
+    filename: varchar("filename", { length: 240 }).notNull(),
+    extension: varchar("extension", { length: 24 }).notNull(),
+    mimeType: varchar("mime_type", { length: 120 }).notNull(),
+    expectedByteSize: bigint("expected_byte_size", {
+      mode: "number",
+    }).notNull(),
+    expectedSha256: varchar("expected_sha256", { length: 64 }),
+    receivedByteSize: bigint("received_byte_size", { mode: "number" })
+      .notNull()
+      .default(0),
+    nextPartNumber: integer("next_part_number").notNull().default(0),
+    status: varchar("status", { length: 24 }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    fileExpiresAt: timestamp("file_expires_at", { withTimezone: true }),
+    fileId: varchar("file_id", { length: 40 }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    index("idx_file_upload_sessions_owner_created").on(
+      table.ownerId,
+      table.createdAt,
+    ),
+    index("idx_file_upload_sessions_expiry").on(table.status, table.expiresAt),
+  ],
+);
+
+export const fileUploadParts = pgTable(
+  "file_upload_parts",
+  {
+    sessionId: varchar("session_id", { length: 40 })
+      .notNull()
+      .references(() => fileUploadSessions.id, { onDelete: "cascade" }),
+    partNumber: integer("part_number").notNull(),
+    byteOffset: bigint("byte_offset", { mode: "number" }).notNull(),
+    artifactRef: varchar("artifact_ref", { length: 37 }).notNull(),
+    byteSize: bigint("byte_size", { mode: "number" }).notNull(),
+    sha256: varchar("sha256", { length: 64 }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_file_upload_parts_session_part").on(
+      table.sessionId,
+      table.partNumber,
+    ),
+    uniqueIndex("uk_file_upload_parts_artifact_ref").on(table.artifactRef),
+  ],
+);
+
+export const fileMetadata = pgTable(
+  "file_metadata",
+  {
+    id: varchar("id", { length: 40 }).primaryKey(),
+    ownerId: varchar("owner_id", { length: 64 }).notNull(),
+    purpose: varchar("purpose", { length: 80 }).notNull(),
+    filename: varchar("filename", { length: 240 }).notNull(),
+    extension: varchar("extension", { length: 24 }).notNull(),
+    mimeType: varchar("mime_type", { length: 120 }).notNull(),
+    artifactRef: varchar("artifact_ref", { length: 37 }).notNull(),
+    byteSize: bigint("byte_size", { mode: "number" }).notNull(),
+    sha256: varchar("sha256", { length: 64 }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_file_metadata_artifact_ref").on(table.artifactRef),
+    index("idx_file_metadata_owner_created").on(table.ownerId, table.createdAt),
+    index("idx_file_metadata_expiry").on(table.expiresAt),
+  ],
+);

package/src/schema/governance.ts

@@ -0,0 +1,204 @@
+// @windy-module system.license begin
+import { sql } from "drizzle-orm";
+import { timestamp as licenseTimestamp } from "drizzle-orm/pg-core";
+import { idColumn as licenseIdColumn } from "./common.js";
+// @windy-module system.license end
+// @windy-module system.audit begin
+import { timestamp as auditTimestamp } from "drizzle-orm/pg-core";
+import { idColumn as auditIdColumn } from "./common.js";
+// @windy-module system.audit end
+import {
+  boolean,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  // @windy-module system.license begin
+  uniqueIndex,
+  // @windy-module system.license end
+  varchar,
+} from "drizzle-orm/pg-core";
+import { auditColumns, statusColumn } from "./common.js";
+
+export const featureFlags = pgTable(
+  "feature_flags",
+  {
+    key: varchar("key", { length: 160 }).primaryKey(),
+    module: varchar("module", { length: 96 }).notNull(),
+    label: varchar("label", { length: 120 }).notNull(),
+    description: text("description"),
+    enabled: boolean("enabled").notNull().default(false),
+    visible: varchar("visible", { length: 32 }).notNull().default("visible"),
+    stage: varchar("stage", { length: 32 }).notNull().default("stable"),
+    // 旧布尔列仅为迁移兼容保留；正式 Guard 只读取 licenseKey 对应的 Entitlement。
+    licenseRequired: boolean("license_required").notNull().default(false),
+    licenseKey: varchar("license_key", { length: 160 }),
+    allowedLicenseVersions: jsonb("allowed_license_versions").$type<string[]>(),
+    dependencies: jsonb("dependencies").$type<string[]>(),
+    status: statusColumn().notNull().default("active"),
+    ...auditColumns,
+  },
+  (table) => [
+    index("idx_feature_flags_module").on(table.module),
+    index("idx_feature_flags_license").on(table.licenseKey),
+  ],
+);
+
+// @windy-module system.license begin
+export const licenseOperators = pgTable(
+  "license_operators",
+  {
+    id: licenseIdColumn().primaryKey(),
+    username: varchar("username", { length: 80 }).notNull(),
+    displayName: varchar("display_name", { length: 120 }).notNull(),
+    tokenHash: varchar("token_hash", { length: 128 }),
+    passwordHash: text("password_hash"),
+    role: varchar("role", { length: 40 }).notNull().default("readonly"),
+    permissions: jsonb("permissions").$type<string[]>().notNull(),
+    status: statusColumn().notNull(),
+    lastUsedAt: licenseTimestamp("last_used_at", { withTimezone: true }),
+    createdAt: licenseTimestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: licenseTimestamp("updated_at", { withTimezone: true }),
+    updatedBy: varchar("updated_by", { length: 64 }),
+    disabledAt: licenseTimestamp("disabled_at", { withTimezone: true }),
+    disabledBy: varchar("disabled_by", { length: 64 }),
+  },
+  (table) => [
+    uniqueIndex("uk_license_operators_username").on(table.username),
+    index("idx_license_operators_status").on(table.status),
+  ],
+);
+
+export const licenseOperatorSessions = pgTable(
+  "license_operator_sessions",
+  {
+    id: licenseIdColumn().primaryKey(),
+    operatorId: varchar("operator_id", { length: 64 })
+      .notNull()
+      .references(() => licenseOperators.id, { onDelete: "restrict" }),
+    tokenHash: varchar("token_hash", { length: 128 }).notNull(),
+    status: statusColumn().notNull().default("active"),
+    issuedAt: licenseTimestamp("issued_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    expiresAt: licenseTimestamp("expires_at", { withTimezone: true }).notNull(),
+    revokedAt: licenseTimestamp("revoked_at", { withTimezone: true }),
+    lastSeenAt: licenseTimestamp("last_seen_at", { withTimezone: true }),
+    ip: varchar("ip", { length: 80 }),
+    userAgent: text("user_agent"),
+  },
+  (table) => [
+    uniqueIndex("uk_license_operator_sessions_token_hash").on(table.tokenHash),
+    index("idx_license_operator_sessions_operator").on(table.operatorId),
+    index("idx_license_operator_sessions_status").on(table.status),
+    index("idx_license_operator_sessions_expires").on(table.expiresAt),
+  ],
+);
+
+export const licenseKeys = pgTable(
+  "license_keys",
+  {
+    id: licenseIdColumn().primaryKey(),
+    keyId: varchar("key_id", { length: 160 }).notNull(),
+    publicKeyPem: text("public_key_pem").notNull(),
+    algorithm: varchar("algorithm", { length: 40 })
+      .notNull()
+      .default("ED25519"),
+    status: statusColumn().notNull(),
+    rotatedFromKeyId: varchar("rotated_from_key_id", { length: 160 }),
+    createdAt: licenseTimestamp("created_at", { withTimezone: true }).notNull(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+    retiredAt: licenseTimestamp("retired_at", { withTimezone: true }),
+    retiredBy: varchar("retired_by", { length: 64 }),
+    retainUntil: licenseTimestamp("retain_until", { withTimezone: true }),
+  },
+  (table) => [
+    uniqueIndex("uk_license_keys_key_id").on(table.keyId),
+    uniqueIndex("uk_license_keys_single_active")
+      .on(table.status)
+      .where(sql`${table.status} = 'active'`),
+    index("idx_license_keys_status").on(table.status),
+  ],
+);
+
+export const licenseKeyCompatibilities = pgTable(
+  "license_key_compatibilities",
+  {
+    id: licenseIdColumn().primaryKey(),
+    productCode: varchar("product_code", { length: 120 }).notNull(),
+    softwareVersion: varchar("software_version", { length: 80 }).notNull(),
+    publicKeyId: varchar("public_key_id", { length: 160 })
+      .notNull()
+      .references(() => licenseKeys.keyId, { onDelete: "restrict" }),
+    declaredAt: licenseTimestamp("declared_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    declaredBy: varchar("declared_by", { length: 64 }).notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_license_key_compatibility").on(
+      table.productCode,
+      table.softwareVersion,
+      table.publicKeyId,
+    ),
+    index("idx_license_key_compatibility_version").on(
+      table.productCode,
+      table.softwareVersion,
+    ),
+    index("idx_license_key_compatibility_key").on(table.publicKeyId),
+  ],
+);
+
+export const licenseGovernanceEvents = pgTable(
+  "license_governance_events",
+  {
+    id: licenseIdColumn().primaryKey(),
+    type: varchar("type", { length: 100 }).notNull(),
+    resourceType: varchar("resource_type", { length: 80 }).notNull(),
+    resourceId: varchar("resource_id", { length: 160 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    occurredAt: licenseTimestamp("occurred_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+  },
+  (table) => [
+    index("idx_license_governance_resource_time").on(
+      table.resourceType,
+      table.resourceId,
+      table.occurredAt,
+    ),
+    index("idx_license_governance_type_time").on(table.type, table.occurredAt),
+    index("idx_license_governance_actor_time").on(
+      table.actorId,
+      table.occurredAt,
+    ),
+  ],
+);
+// @windy-module system.license end
+
+// @windy-module system.audit begin
+export const auditLogs = pgTable(
+  "audit_logs",
+  {
+    id: auditIdColumn().primaryKey(),
+    actorId: varchar("actor_id", { length: 64 }),
+    action: varchar("action", { length: 120 }).notNull(),
+    resource: varchar("resource", { length: 160 }).notNull(),
+    resourceId: varchar("resource_id", { length: 160 }),
+    ip: varchar("ip", { length: 64 }),
+    userAgent: text("user_agent"),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+    createdAt: auditTimestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    index("idx_audit_logs_actor").on(table.actorId),
+    index("idx_audit_logs_resource").on(table.resource, table.resourceId),
+    index("idx_audit_logs_created").on(table.createdAt),
+  ],
+);
+// @windy-module system.audit end

package/src/schema/governed-exports.ts

@@ -0,0 +1,90 @@
+import { sql } from "drizzle-orm";
+import type { LifecycleStatus } from "@southwind-ai/shared";
+import {
+  boolean,
+  check,
+  index,
+  jsonb,
+  pgTable,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type { GovernedExportScopeSnapshot } from "./common.js";
+import { durableJobs } from "./durable-jobs.js";
+
+export interface GovernedExportQuerySnapshot {
+  q?: string;
+  status?: LifecycleStatus;
+  includeDeleted: boolean;
+  sort?: Array<{ field: string; order: "asc" | "desc" }>;
+}
+
+export const governedExportRequests = pgTable(
+  "governed_export_requests",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    resourceType: varchar("resource_type", { length: 160 }).notNull(),
+    policyKey: varchar("policy_key", { length: 160 }).notNull(),
+    policyVersion: varchar("policy_version", { length: 40 }).notNull(),
+    fieldKeys: jsonb("field_keys").$type<string[]>().notNull(),
+    requesterId: varchar("requester_id", { length: 64 }).notNull(),
+    requesterName: varchar("requester_name", { length: 160 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 160 }).notNull(),
+    requestFingerprint: varchar("request_fingerprint", {
+      length: 64,
+    }).notNull(),
+    reason: varchar("reason", { length: 500 }).notNull(),
+    scopeSnapshot: jsonb("scope_snapshot")
+      .$type<GovernedExportScopeSnapshot>()
+      .notNull(),
+    scopeHash: varchar("scope_hash", { length: 64 }).notNull(),
+    querySnapshot: jsonb("query_snapshot")
+      .$type<GovernedExportQuerySnapshot>()
+      .notNull(),
+    status: varchar("status", { length: 32 }).notNull(),
+    approvalRequired: boolean("approval_required").notNull(),
+    approvalId: varchar("approval_id", { length: 64 }),
+    durableJobId: varchar("durable_job_id", { length: 64 }).references(
+      () => durableJobs.id,
+      { onDelete: "restrict" },
+    ),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_governed_exports_idempotency").on(
+      table.requesterId,
+      table.resourceType,
+      table.idempotencyKey,
+    ),
+    uniqueIndex("uk_governed_exports_job")
+      .on(table.durableJobId)
+      .where(sql`${table.durableJobId} is not null`),
+    index("idx_governed_exports_owner_created").on(
+      table.requesterId,
+      table.createdAt,
+    ),
+    index("idx_governed_exports_expiry").on(table.status, table.expiresAt),
+    check(
+      "ck_governed_exports_status",
+      sql`${table.status} in ('pending-approval', 'queued', 'running', 'succeeded', 'failed', 'cancelled', 'rejected')`,
+    ),
+    check(
+      "ck_governed_exports_scope_hash",
+      sql`${table.scopeHash} ~ '^[0-9a-f]{64}$'`,
+    ),
+    check(
+      "ck_governed_exports_approval_job_state",
+      sql`(${table.approvalRequired} or ${table.approvalId} is null)
+        and (${table.status} <> 'pending-approval' or (${table.approvalRequired} and ${table.durableJobId} is null))
+        and (${table.status} not in ('running', 'succeeded') or ${table.durableJobId} is not null)
+        and (${table.durableJobId} is null or not ${table.approvalRequired} or ${table.approvalId} is not null)`,
+    ),
+  ],
+);