@sixb/pg 0.1.20 → 0.1.22

package/src/pg-execution-storage.ts

@@ -1,4 +1,5 @@
 import {
+  compareExecutionCreation,
   type ExecutionStorageRow,
   executionRecordFromStorageRow,
   executionRecordToStorageRow,
@@ -6,8 +7,12 @@ import {
 } from "@sixb/core/internal/execution-storage"
 import type {
   CreateExecutionInput,
+  ExecutionDescendant,
   ExecutionRecord,
   ExecutionStorage,
+  ListExecutionDescendantsInput,
+  ListSessionExecutionsInput,
+  SessionExecutions,
   ShareSessionStorage,
 } from "@sixb/core/storage"
 import { ExecutionStorageError } from "@sixb/core/storage"
@@ -111,6 +116,84 @@ export class PgExecutionStorage implements ExecutionStorage {
     `
     return row ? pgExecutionRecord(row) : null
   }
+
+  async listBySession(input: ListSessionExecutionsInput): Promise<SessionExecutions> {
+    const session =
+      input.session.type === "user"
+        ? this.sql`authority_session_id = ${input.session.id}`
+        : this.sql`authority_delegation_session_id = ${input.session.id}`
+
+    // Each iteration of a recursive query reads the rows the previous one produced, so the walk goes
+    // level by level, roots first; with no ORDER BY outside, PostgreSQL evaluates only the rows the
+    // limit returns. Within the last level reached, which rows come first is unspecified.
+    const rows = await this.sql<(PgExecutionRow & { readonly depth: number })[]>`
+      WITH RECURSIVE tree AS (
+        (
+          SELECT *, 0 AS depth
+          FROM executions
+          WHERE project_id = ${input.projectId}
+            AND ${session}
+            AND parent_execution_id IS NULL
+            AND created_at >= ${input.from}
+            AND created_at < ${input.to}
+          ORDER BY created_at, id
+          LIMIT ${input.limit + 1}
+        )
+        UNION ALL
+        SELECT child.*, tree.depth + 1
+        FROM tree
+        JOIN executions child
+          ON child.project_id = tree.project_id
+          AND child.parent_execution_id = tree.id
+      )
+      SELECT * FROM tree
+      LIMIT ${input.limit + 1}
+    `
+
+    // Keep the first `limit` by depth, then oldest first, as the contract keeps them.
+    const records = rows
+      .map((row) => ({ depth: row.depth, record: pgExecutionRecord(row) }))
+      .sort(
+        (left, right) =>
+          left.depth - right.depth || compareExecutionCreation(left.record, right.record)
+      )
+      .slice(0, input.limit)
+      .map(({ record }) => record)
+
+    return {
+      executions: records.sort(compareExecutionCreation),
+      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/pg-workflow-run-storage.ts

@@ -314,6 +314,29 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
     return row ? rowToWorkflowRunRecord(row) : null
   }
 
+  async getByExecutionIds(params: {
+    readonly projectId: string
+    readonly executionIds: readonly string[]
+  }): Promise<readonly WorkflowRunRecord[]> {
+    const executionIds = [...new Set(params.executionIds)]
+    if (executionIds.length === 0) {
+      return []
+    }
+
+    const rows = await this.sql<WorkflowRunDatabaseRow[]>`
+      SELECT *
+      FROM workflow_runs
+      WHERE project_id = ${params.projectId}
+        AND execution_id = ANY(${this.sql.array(executionIds)}::text[])
+    `
+
+    const byExecution = new Map(rows.map((row) => [row.execution_id, row]))
+    return executionIds.flatMap((executionId) => {
+      const row = byExecution.get(executionId)
+      return row ? [rowToWorkflowRunRecord(row)] : []
+    })
+  }
+
   async list(input: ListWorkflowRunsInput): Promise<ListWorkflowRunsResult> {
     if (hasEmptyStatuses(input) || input.workflowIds?.length === 0) {
       return {

package/src/share-grant-storage.ts

@@ -8,6 +8,7 @@ import {
 import type {
   CreateShareGrantInput,
   GetShareGrantByIdInput,
+  GetShareGrantsByIdsInput,
   ListShareGrantsInput,
   ListShareGrantsResult,
   RevokeShareGrantInput,
@@ -85,6 +86,26 @@ export class PgShareGrantStorage implements ShareGrantStorage {
     return row ? recordFromRow(row) : null
   }
 
+  async getByIds(input: GetShareGrantsByIdsInput): Promise<readonly ShareGrantRecord[]> {
+    const ids = [...new Set(input.ids)]
+    if (ids.length === 0) {
+      return []
+    }
+
+    const rows = await this.sql<PgShareGrantRow[]>`
+      SELECT *
+      FROM share_grants
+      WHERE project_id = ${input.projectId}
+        AND id = ANY(${this.sql.array(ids)}::text[])
+    `
+
+    const byId = new Map(rows.map((row) => [row.id, row]))
+    return ids.flatMap((id) => {
+      const row = byId.get(id)
+      return row ? [recordFromRow(row)] : []
+    })
+  }
+
   async list(input: ListShareGrantsInput): Promise<ListShareGrantsResult> {
     const normalized = normalizeListShareGrantsInput(input)
     const where = ["project_id = $1"]

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.'
   )
 }