@sixb/pg 0.1.21 → 0.1.22

package/src/pg-artifact-storage.ts

@@ -1,15 +1,22 @@
 import {
+  artifactStateBytes,
   artifactStorageErrors,
+  checkArtifactStateWrite,
   parseArtifactFrameGrantRow,
   parseArtifactRow,
+  parseArtifactStateRow,
   parseArtifactVersionRow,
 } from "@sixb/core/internal/storage"
 import type {
   ArtifactFrameGrantRecord,
   ArtifactRecord,
+  ArtifactStateEntry,
+  ArtifactStateKeyInput,
+  ArtifactStateScope,
   ArtifactStorage,
   ArtifactVersionInput,
   ArtifactVersionRecord,
+  CopyArtifactInput,
   CreateArtifactInput,
   DeleteArtifactInput,
   DeleteArtifactVersionsByOriginInput,
@@ -24,6 +31,7 @@ import type {
   ListReferencingVersionsInput,
   PublishArtifactVersionInput,
   PublishedArtifactVersion,
+  SetArtifactStateInput,
 } from "@sixb/core/storage"
 import type { SQLClient, SqlParameter } from "./pg-client"
 import { type PgStoreClient, runPgTransaction } from "./transactions"
@@ -51,6 +59,8 @@ const FRAME_GRANT_COLUMNS = `
   targets, created_at AS "createdAt", expires_at AS "expiresAt"
 `
 
+const STATE_COLUMNS = `key, value, size_bytes AS "sizeBytes", updated_at AS "updatedAt"`
+
 export class PgArtifactStorage implements ArtifactStorage {
   constructor(private readonly sql: PgStoreClient) {}
 
@@ -80,7 +90,7 @@ export class PgArtifactStorage implements ArtifactStorage {
     return runPgTransaction(this.sql, async (tx) => {
       // The row lock serializes concurrent publishes of one artifact.
       const [current] = await tx<PgRow[]>`
-        SELECT kind, next_version FROM artifacts
+        SELECT kind, next_version, latest_version FROM artifacts
         WHERE project_id = ${input.projectId} AND id = ${input.artifactId}
         FOR UPDATE
       `
@@ -89,6 +99,20 @@ export class PgArtifactStorage implements ArtifactStorage {
       if (kind !== input.kind) {
         throw artifactStorageErrors.kindMismatch(input.artifactId, kind, input.kind)
       }
+      // Under the row lock: a publish from the same base after this one finds it moved.
+      const latestVersion = Number(current.latest_version)
+      if (input.baseVersion !== undefined && latestVersion !== input.baseVersion) {
+        const [row] = await tx<PgRow[]>`
+          SELECT ${tx.unsafe(VERSION_COLUMNS)} FROM artifact_versions
+          WHERE project_id = ${input.projectId} AND artifact_id = ${input.artifactId}
+            AND version = ${latestVersion}
+        `
+        const latest = parseArtifactVersionRow(row as PgRow)
+        throw artifactStorageErrors.moved(input.artifactId, input.baseVersion, {
+          version: latest.version,
+          author: latest.author,
+        })
+      }
       const version = await insertVersion(
         tx,
         input.projectId,
@@ -124,15 +148,15 @@ export class PgArtifactStorage implements ArtifactStorage {
       where.push(`a.owner_principal_id = $${params.length + 1}`)
       params.push(input.owner.id)
     }
-    if (input.originThreadId !== undefined) {
+    if (input.threadId !== undefined) {
       where.push(
         `EXISTS (
-          SELECT 1 FROM artifact_versions v
-          WHERE v.project_id = a.project_id AND v.artifact_id = a.id
-            AND v.origin_thread_id = $${params.length + 1}
+          SELECT 1 FROM artifact_threads t
+          WHERE t.project_id = a.project_id AND t.artifact_id = a.id
+            AND t.thread_id = $${params.length + 1}
         )`
       )
-      params.push(input.originThreadId)
+      params.push(input.threadId)
     }
     if (input.kind !== undefined) {
       where.push(`a.kind = $${params.length + 1}`)
@@ -163,6 +187,58 @@ export class PgArtifactStorage implements ArtifactStorage {
     return row ? parseArtifactVersionRow(row) : null
   }
 
+  async listThreadIds(input: GetArtifactInput): Promise<string[]> {
+    const rows = await this.sql<{ thread_id: string }[]>`
+      SELECT thread_id FROM artifact_threads
+      WHERE project_id = ${input.projectId} AND artifact_id = ${input.id}
+      ORDER BY thread_id COLLATE "C"
+    `
+    return rows.map((row) => row.thread_id)
+  }
+
+  async copy(input: CopyArtifactInput): Promise<ArtifactRecord> {
+    return runPgTransaction(this.sql, async (tx) => {
+      // The share lock keeps the source from being deleted or published to while it is copied, so
+      // the copy holds every version it has.
+      const [source] = await tx<PgRow[]>`
+        SELECT id FROM artifacts WHERE project_id = ${input.projectId} AND id = ${input.sourceId}
+        FOR SHARE
+      `
+      if (!source) throw artifactStorageErrors.notFound(input.sourceId)
+
+      const [artifact] = await tx<PgRow[]>`
+        INSERT INTO artifacts (
+          project_id, id, kind, title, owner_principal_type, owner_principal_id,
+          latest_version, next_version, created_at, updated_at
+        )
+        SELECT project_id, ${input.id}, kind, title, ${input.owner.type}, ${input.owner.id},
+               latest_version, next_version, created_at, updated_at
+        FROM artifacts WHERE project_id = ${input.projectId} AND id = ${input.sourceId}
+        ON CONFLICT (project_id, id) DO NOTHING
+        RETURNING ${tx.unsafe(ARTIFACT_COLUMNS)}
+      `
+      if (!artifact) throw artifactStorageErrors.exists(input.id)
+
+      await tx`
+        INSERT INTO artifact_versions (
+          project_id, artifact_id, version, title, entry, files, outline, refs,
+          author_principal_type, author_principal_id, created_at
+        )
+        SELECT project_id, ${input.id}, version, title, entry, files, outline, refs,
+               author_principal_type, author_principal_id, created_at
+        FROM artifact_versions
+        WHERE project_id = ${input.projectId} AND artifact_id = ${input.sourceId}
+      `
+      await tx`
+        INSERT INTO artifact_threads (project_id, artifact_id, thread_id, shared_at, copied)
+        VALUES (
+          ${input.projectId}, ${input.id}, ${input.threadId}, ${input.copiedAt ?? new Date()}, TRUE
+        )
+      `
+      return parseArtifactRow(artifact)
+    })
+  }
+
   async listVersions(input: ListArtifactVersionsInput): Promise<ListArtifactVersionsResult> {
     const [counted] = await this.sql<{ total: number }[]>`
       SELECT COUNT(*)::int AS total FROM artifact_versions
@@ -241,8 +317,97 @@ export class PgArtifactStorage implements ArtifactStorage {
     return rows.length
   }
 
+  async getState(input: ArtifactStateKeyInput): Promise<ArtifactStateEntry | null> {
+    const [row] = await this.sql<PgRow[]>`
+      SELECT ${this.sql.unsafe(STATE_COLUMNS)} FROM artifact_state
+      WHERE project_id = ${input.projectId} AND artifact_id = ${input.artifactId}
+        AND principal_type = ${input.principal.type} AND principal_id = ${input.principal.id}
+        AND key = ${input.key}
+    `
+    return row ? parseArtifactStateRow(row) : null
+  }
+
+  async setState(input: SetArtifactStateInput): Promise<void> {
+    await runPgTransaction(this.sql, async (tx) => {
+      // The key share lock keeps the artifact from being deleted under the write, without
+      // waiting on a publish.
+      const [artifact] = await tx<PgRow[]>`
+        SELECT 1 FROM artifacts WHERE project_id = ${input.projectId} AND id = ${input.artifactId}
+        FOR KEY SHARE
+      `
+      if (!artifact) throw artifactStorageErrors.notFound(input.artifactId)
+      // One reader's writes to one artifact take turns, so two at once cannot both fit under the
+      // limits; other readers' writes do not wait.
+      await tx`
+        SELECT pg_advisory_xact_lock(hashtextextended(${JSON.stringify([
+          "artifact_state",
+          input.projectId,
+          input.artifactId,
+          input.principal.type,
+          input.principal.id,
+        ])}, 0))
+      `
+      const [others] = await tx<PgRow[]>`
+        SELECT count(*) AS keys, coalesce(sum(size_bytes), 0) AS bytes FROM artifact_state
+        WHERE project_id = ${input.projectId} AND artifact_id = ${input.artifactId}
+          AND principal_type = ${input.principal.type} AND principal_id = ${input.principal.id}
+          AND key <> ${input.key}
+      `
+      const sizeBytes = artifactStateBytes(input.value)
+      checkArtifactStateWrite({
+        key: input.key,
+        valueBytes: sizeBytes,
+        others: { keys: Number(others?.keys ?? 0), bytes: Number(others?.bytes ?? 0) },
+      })
+      await tx`
+        INSERT INTO artifact_state (
+          project_id, artifact_id, principal_type, principal_id, key, value, size_bytes,
+          updated_at
+        ) VALUES (
+          ${input.projectId}, ${input.artifactId}, ${input.principal.type},
+          ${input.principal.id}, ${input.key}, ${input.value}, ${sizeBytes}, ${input.updatedAt}
+        )
+        ON CONFLICT (project_id, artifact_id, principal_type, principal_id, key) DO UPDATE SET
+          value = excluded.value, size_bytes = excluded.size_bytes,
+          updated_at = excluded.updated_at
+      `
+    })
+  }
+
+  async deleteState(input: ArtifactStateKeyInput): Promise<boolean> {
+    const rows = await this.sql`
+      DELETE FROM artifact_state
+      WHERE project_id = ${input.projectId} AND artifact_id = ${input.artifactId}
+        AND principal_type = ${input.principal.type} AND principal_id = ${input.principal.id}
+        AND key = ${input.key}
+      RETURNING key
+    `
+    return rows.length > 0
+  }
+
+  async listState(input: ArtifactStateScope): Promise<ArtifactStateEntry[]> {
+    // COLLATE "C": code-unit order, as SQLite and the in-memory store compare keys.
+    const rows = await this.sql<PgRow[]>`
+      SELECT ${this.sql.unsafe(STATE_COLUMNS)} FROM artifact_state
+      WHERE project_id = ${input.projectId} AND artifact_id = ${input.artifactId}
+        AND principal_type = ${input.principal.type} AND principal_id = ${input.principal.id}
+      ORDER BY key COLLATE "C"
+    `
+    return rows.map(parseArtifactStateRow)
+  }
+
+  async clearState(input: ArtifactStateScope): Promise<number> {
+    const rows = await this.sql`
+      DELETE FROM artifact_state
+      WHERE project_id = ${input.projectId} AND artifact_id = ${input.artifactId}
+        AND principal_type = ${input.principal.type} AND principal_id = ${input.principal.id}
+      RETURNING key
+    `
+    return rows.length
+  }
+
   async delete(input: DeleteArtifactInput): Promise<boolean> {
-    // Versions and frame grants go with the artifact through ON DELETE CASCADE.
+    // Versions, frame grants, and state go with the artifact through ON DELETE CASCADE.
     const rows = await this.sql`
       DELETE FROM artifacts WHERE project_id = ${input.projectId} AND id = ${input.id}
       RETURNING id
@@ -269,11 +434,24 @@ export class PgArtifactStorage implements ArtifactStorage {
       `
       const affected = locked.map((row) => row.id)
       if (affected.length === 0) return 0
-      const deleted = await tx`
+      const deleted = await tx<{ origin_thread_id: string }[]>`
         DELETE FROM artifact_versions
         WHERE project_id = ${input.projectId} AND origin_run_id = ${input.runId}
           AND artifact_id IN ${tx(affected)}
-        RETURNING version
+        RETURNING origin_thread_id
+      `
+      // A run publishes from one thread: its artifacts stay shared there only while a version
+      // from it remains, or when they were copied for it.
+      const threadId = deleted[0]?.origin_thread_id
+      await tx`
+        DELETE FROM artifact_threads t
+        WHERE t.project_id = ${input.projectId} AND t.artifact_id IN ${tx(affected)}
+          AND t.thread_id = ${threadId ?? null} AND NOT t.copied
+          AND NOT EXISTS (
+            SELECT 1 FROM artifact_versions v
+            WHERE v.project_id = t.project_id AND v.artifact_id = t.artifact_id
+              AND v.origin_thread_id = t.thread_id
+          )
       `
       // An artifact left without versions goes; the rest point at their newest remaining one.
       await tx`
@@ -321,5 +499,23 @@ async function insertVersion(
     )
     RETURNING ${sql.unsafe(VERSION_COLUMNS)}
   `
+  if (input.origin) {
+    await linkThread(sql, projectId, artifactId, input.origin.threadId, input.createdAt)
+  }
   return parseArtifactVersionRow(row)
 }
+
+/** Shares an artifact in a thread, keeping when it was first shared there. */
+async function linkThread(
+  sql: SQLClient,
+  projectId: string,
+  artifactId: string,
+  threadId: string,
+  sharedAt: Date
+): Promise<void> {
+  await sql`
+    INSERT INTO artifact_threads (project_id, artifact_id, thread_id, shared_at)
+    VALUES (${projectId}, ${artifactId}, ${threadId}, ${sharedAt})
+    ON CONFLICT (project_id, artifact_id, thread_id) DO NOTHING
+  `
+}

package/src/pg-execution-storage.ts

@@ -7,8 +7,10 @@ import {
 } from "@sixb/core/internal/execution-storage"
 import type {
   CreateExecutionInput,
+  ExecutionDescendant,
   ExecutionRecord,
   ExecutionStorage,
+  ListExecutionDescendantsInput,
   ListSessionExecutionsInput,
   SessionExecutions,
   ShareSessionStorage,
@@ -163,6 +165,35 @@ export class PgExecutionStorage implements ExecutionStorage {
       truncated: rows.length > input.limit,
     }
   }
+
+  async listDescendants(
+    input: ListExecutionDescendantsInput
+  ): Promise<readonly ExecutionDescendant[]> {
+    if (input.executionIds.length === 0) return []
+    const ids = this.sql.array([...new Set(input.executionIds)])
+
+    // UNION, not UNION ALL: an execution asked about may sit below another one asked about, and
+    // the walk would otherwise reach what it caused twice.
+    const rows = await this.sql<{ id: string; parent_id: string }[]>`
+      WITH RECURSIVE tree(id, parent_id) AS (
+        SELECT child.id, child.parent_execution_id
+        FROM executions child
+        WHERE child.project_id = ${input.projectId}
+          AND child.parent_execution_id = ANY(${ids}::text[])
+        UNION
+        SELECT child.id, child.parent_execution_id
+        FROM tree
+        JOIN executions child
+          ON child.project_id = ${input.projectId}
+          AND child.parent_execution_id = tree.id
+      )
+      SELECT id, parent_id
+      FROM tree
+      WHERE id <> ALL(${ids}::text[])
+      ORDER BY id COLLATE "C"
+    `
+    return rows.map((row) => ({ id: row.id, parentId: row.parent_id }))
+  }
 }
 
 /** An `executions` row as its record, for any store that reads executions alongside its own rows. */

package/src/storage-errors.ts

@@ -81,6 +81,13 @@ export function isUniqueViolation(error: unknown): boolean {
   return pgErrorCode(error) === UNIQUE_VIOLATION
 }
 
+/** True when the error is a unique violation of exactly the named constraint. */
+export function isUniqueViolationOf(error: unknown, constraint: string): boolean {
+  if (!isUniqueViolation(error)) return false
+
+  return (error as { readonly constraint_name?: unknown }).constraint_name === constraint
+}
+
 /** True when the error is a PostgreSQL foreign-key violation (SQLSTATE 23503). */
 export function isForeignKeyViolation(error: unknown): boolean {
   return pgErrorCode(error) === FOREIGN_KEY_VIOLATION

package/src/transactions.ts

@@ -159,7 +159,7 @@ export async function runPgRepeatableReadTransaction<T>(
   }
 
   throw new Error(
-    '[SixbPg] Selected object reads cannot join an unverified PostgreSQL transaction. Use storage.transaction(..., { isolation: "serializable" }) when reading through tx.objects.'
+    '[SixbPg] Scoped object reads cannot join an unverified PostgreSQL transaction. Use storage.transaction(..., { isolation: "serializable" }) when reading through tx.objects.'
   )
 }