@sixb/pg 0.1.12 → 0.1.14

package/src/index.ts

@@ -42,6 +42,7 @@ import { PgAiLimitStorage } from "./pg-ai-limit-storage"
 import { PgAiUsageStorage } from "./pg-ai-usage-storage"
 import { createPgClient, type SQL, type SQLClient } from "./pg-client"
 import { PgExecutionStorage } from "./pg-execution-storage"
+import { PgFileUploadSessionStorage } from "./pg-file-upload-session-storage"
 import { PgPipelineRunStorage } from "./pg-pipeline-run-storage"
 import { PgProjectionRunStorage } from "./pg-projection-run-storage"
 import { PgRulesStorage } from "./pg-rules-storage"
@@ -158,6 +159,7 @@ export class PostgresStorage implements MigrationCapableStorage {
   readonly connectorConnections: PgConnectorConnectionStorage
   readonly shareGrants: PgShareGrantStorage
   readonly shareSessions: PgShareSessionStorage
+  readonly fileUploadSessions: PgFileUploadSessionStorage
   readonly migrators: readonly StorageMigrator[]
 
   private readonly sql: SQL
@@ -235,6 +237,7 @@ export class PostgresStorage implements MigrationCapableStorage {
     this.connectorConnections = createOperationScopedFacade(stores.connectorConnections, scope)
     this.shareGrants = createOperationScopedFacade(stores.shareGrants, scope)
     this.shareSessions = createOperationScopedFacade(stores.shareSessions, scope)
+    this.fileUploadSessions = createOperationScopedFacade(stores.fileUploadSessions, scope)
     registerPostgresStorageTestingAdapter(this, (durationMs) =>
       stores.connectorConnections.advanceTimeForTesting(durationMs)
     )
@@ -371,6 +374,7 @@ function createPostgresStores(
     connectorConnections: new PgConnectorConnectionStorage(sql),
     shareGrants,
     shareSessions,
+    fileUploadSessions: new PgFileUploadSessionStorage(sql),
   }
 }
 
@@ -395,6 +399,7 @@ interface PostgresStoreSet {
   readonly connectorConnections: PgConnectorConnectionStorage
   readonly shareGrants: PgShareGrantStorage
   readonly shareSessions: PgShareSessionStorage
+  readonly fileUploadSessions: PgFileUploadSessionStorage
 }
 
 function resolveTimeoutMillis(value: number | undefined, label: string): number | undefined {

package/src/migrations/046-workflow-intervention-principals.sql

@@ -0,0 +1,15 @@
+-- Intervention actors were stored as { principalType, principalId }. Rewrite them to the
+-- canonical Principal shape { type, id } used by every other stored principal.
+UPDATE workflow_interventions
+SET submitted_by = jsonb_build_object(
+  'type', submitted_by->>'principalType',
+  'id', submitted_by->>'principalId'
+)
+WHERE submitted_by->>'principalType' IS NOT NULL;
+
+UPDATE workflow_interventions
+SET cancelled_by = jsonb_build_object(
+  'type', cancelled_by->>'principalType',
+  'id', cancelled_by->>'principalId'
+)
+WHERE cancelled_by->>'principalType' IS NOT NULL;

package/src/migrations/047-ontology-commit-attribution.sql

@@ -0,0 +1,50 @@
+-- Commits and their events name who requested the write and what ran it, replacing the
+-- authority-only `actor`. Both are copied from the commit's execution, which stays canonical and
+-- is immutable, so the backfill is exact.
+ALTER TABLE ontology_commits
+  ADD COLUMN requested_by JSONB,
+  ADD COLUMN executor JSONB;
+
+UPDATE ontology_commits c SET
+  requested_by = CASE
+    WHEN e.requested_by_user_id IS NOT NULL
+      THEN jsonb_build_object('type', 'user', 'id', e.requested_by_user_id)
+    WHEN e.requested_by_service_account_id IS NOT NULL
+      THEN jsonb_build_object('type', 'serviceAccount', 'id', e.requested_by_service_account_id)
+  END,
+  executor = CASE e.executor_kind
+    WHEN 'request' THEN jsonb_build_object('type', 'request', 'requestId', e.executor_id)
+    WHEN 'agent' THEN jsonb_build_object('type', 'agent', 'runId', e.executor_id)
+    WHEN 'kernel' THEN jsonb_build_object(
+      'type', 'kernel',
+      'operation',
+      CASE e.authority_kernel_operation
+        WHEN 'ontology.recover'
+          THEN jsonb_build_object('type', 'ontology.recover', 'recoveryId', e.executor_id)
+        ELSE jsonb_build_object('type', 'ontology.indexVectors', 'indexingId', e.executor_id)
+      END
+    )
+    ELSE jsonb_build_object(
+      'type', 'primitive',
+      'kind', e.executor_kind,
+      'id', e.authority_primitive_id,
+      'runId', e.executor_id
+    )
+  END
+FROM executions e
+WHERE e.project_id = c.project_id AND e.id = c.execution_id;
+
+ALTER TABLE ontology_commits ALTER COLUMN executor SET NOT NULL;
+
+-- Events not yet published would otherwise reach consumers in the retired shape.
+UPDATE ontology_outbox o SET envelope =
+  (o.envelope - 'actor')
+  || jsonb_build_object('executor', c.executor)
+  || CASE
+    WHEN c.requested_by IS NULL THEN '{}'::jsonb
+    ELSE jsonb_build_object('requestedBy', c.requested_by)
+  END
+FROM ontology_commits c
+WHERE c.project_id = o.project_id AND c.id = o.commit_id;
+
+ALTER TABLE ontology_commits DROP COLUMN actor;

package/src/migrations/048-file-upload-sessions.sql

@@ -0,0 +1,34 @@
+-- Durable staged-upload sessions, so an upload survives restarts and spans API replicas.
+CREATE TABLE file_upload_sessions (
+  id TEXT PRIMARY KEY CHECK (length(trim(id)) > 0),
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  owner_principal_type TEXT NOT NULL
+    CHECK (owner_principal_type IN ('user', 'serviceAccount', 'system')),
+  owner_principal_id TEXT NOT NULL CHECK (length(owner_principal_id) > 0),
+  strategy TEXT NOT NULL CHECK (strategy IN ('server', 'direct-put', 'multipart')),
+  status TEXT NOT NULL CHECK (status IN ('pending', 'completed', 'aborted')),
+  file_name TEXT,
+  media_type TEXT,
+  logical_path TEXT,
+  expected_size_bytes BIGINT CHECK (expected_size_bytes IS NULL OR expected_size_bytes >= 0),
+  expected_digest TEXT,
+  provider_upload JSONB CHECK (provider_upload IS NULL OR jsonb_typeof(provider_upload) = 'object'),
+  signed_parts JSONB NOT NULL CHECK (jsonb_typeof(signed_parts) = 'array'),
+  file_ref JSONB CHECK (file_ref IS NULL OR jsonb_typeof(file_ref) = 'object'),
+  created_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  completed_at TIMESTAMPTZ,
+  aborted_at TIMESTAMPTZ,
+  -- Derived by core (fileUploadSessionReapAt); NULL while an abandoned upload awaits its abort.
+  reap_at TIMESTAMPTZ,
+  CHECK ((status = 'completed') = (completed_at IS NOT NULL)),
+  CHECK ((status = 'aborted') = (aborted_at IS NOT NULL))
+);
+
+CREATE INDEX idx_file_upload_sessions_reap
+  ON file_upload_sessions (reap_at)
+  WHERE reap_at IS NOT NULL;
+
+CREATE INDEX idx_file_upload_sessions_abandoned
+  ON file_upload_sessions (project_id, expires_at)
+  WHERE status = 'pending' AND provider_upload IS NOT NULL;

package/src/migrations/049-native-sessions.sql

@@ -0,0 +1,19 @@
+-- Native clients, such as the CLI, hold their session as bearer tokens: a
+-- short-lived access token, whose hash is `token_hash`, and a rotating refresh token. Browser
+-- sessions leave these columns NULL; `refresh_token_hash IS NULL` is what marks a cookie session.
+ALTER TABLE auth_sessions
+  ADD COLUMN client_name TEXT,
+  ADD COLUMN access_expires_at TIMESTAMPTZ,
+  ADD COLUMN refresh_token_hash TEXT,
+  ADD COLUMN previous_refresh_token_hash TEXT,
+  ADD COLUMN refreshed_at TIMESTAMPTZ,
+  ADD CONSTRAINT auth_sessions_bearer_state CHECK (
+    (refresh_token_hash IS NULL) = (client_name IS NULL)
+    AND (refresh_token_hash IS NULL) = (access_expires_at IS NULL)
+    AND (refresh_token_hash IS NOT NULL OR previous_refresh_token_hash IS NULL)
+  );
+
+-- The device flow now starts a session instead of issuing a personal access token.
+ALTER TABLE auth_device_authorizations
+  DROP COLUMN token_name,
+  DROP COLUMN token_expires_at;

package/src/migrations/050-directory-group-memberships.sql

@@ -0,0 +1,5 @@
+-- A membership the identity provider owns is recorded with source 'directory' and synced to the
+-- provider's groups on every sign-in. Service accounts never sign in, so their table is unchanged.
+ALTER TABLE auth_group_memberships DROP CONSTRAINT auth_group_memberships_source_check;
+ALTER TABLE auth_group_memberships ADD CONSTRAINT auth_group_memberships_source_check
+  CHECK (source IN ('invitation', 'manual', 'agent', 'directory'));

package/src/migrations.ts

@@ -99,6 +99,16 @@ import vectorBatchingSql from "./migrations/044-vector-batching.sql" with { type
 import agentThreadSandboxStateSql from "./migrations/045-agent-thread-sandbox-state.sql" with {
   type: "text",
 }
+import workflowInterventionPrincipalsSql from "./migrations/046-workflow-intervention-principals.sql" with {
+  type: "text",
+}
+import ontologyCommitAttributionSql from "./migrations/047-ontology-commit-attribution.sql" with {
+  type: "text",
+}
+import nativeSessionsSql from "./migrations/049-native-sessions.sql" with { type: "text" }
+import directoryGroupMembershipsSql from "./migrations/050-directory-group-memberships.sql" with {
+  type: "text",
+}
 import type { SQL, SQLClient } from "./pg-client"
 
 export interface PostgresMigrationContext {
@@ -397,6 +407,11 @@ export const postgresStorageMigrations = defineMigrations<PostgresMigrationConte
     pgSql("043-vector-indexing", vectorIndexingSql),
     pgSql("044-vector-batching", vectorBatchingSql),
     pgSql("045-agent-thread-sandbox-state", agentThreadSandboxStateSql),
+    pgSql("046-workflow-intervention-principals", workflowInterventionPrincipalsSql),
+    pgSql("047-ontology-commit-attribution", ontologyCommitAttributionSql),
+    pgSql("048-file-upload-sessions", fileUploadSessionsSql),
+    pgSql("049-native-sessions", nativeSessionsSql),
+    pgSql("050-directory-group-memberships", directoryGroupMembershipsSql),
   ],
 })
 
@@ -420,3 +435,4 @@ import outboxPublicationOrderSql from "./migrations/038-outbox-publication-order
 import connectorOptionalPkceSql from "./migrations/040-connector-optional-pkce.sql" with {
   type: "text",
 }
+import fileUploadSessionsSql from "./migrations/048-file-upload-sessions.sql" with { type: "text" }

package/src/objects/storage.ts

@@ -88,6 +88,8 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     decimal: { equality: true, ordering: true },
     date: { equality: true, ordering: true },
     timestamp: { equality: true, ordering: true },
+    // jsonb equality and containment compare both fields of `{ type, id }`, whatever key order.
+    userRef: { equality: true },
   },
   limits: {
     totalCount: true,

package/src/ontology-storage/materializations.ts

@@ -1,8 +1,4 @@
-import type {
-  EffectiveChangeCounts,
-  ExpectedLinkRevision,
-  ExpectedObjectRevision,
-} from "@sixb/core/internal/materialization"
+import type { EffectiveChangeCounts } from "@sixb/core/internal/materialization"
 import {
   assertPinnedDatasetWatermark,
   linkRefKey,
@@ -16,6 +12,9 @@ import {
   telemetryPointSortKey,
 } from "@sixb/core/internal/materialization"
 import {
+  assertExpectedLinkRevision,
+  assertExpectedLinkScopeRevision,
+  assertExpectedObjectRevision,
   assertMaterializationFinalizationCorrelation,
   assertMaterializationHeader,
   assertMaterializationLaneCompletion,
@@ -126,23 +125,21 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
         true
       )
       for (const expected of input.expected.objects) {
-        this.assertObject(objectRevisions.get(objectRefKey(expected.ref)) ?? null, expected)
+        assertExpectedObjectRevision(
+          objectRevisions.get(objectRefKey(expected.ref)) ?? null,
+          expected
+        )
       }
       const linkRevisions = await reader.effectiveLinkLastCommits(
         input.expected.links.map((expected) => expected.ref),
         true
       )
       for (const expected of input.expected.links) {
-        this.assertLink(linkRevisions.get(linkRefKey(expected.ref)), expected)
+        assertExpectedLinkRevision(linkRevisions.get(linkRefKey(expected.ref)), expected)
       }
       const linkScopeRevisions = await reader.linkScopeRevisions(input.expected.linkScopes)
       for (const [index, expected] of input.expected.linkScopes.entries()) {
-        if (linkScopeRevisions[index]?.fingerprint !== expected.fingerprint) {
-          throw new MaterializationConflictError(
-            "effective-state",
-            `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`
-          )
-        }
+        assertExpectedLinkScopeRevision(linkScopeRevisions[index]?.fingerprint, expected)
       }
       const points = await reader.exactPoints(input.expected.points, true)
       const pointRevisions = new Map(
@@ -514,48 +511,6 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     }
   }
 
-  private assertObject(
-    row: { readonly version: number; readonly lastCommitId: string | null } | null,
-    expected: ExpectedObjectRevision
-  ): void {
-    if (!expected.exists) {
-      if (row) {
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected object ${objectRefKey(expected.ref)} to be absent.`
-        )
-      }
-      return
-    }
-    if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        `Expected object ${objectRefKey(expected.ref)} changed.`
-      )
-    }
-  }
-
-  private assertLink(
-    lastCommitId: string | null | undefined,
-    expected: ExpectedLinkRevision
-  ): void {
-    if (!expected.exists) {
-      if (lastCommitId !== undefined) {
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected link ${linkRefKey(expected.ref)} to be absent.`
-        )
-      }
-      return
-    }
-    if (lastCommitId === undefined || lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        `Expected link ${linkRefKey(expected.ref)} changed.`
-      )
-    }
-  }
-
   private async assertFinalization(
     session: PgMaterializationSessionState,
     input: FinalizeMaterializationInput
@@ -873,18 +828,20 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
   ): Promise<OntologyCommitRecord> {
     const { commit } = header
     const origin = originColumns(commit.origin)
-    const actor = commit.actor === undefined ? null : jsonParameter(this.sql, commit.actor)
+    const requestedBy =
+      commit.requestedBy === undefined ? null : jsonParameter(this.sql, commit.requestedBy)
     const rows = await this.sql<PgOntologyCommitRow[]>`
       INSERT INTO ontology_commits (
         project_id, id, idempotency_key, request_hash, execution_id,
-        origin_kind, origin_run_id, origin_batch_ordinal, origin, actor,
+        origin_kind, origin_run_id, origin_batch_ordinal, origin, requested_by, executor,
         ontology_revision, projection_revision, ownership_hash,
         intent, result, committed_at
       ) VALUES (
         ${commit.projectId}, ${commit.id}, ${commit.idempotencyKey}, ${commit.requestHash},
         ${commit.executionId},
         ${origin.kind}, ${origin.runId}, ${origin.batchOrdinal},
-        ${jsonParameter(this.sql, commit.origin)}, ${actor}, ${commit.ontologyRevision},
+        ${jsonParameter(this.sql, commit.origin)}, ${requestedBy},
+        ${jsonParameter(this.sql, commit.executor)}, ${commit.ontologyRevision},
         ${commit.projectionRevision ?? null}, ${commit.ownershipHash ?? null},
         ${jsonParameter(this.sql, commit.intent)},
         ${jsonParameter(this.sql, input.finalization.result)}, ${commit.committedAt}

package/src/ontology-storage/shared.ts

@@ -39,7 +39,8 @@ export interface PgOntologyCommitRow {
   readonly origin_run_id: string | null
   readonly origin_batch_ordinal: number | string | null
   readonly origin: unknown
-  readonly actor: unknown | null
+  readonly requested_by: unknown | null
+  readonly executor: unknown
   readonly ontology_revision: string
   readonly projection_revision: string | null
   readonly ownership_hash: string | null
@@ -187,11 +188,14 @@ export function commitRecord(row: PgOntologyCommitRow): OntologyCommitRecord {
     requestHash: row.request_hash,
     executionId: row.execution_id,
     origin: structuredClone(row.origin) as OntologyCommitWrite["origin"],
-    ...(row.actor === null
+    ...(row.requested_by === null
       ? {}
       : {
-          actor: structuredClone(row.actor) as NonNullable<OntologyCommitWrite["actor"]>,
+          requestedBy: structuredClone(row.requested_by) as NonNullable<
+            OntologyCommitWrite["requestedBy"]
+          >,
         }),
+    executor: structuredClone(row.executor) as OntologyCommitWrite["executor"],
     ontologyRevision: row.ontology_revision,
     ...(row.projection_revision === null ? {} : { projectionRevision: row.projection_revision }),
     ...(row.ownership_hash === null ? {} : { ownershipHash: row.ownership_hash }),

package/src/pg-file-upload-session-storage.ts

@@ -0,0 +1,143 @@
+import {
+  DurableFileUploadSessions,
+  type FileUploadSessionPersistence,
+  type FileUploadSessionPersistenceBackend,
+  fileUploadSessionReapAt,
+  parseFileUploadSessionRow,
+} from "@sixb/core/internal/file-upload-session-storage-provider"
+import type { FileUploadSession, ListAbandonedFileUploadSessionsInput } from "@sixb/core/storage"
+import { type PgStoreClient, runPgTransaction } from "./transactions"
+
+export class PgFileUploadSessionStorage extends DurableFileUploadSessions {
+  constructor(sql: PgStoreClient) {
+    super(new PgFileUploadSessionBackend(sql))
+  }
+}
+
+class PgFileUploadSessionBackend implements FileUploadSessionPersistenceBackend {
+  constructor(private readonly sql: PgStoreClient) {}
+
+  read<T>(run: (persistence: FileUploadSessionPersistence) => Promise<T>): Promise<T> {
+    return run(new PgFileUploadSessionPersistence(this.sql, false))
+  }
+
+  transaction<T>(run: (persistence: FileUploadSessionPersistence) => Promise<T>): Promise<T> {
+    return runPgTransaction(this.sql, (tx) => run(new PgFileUploadSessionPersistence(tx, true)))
+  }
+}
+
+class PgFileUploadSessionPersistence implements FileUploadSessionPersistence {
+  constructor(
+    private readonly sql: PgStoreClient,
+    private readonly locking: boolean
+  ) {}
+
+  async now(): Promise<Date> {
+    const [row] = await this.sql<{ readonly now: Date }[]>`SELECT clock_timestamp() AS now`
+    if (!row) throw new Error("[SixbPg] Database clock returned no row.")
+    return new Date(row.now)
+  }
+
+  async insert(session: FileUploadSession): Promise<boolean> {
+    // A unique violation would abort the surrounding transaction; report the conflict instead.
+    const rows = await this.sql`
+      INSERT INTO file_upload_sessions (
+        id, project_id, owner_principal_type, owner_principal_id, strategy, status, file_name,
+        media_type, logical_path, expected_size_bytes, expected_digest, provider_upload,
+        signed_parts, file_ref, created_at, expires_at, completed_at, aborted_at, reap_at
+      ) VALUES (
+        ${session.id}, ${session.projectId}, ${session.principal.type}, ${session.principal.id},
+        ${session.strategy}, ${session.status}, ${session.fileName ?? null}, ${session.mediaType ?? null},
+        ${session.logicalPath ?? null}, ${session.expectedSizeBytes ?? null},
+        ${session.expectedDigest ?? null}, ${jsonText(session.providerUpload)}::text::jsonb,
+        ${JSON.stringify(session.signedParts)}::text::jsonb, ${jsonText(session.fileRef)}::text::jsonb,
+        ${session.createdAt}, ${session.expiresAt}, ${session.completedAt ?? null},
+        ${session.abortedAt ?? null}, ${fileUploadSessionReapAt(session)}
+      )
+      ON CONFLICT (id) DO NOTHING
+      RETURNING id
+    `
+    return rows.length === 1
+  }
+
+  async get(uploadId: string): Promise<FileUploadSession | null> {
+    const [row] = this.locking
+      ? await this.sql<PgFileUploadSessionRow[]>`
+          SELECT * FROM file_upload_sessions WHERE id = ${uploadId} FOR UPDATE
+        `
+      : await this.sql<PgFileUploadSessionRow[]>`
+          SELECT * FROM file_upload_sessions WHERE id = ${uploadId}
+        `
+    return row ? sessionFromRow(row) : null
+  }
+
+  async update(session: FileUploadSession): Promise<void> {
+    await this.sql`
+      UPDATE file_upload_sessions
+      SET status = ${session.status},
+        provider_upload = ${jsonText(session.providerUpload)}::text::jsonb,
+        signed_parts = ${JSON.stringify(session.signedParts)}::text::jsonb,
+        file_ref = ${jsonText(session.fileRef)}::text::jsonb,
+        created_at = ${session.createdAt},
+        expires_at = ${session.expiresAt},
+        completed_at = ${session.completedAt ?? null},
+        aborted_at = ${session.abortedAt ?? null},
+        reap_at = ${fileUploadSessionReapAt(session)}
+      WHERE id = ${session.id}
+    `
+  }
+
+  async listAbandoned(
+    input: ListAbandonedFileUploadSessionsInput
+  ): Promise<readonly FileUploadSession[]> {
+    const rows = await this.sql<PgFileUploadSessionRow[]>`
+      SELECT * FROM file_upload_sessions
+      WHERE project_id = ${input.projectId} AND status = 'pending'
+        AND provider_upload IS NOT NULL AND expires_at <= ${input.now}
+      ORDER BY expires_at, id COLLATE "C"
+      LIMIT ${input.limit}
+    `
+    return rows.map(sessionFromRow)
+  }
+
+  async deleteReapable(now: Date): Promise<number> {
+    const rows = await this.sql`
+      DELETE FROM file_upload_sessions
+      WHERE reap_at IS NOT NULL AND reap_at <= ${now}
+      RETURNING id
+    `
+    return rows.length
+  }
+}
+
+interface PgFileUploadSessionRow {
+  readonly [column: string]: unknown
+}
+
+function sessionFromRow(row: PgFileUploadSessionRow): FileUploadSession {
+  return parseFileUploadSessionRow({
+    id: row.id,
+    projectId: row.project_id,
+    ownerPrincipalType: row.owner_principal_type,
+    ownerPrincipalId: row.owner_principal_id,
+    strategy: row.strategy,
+    status: row.status,
+    fileName: row.file_name,
+    mediaType: row.media_type,
+    logicalPath: row.logical_path,
+    expectedSizeBytes: row.expected_size_bytes,
+    expectedDigest: row.expected_digest,
+    providerUpload: row.provider_upload,
+    signedParts: row.signed_parts,
+    fileRef: row.file_ref,
+    createdAt: row.created_at,
+    expiresAt: row.expires_at,
+    completedAt: row.completed_at,
+    abortedAt: row.aborted_at,
+  })
+}
+
+/** JSON text for a nullable jsonb column; always bind with the `::text::jsonb` double cast. */
+function jsonText(value: object | undefined): string | null {
+  return value === undefined ? null : JSON.stringify(value)
+}

package/src/pg-workflow-intervention-storage.ts

@@ -5,8 +5,8 @@ import type {
   ExpireWorkflowInterventionInput,
   ListWorkflowInterventionsInput,
   ListWorkflowInterventionsResult,
+  Principal,
   SubmitWorkflowInterventionInput,
-  WorkflowInterventionActor,
   WorkflowInterventionRecord,
   WorkflowInterventionStorage,
 } from "@sixb/core/storage"
@@ -78,7 +78,7 @@ export class PgWorkflowInterventionStorage implements WorkflowInterventionStorag
         SET
           status = ${"submitted"},
           submitted_at = ${input.submittedAt ?? new Date()},
-          submitted_by = ${serializeActor(input.submittedBy)}::text::jsonb,
+          submitted_by = ${serializePrincipal(input.submittedBy)}::text::jsonb,
           response = ${serializeRecord(input.response)}::text::jsonb
         WHERE project_id = ${input.projectId} AND id = ${input.id}
         RETURNING *
@@ -97,7 +97,7 @@ export class PgWorkflowInterventionStorage implements WorkflowInterventionStorag
         SET
           status = ${"cancelled"},
           cancelled_at = ${input.cancelledAt ?? new Date()},
-          cancelled_by = ${serializeActor(input.cancelledBy)}::text::jsonb
+          cancelled_by = ${serializePrincipal(input.cancelledBy)}::text::jsonb
         WHERE project_id = ${input.projectId} AND id = ${input.id}
         RETURNING *
       `
@@ -268,16 +268,12 @@ function parseRecord(value: WorkflowIOSnapshot | string): WorkflowIOSnapshot {
   return typeof value === "string" ? (JSON.parse(value) as WorkflowIOSnapshot) : value
 }
 
-function serializeActor(actor: WorkflowInterventionActor | undefined): string | null {
-  return actor ? JSON.stringify(actor) : null
+function serializePrincipal(principal: Principal | undefined): string | null {
+  return principal ? JSON.stringify(principal) : null
 }
 
-function parseActor(
-  value: WorkflowInterventionActor | string | null
-): WorkflowInterventionActor | undefined {
-  return typeof value === "string"
-    ? (JSON.parse(value) as WorkflowInterventionActor)
-    : (value ?? undefined)
+function parsePrincipal(value: Principal | string | null): Principal | undefined {
+  return typeof value === "string" ? (JSON.parse(value) as Principal) : (value ?? undefined)
 }
 
 function rowToWorkflowInterventionRecord(
@@ -299,10 +295,10 @@ function rowToWorkflowInterventionRecord(
     requestedAt: new Date(row.requested_at),
     expiresAt: row.expires_at ? new Date(row.expires_at) : undefined,
     submittedAt: row.submitted_at ? new Date(row.submitted_at) : undefined,
-    submittedBy: parseActor(row.submitted_by),
+    submittedBy: parsePrincipal(row.submitted_by),
     response: row.response ? parseRecord(row.response) : undefined,
     cancelledAt: row.cancelled_at ? new Date(row.cancelled_at) : undefined,
-    cancelledBy: parseActor(row.cancelled_by),
+    cancelledBy: parsePrincipal(row.cancelled_by),
     expiredAt: row.expired_at ? new Date(row.expired_at) : undefined,
   }
 }
@@ -331,9 +327,9 @@ interface WorkflowInterventionDatabaseRow {
   requested_at: Date | string
   expires_at: Date | string | null
   submitted_at: Date | string | null
-  submitted_by: WorkflowInterventionActor | string | null
+  submitted_by: Principal | string | null
   response: WorkflowIOSnapshot | string | null
   cancelled_at: Date | string | null
-  cancelled_by: WorkflowInterventionActor | string | null
+  cancelled_by: Principal | string | null
   expired_at: Date | string | null
 }