@sixb/pg 0.1.12 → 0.1.13

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
 }