@sixb/pg 0.1.11 → 0.1.13

package/src/ontology-storage/vector-indexing.ts

@@ -0,0 +1,168 @@
+import { parseSixbFailure } from "@sixb/core/internal/errors"
+import {
+  type MaterializationSession,
+  type OntologyVectorIndexingStorage,
+  VECTOR_INDEXING_FAILURE_CODES,
+  type VectorIndexingRequest,
+  type VectorIndexingWork,
+} from "@sixb/core/storage"
+import type { SQLClient } from "../pg-client"
+import { jsonParameter as json, type PgRootOperation } from "./shared"
+
+interface WorkRow {
+  batch_id: string | null
+  request: VectorIndexingRequest
+  status: VectorIndexingWork["status"]
+  available_at: Date | string
+  values_json: number[] | null
+  error: string | null
+}
+
+export class PgVectorIndexingStorage implements OntologyVectorIndexingStorage {
+  constructor(
+    private readonly sql: SQLClient,
+    private readonly run: PgRootOperation,
+    private readonly assertSession: (session: MaterializationSession, projectId: string) => void
+  ) {}
+
+  async schedule(input: Parameters<OntologyVectorIndexingStorage["schedule"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    if (input.deleted.length)
+      await this.sql`
+      DELETE FROM object_vector_indexing AS work
+      USING jsonb_array_elements(${json(this.sql, input.deleted)}::jsonb) AS deleted(ref)
+      WHERE work.project_id = ${input.projectId}
+        AND work.object_type_id = deleted.ref->>'objectTypeId'
+        AND work.primary_id = deleted.ref->>'primaryId'
+    `
+    if (input.requests.length)
+      await this.sql`
+      INSERT INTO object_vector_indexing (
+        project_id, id, object_type_id, primary_id, profile, batch_id, request, status, available_at, dispatch_at
+      )
+      SELECT ${input.projectId}, entry->>'id', entry#>>'{ref,objectTypeId}',
+        entry#>>'{ref,primaryId}', entry->>'profile', entry->>'batchId', entry - 'batchId', 'pending',
+        ${input.availableAt}::timestamptz, ${input.availableAt}::timestamptz
+      FROM jsonb_array_elements(${json(this.sql, input.requests)}::jsonb) AS pending(entry)
+      ON CONFLICT (project_id, object_type_id, primary_id, profile) DO UPDATE SET
+        id = EXCLUDED.id, batch_id = EXCLUDED.batch_id, request = EXCLUDED.request, status = 'pending',
+        available_at = EXCLUDED.available_at, dispatch_at = EXCLUDED.dispatch_at,
+        values_json = NULL, error = NULL
+    `
+  }
+  async complete(input: Parameters<OntologyVectorIndexingStorage["complete"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    if (!input.entries.length) return
+    await this.sql`
+      DELETE FROM object_vector_indexing AS work
+      USING jsonb_array_elements(${json(this.sql, input.entries)}::jsonb) AS completed(entry)
+      WHERE work.project_id = ${input.projectId}
+        AND work.object_type_id = entry#>>'{ref,objectTypeId}'
+        AND work.primary_id = entry#>>'{ref,primaryId}'
+        AND work.profile = entry->>'profile'
+        AND work.request->>'configuration' = entry->>'configuration'
+        AND work.request->>'sourceFingerprint' = entry->>'sourceFingerprint'
+    `
+  }
+
+  async dispatched(input: Parameters<OntologyVectorIndexingStorage["dispatched"]>[0]) {
+    if (!input.ids.length) return
+    await this.run(async (sql) => {
+      await sql`UPDATE object_vector_indexing SET dispatch_at = ${input.nextDispatchAt} WHERE project_id = ${input.projectId} AND id = ANY(${sql.array([...input.ids])}::text[])`
+    })
+  }
+  async get(input: Parameters<OntologyVectorIndexingStorage["get"]>[0]) {
+    return this.run(async (sql) => {
+      const rows = await sql<
+        WorkRow[]
+      >`SELECT batch_id, request, status, available_at, values_json, error FROM object_vector_indexing WHERE project_id = ${input.projectId} AND id = ${input.id}`
+      return rows[0] ? decode(rows[0]) : null
+    })
+  }
+  async getBatch(input: Parameters<OntologyVectorIndexingStorage["getBatch"]>[0]) {
+    return this.run(async (sql) =>
+      (
+        await sql<WorkRow[]>`
+      SELECT batch_id, request, status, available_at, values_json, error
+      FROM object_vector_indexing WHERE project_id = ${input.projectId}
+      AND batch_id = ${input.batchId} ORDER BY id`
+      ).map(decode)
+    )
+  }
+
+  async getBatchMember(input: Parameters<OntologyVectorIndexingStorage["getBatchMember"]>[0]) {
+    return this.run(async (sql) => {
+      const rows = await sql<WorkRow[]>`
+        SELECT batch_id, request, status, available_at, values_json, error
+        FROM object_vector_indexing WHERE project_id = ${input.projectId}
+        AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        AND profile = ${input.profile} AND batch_id = ${input.batchId}`
+      return rows[0] ? decode(rows[0]) : null
+    })
+  }
+
+  async updateBatch(input: Parameters<OntologyVectorIndexingStorage["updateBatch"]>[0]) {
+    if (!input.updates.length) return true
+    return this.run(async (sql) => {
+      const rows = await sql<{ id: string }[]>`
+        WITH changes AS MATERIALIZED (
+          SELECT item FROM jsonb_array_elements(${json(sql, input.updates)}::jsonb) AS entries(item)
+        ), locked AS MATERIALIZED (
+          SELECT work.id FROM object_vector_indexing AS work
+          JOIN changes ON work.id = item->>'id' AND work.status = item->>'expectedStatus'
+          WHERE work.project_id = ${input.projectId} ORDER BY work.id FOR UPDATE OF work
+        )
+        UPDATE object_vector_indexing AS work SET
+          status = changes.item->>'status', available_at = (changes.item->>'availableAt')::timestamptz,
+          values_json = COALESCE(changes.item->'values', work.values_json),
+          error = (changes.item->'error')::text
+        FROM changes, locked
+        WHERE work.project_id = ${input.projectId} AND work.id = locked.id
+          AND work.id = changes.item->>'id'
+          AND (${!input.requireAll} OR (SELECT count(*) FROM locked) = ${input.updates.length})
+        RETURNING work.id`
+      return !input.requireAll || rows.length === input.updates.length
+    })
+  }
+
+  async listDue(input: Parameters<OntologyVectorIndexingStorage["listDue"]>[0]) {
+    return this.run(async (sql) =>
+      (
+        await sql<
+          WorkRow[]
+        >`SELECT batch_id, request, status, available_at, NULL AS values_json, error FROM object_vector_indexing WHERE project_id = ${input.projectId} AND status <> 'failed' AND dispatch_at <= ${input.now} ORDER BY dispatch_at, id LIMIT ${input.limit}`
+      ).map(decode)
+    )
+  }
+  async update(input: Parameters<OntologyVectorIndexingStorage["update"]>[0]) {
+    return this.run(
+      async (sql) =>
+        (
+          await sql`
+      UPDATE object_vector_indexing SET status = ${input.status}, available_at = ${input.availableAt},
+      values_json = COALESCE(${input.values ? json(sql, input.values) : null}, values_json), error = ${input.error ? JSON.stringify(input.error) : null}
+      WHERE project_id = ${input.projectId} AND id = ${input.id} AND status = ${input.expectedStatus} RETURNING id
+    `
+        ).length === 1
+    )
+  }
+  async remove(input: Parameters<OntologyVectorIndexingStorage["remove"]>[0]) {
+    await this.run(async (sql) => {
+      await sql`DELETE FROM object_vector_indexing WHERE project_id = ${input.projectId} AND id = ${input.id}`
+    })
+  }
+}
+function decode(row: WorkRow): VectorIndexingWork {
+  return {
+    ...row.request,
+    ...(row.batch_id ? { batchId: row.batch_id } : {}),
+    status: row.status,
+    availableAt: new Date(row.available_at).toISOString(),
+    ...(row.values_json ? { values: row.values_json } : {}),
+    ...(row.error
+      ? {
+          error: parseSixbFailure(row.error, VECTOR_INDEXING_FAILURE_CODES),
+        }
+      : {}),
+  }
+}

package/src/ontology-storage/vectors.ts

@@ -0,0 +1,172 @@
+import { MaterializationConflictError } from "@sixb/core/internal/materialization"
+import type {
+  MaterializationSession,
+  ObjectVectorState,
+  OntologyVectorStorage,
+} from "@sixb/core/storage"
+import type { SQLClient } from "../pg-client"
+import { jsonParameter as json, type PgRootOperation } from "./shared"
+
+interface VectorMetadataRow {
+  readonly profile: string
+  readonly configuration: string
+  readonly source: string[]
+  readonly source_fingerprint: string
+  readonly last_commit_id: string
+}
+
+export class PgOntologyVectorStorage implements OntologyVectorStorage {
+  constructor(
+    private readonly sql: SQLClient,
+    private readonly runRootOperation: PgRootOperation,
+    private readonly assertSession: (
+      session: MaterializationSession,
+      projectId: string,
+      commitId?: string
+    ) => void
+  ) {}
+
+  async list(
+    input: Parameters<OntologyVectorStorage["list"]>[0]
+  ): Promise<readonly ObjectVectorState[]> {
+    return this.runRootOperation(async (sql) => {
+      const rows = await sql<VectorMetadataRow[]>`
+        SELECT profile, configuration, source, source_fingerprint, last_commit_id
+        FROM object_vectors
+        WHERE project_id = ${input.projectId}
+          AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        ORDER BY profile
+      `
+      return rows.map((row) => ({
+        ref: { ...input.ref },
+        profile: row.profile,
+        configuration: row.configuration,
+        source: row.source,
+        sourceFingerprint: row.source_fingerprint,
+        lastCommitId: row.last_commit_id,
+      }))
+    })
+  }
+
+  async listBatch(
+    input: Parameters<OntologyVectorStorage["listBatch"]>[0]
+  ): Promise<readonly ObjectVectorState[]> {
+    if (!input.refs.length) return []
+    return this.runRootOperation(async (sql) => {
+      const rows = await sql<
+        (VectorMetadataRow & { object_type_id: string; primary_id: string })[]
+      >`
+        SELECT stored.object_type_id, stored.primary_id, stored.profile, stored.configuration,
+          stored.source, stored.source_fingerprint, stored.last_commit_id
+        FROM (SELECT DISTINCT ref->>'objectTypeId' AS object_type_id, ref->>'primaryId' AS primary_id
+          FROM jsonb_array_elements(${json(sql, input.refs)}::jsonb) AS requested(ref)) AS requested
+        JOIN object_vectors AS stored ON stored.project_id = ${input.projectId}
+          AND stored.object_type_id = requested.object_type_id AND stored.primary_id = requested.primary_id
+        ORDER BY stored.object_type_id, stored.primary_id, stored.profile
+      `
+      return rows.map((row) => ({
+        ref: { objectTypeId: row.object_type_id, primaryId: row.primary_id },
+        profile: row.profile,
+        configuration: row.configuration,
+        source: row.source,
+        sourceFingerprint: row.source_fingerprint,
+        lastCommitId: row.last_commit_id,
+      }))
+    })
+  }
+
+  async removeBatch(input: Parameters<OntologyVectorStorage["removeBatch"]>[0]): Promise<void> {
+    this.assertSession(input.session, input.projectId)
+    if (!input.entries.length) return
+    const removed = await this.sql`
+      DELETE FROM object_vectors AS stored
+      USING jsonb_array_elements(${json(this.sql, input.entries)}::jsonb) AS requested(entry)
+      WHERE stored.project_id = ${input.projectId}
+        AND stored.object_type_id = entry#>>'{ref,objectTypeId}'
+        AND stored.primary_id = entry#>>'{ref,primaryId}' AND stored.profile = entry->>'profile'
+        AND stored.last_commit_id = entry->>'expectedCommitId'
+      RETURNING stored.profile
+    `
+    if (removed.length !== input.entries.length) throw vectorConflict()
+  }
+
+  async write(input: Parameters<OntologyVectorStorage["write"]>[0]): Promise<void> {
+    await this.writeBatch({ session: input.session, projectId: input.projectId, entries: [input] })
+  }
+
+  async writeBatch(input: Parameters<OntologyVectorStorage["writeBatch"]>[0]): Promise<void> {
+    const entries = input.entries.map(({ value, expectedCommitId }) => {
+      this.assertSession(input.session, input.projectId, value.lastCommitId)
+      return {
+        object_type_id: value.ref.objectTypeId,
+        primary_id: value.ref.primaryId,
+        profile: value.profile,
+        configuration: value.configuration,
+        source: [...value.source],
+        source_fingerprint: value.sourceFingerprint,
+        embedding: [...value.values],
+        last_commit_id: value.lastCommitId,
+        expected_commit_id: expectedCommitId,
+      }
+    })
+    const inserts = entries.filter((entry) => entry.expected_commit_id === null)
+    const updates = entries.filter((entry) => entry.expected_commit_id !== null)
+
+    // Keep insert-if-absent and revision-checked update distinct: an upsert could recreate
+    // a deleted vector or overwrite a representation produced after preparation.
+    if (inserts.length) {
+      const rows = await this.sql`
+        INSERT INTO object_vectors (
+          project_id, object_type_id, primary_id, profile, configuration,
+          source, source_fingerprint, embedding, last_commit_id
+        )
+        SELECT ${input.projectId}, object_type_id, primary_id, profile, configuration,
+          source, source_fingerprint, embedding, last_commit_id
+        FROM jsonb_to_recordset(${json(this.sql, inserts)}::jsonb) AS incoming(
+          object_type_id text, primary_id text, profile text, configuration text,
+          source text[], source_fingerprint text, embedding real[], last_commit_id text
+        )
+        ORDER BY object_type_id, primary_id, profile
+        ON CONFLICT (project_id, object_type_id, primary_id, profile) DO NOTHING
+        RETURNING profile`
+      if (rows.length !== inserts.length) throw vectorConflict()
+    }
+
+    if (updates.length) {
+      const rows = await this.sql`
+        UPDATE object_vectors AS stored SET
+          configuration = incoming.configuration, source = incoming.source,
+          source_fingerprint = incoming.source_fingerprint, embedding = incoming.embedding,
+          last_commit_id = incoming.last_commit_id
+        FROM jsonb_to_recordset(${json(this.sql, updates)}::jsonb) AS incoming(
+          object_type_id text, primary_id text, profile text, configuration text,
+          source text[], source_fingerprint text, embedding real[], last_commit_id text,
+          expected_commit_id text
+        )
+        WHERE stored.project_id = ${input.projectId}
+          AND stored.object_type_id = incoming.object_type_id AND stored.primary_id = incoming.primary_id
+          AND stored.profile = incoming.profile AND stored.last_commit_id = incoming.expected_commit_id
+        RETURNING stored.profile`
+      if (rows.length !== updates.length) throw vectorConflict()
+    }
+  }
+
+  async remove(input: Parameters<OntologyVectorStorage["remove"]>[0]): Promise<void> {
+    this.assertSession(input.session, input.projectId)
+    const rows = await this.sql`
+      DELETE FROM object_vectors
+      WHERE project_id = ${input.projectId}
+        AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        AND profile = ${input.profile} AND last_commit_id = ${input.expectedCommitId}
+      RETURNING profile
+    `
+    if (rows.length !== 1) throw vectorConflict()
+  }
+}
+
+function vectorConflict(): MaterializationConflictError {
+  return new MaterializationConflictError(
+    "effective-state",
+    "Vector changed since it was prepared."
+  )
+}

package/src/pg-ai-cost-storage.ts

@@ -188,6 +188,8 @@ export class PgAiCostStorage implements AiCostStorage {
         COUNT(*)::text AS model_call_count,
         COUNT(*) FILTER (WHERE reporting_status <> 'unavailable')::text
           AS reported_usage_call_count,
+        COUNT(*) FILTER (WHERE input_tokens IS NOT NULL AND output_tokens IS NOT NULL)::text
+          AS complete_usage_call_count,
         COUNT(input_tokens)::text AS input_tokens_count,
         SUM(input_tokens)::text AS input_tokens_sum,
         COUNT(output_tokens)::text AS output_tokens_count,
@@ -379,6 +381,7 @@ interface AggregateRow {
   readonly amount_currency: string | null
   readonly model_call_count: string
   readonly reported_usage_call_count: string
+  readonly complete_usage_call_count: string
   readonly input_tokens_count: string
   readonly input_tokens_sum: string | null
   readonly output_tokens_count: string
@@ -455,6 +458,7 @@ function aggregateFragmentFromRow(row: AggregateRow): AiAccountingAggregateFragm
     modelCallCount: row.model_call_count,
     usage: {
       reportedCallCount: row.reported_usage_call_count,
+      completeCallCount: row.complete_usage_call_count,
       inputTokens: meterFragment(row.input_tokens_count, row.input_tokens_sum),
       outputTokens: meterFragment(row.output_tokens_count, row.output_tokens_sum),
       uncachedInputTokens: meterFragment(

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
 }