@sixb/pg 0.1.19 → 0.1.21

package/src/index.ts

@@ -49,9 +49,11 @@ export type { PgObjectTextCountIndex } from "./objects/text-count-index"
 
 import { PgOntologyStorage, type PgOntologyTransactionContext } from "./ontology-storage"
 import { PgActionRunStorage } from "./pg-action-run-storage"
+import { PgActivityStorage } from "./pg-activity-storage"
 import { PgAiCostStorage } from "./pg-ai-cost-storage"
 import { PgAiLimitStorage } from "./pg-ai-limit-storage"
 import { PgAiUsageStorage } from "./pg-ai-usage-storage"
+import { PgArtifactStorage } from "./pg-artifact-storage"
 import { createPgClient, type SQL, type SQLClient } from "./pg-client"
 import { PgExecutionStorage } from "./pg-execution-storage"
 import { PgFileDownloadGrantStorage } from "./pg-file-download-grant-storage"
@@ -166,6 +168,7 @@ export class PostgresStorage implements MigrationCapableStorage, QueryPreparatio
   readonly auth: PgAuthStorage
   readonly executions: PgExecutionStorage
   readonly agents: PgAgentStorage
+  readonly artifacts: PgArtifactStorage
   readonly aiUsage: AiUsageStorage
   readonly aiCosts: AiCostStorage
   readonly aiLimits: AiLimitStorage
@@ -183,6 +186,7 @@ export class PostgresStorage implements MigrationCapableStorage, QueryPreparatio
   readonly shareSessions: PgShareSessionStorage
   readonly fileUploadSessions: PgFileUploadSessionStorage
   readonly fileDownloadGrants: PgFileDownloadGrantStorage
+  readonly activity: PgActivityStorage
   readonly migrators: readonly StorageMigrator[]
 
   private readonly sql: SQL
@@ -252,6 +256,7 @@ export class PostgresStorage implements MigrationCapableStorage, QueryPreparatio
     this.auth = createAuthOperationScope(stores.auth, scope)
     this.executions = createOperationScopedFacade(stores.executions, scope)
     this.agents = createAgentOperationScope(stores.agents, scope)
+    this.artifacts = createOperationScopedFacade(stores.artifacts, scope)
     this.aiUsage = createOperationScopedFacade(stores.aiUsage, scope)
     this.aiCosts = createOperationScopedFacade(stores.aiCosts, scope)
     this.aiLimits = createOperationScopedFacade(stores.aiLimits, scope)
@@ -269,6 +274,7 @@ export class PostgresStorage implements MigrationCapableStorage, QueryPreparatio
     this.shareSessions = createOperationScopedFacade(stores.shareSessions, scope)
     this.fileUploadSessions = createOperationScopedFacade(stores.fileUploadSessions, scope)
     this.fileDownloadGrants = createOperationScopedFacade(stores.fileDownloadGrants, scope)
+    this.activity = createOperationScopedFacade(stores.activity, scope)
     registerPostgresStorageTestingAdapter(this, (durationMs) =>
       stores.connectorConnections.advanceTimeForTesting(durationMs)
     )
@@ -414,6 +420,7 @@ function createPostgresStores(
     auth,
     executions,
     agents: new PgAgentStorage({ sql, executions }),
+    artifacts: new PgArtifactStorage(sql),
     aiUsage: new PgAiUsageStorage(sql),
     aiCosts: new PgAiCostStorage(sql),
     aiLimits: new PgAiLimitStorage(sql),
@@ -431,6 +438,7 @@ function createPostgresStores(
     shareSessions,
     fileUploadSessions: new PgFileUploadSessionStorage(sql),
     fileDownloadGrants: new PgFileDownloadGrantStorage(sql),
+    activity: new PgActivityStorage(sql),
   }
 }
 
@@ -440,6 +448,7 @@ interface PostgresStoreSet {
   readonly auth: PgAuthStorage
   readonly executions: PgExecutionStorage
   readonly agents: PgAgentStorage
+  readonly artifacts: PgArtifactStorage
   readonly aiUsage: PgAiUsageStorage
   readonly aiCosts: PgAiCostStorage
   readonly aiLimits: PgAiLimitStorage
@@ -457,6 +466,7 @@ interface PostgresStoreSet {
   readonly shareSessions: PgShareSessionStorage
   readonly fileUploadSessions: PgFileUploadSessionStorage
   readonly fileDownloadGrants: PgFileDownloadGrantStorage
+  readonly activity: PgActivityStorage
 }
 
 function resolveTimeoutMillis(value: number | undefined, label: string): number | undefined {

package/src/migrations/062-drop-auth-audience.sql

@@ -0,0 +1,19 @@
+-- A project has one browser app, so sessions, magic links and sign-in attempts no longer name the
+-- one they belong to. Atlas's browser sessions end here: their cookie is no longer read. Native
+-- sessions carried Atlas's name only because the column needed a value, so they stay.
+UPDATE auth_sessions
+SET revoked_at = now()
+WHERE audience = 'atlas'
+  AND refresh_token_hash IS NULL
+  AND revoked_at IS NULL;
+
+-- Dropping the column drops the two indexes that name it.
+ALTER TABLE auth_sessions DROP COLUMN audience;
+CREATE INDEX idx_auth_sessions_user_active
+  ON auth_sessions (project_id, user_id, expires_at DESC, created_at DESC, id DESC)
+  WHERE revoked_at IS NULL;
+CREATE INDEX idx_auth_sessions_user_created
+  ON auth_sessions (project_id, user_id, created_at DESC, id DESC);
+
+ALTER TABLE auth_magic_links DROP COLUMN audience;
+ALTER TABLE auth_oidc_authorization_attempts DROP COLUMN audience;

package/src/migrations/063-artifacts.sql

@@ -0,0 +1,67 @@
+-- Artifacts: versioned documents, sheets, decks, and files. An artifact's kind never
+-- changes. Versions take `next_version`, which only grows, so a number is never reused after its
+-- version is deleted.
+CREATE TABLE artifacts (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  id TEXT NOT NULL CHECK (length(trim(id)) > 0),
+  kind TEXT NOT NULL CHECK (kind IN ('document', 'sheet', 'slides', 'file')),
+  title TEXT NOT NULL CHECK (length(trim(title)) > 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),
+  latest_version INTEGER NOT NULL CHECK (latest_version > 0),
+  next_version INTEGER NOT NULL CHECK (next_version > latest_version),
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, id)
+);
+
+CREATE INDEX idx_artifacts_project_updated ON artifacts (project_id, updated_at DESC, id);
+CREATE INDEX idx_artifacts_owner_updated
+  ON artifacts (project_id, owner_principal_type, owner_principal_id, updated_at DESC, id);
+
+-- `refs`, not `references`: that word is reserved in SQL.
+CREATE TABLE artifact_versions (
+  project_id TEXT NOT NULL,
+  artifact_id TEXT NOT NULL,
+  version INTEGER NOT NULL CHECK (version > 0),
+  title TEXT NOT NULL CHECK (length(trim(title)) > 0),
+  entry TEXT NOT NULL CHECK (length(entry) > 0),
+  files JSONB NOT NULL CHECK (jsonb_typeof(files) = 'array'),
+  outline JSONB NOT NULL CHECK (jsonb_typeof(outline) = 'object'),
+  refs JSONB NOT NULL CHECK (jsonb_typeof(refs) = 'array'),
+  author_principal_type TEXT NOT NULL
+    CHECK (author_principal_type IN ('user', 'serviceAccount', 'system')),
+  author_principal_id TEXT NOT NULL CHECK (length(author_principal_id) > 0),
+  origin_thread_id TEXT,
+  origin_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, artifact_id, version),
+  FOREIGN KEY (project_id, artifact_id) REFERENCES artifacts (project_id, id) ON DELETE CASCADE,
+  CHECK ((origin_thread_id IS NULL) = (origin_run_id IS NULL))
+);
+
+CREATE INDEX idx_artifact_versions_origin_run
+  ON artifact_versions (project_id, origin_run_id) WHERE origin_run_id IS NOT NULL;
+CREATE INDEX idx_artifact_versions_origin_thread
+  ON artifact_versions (project_id, origin_thread_id, artifact_id) WHERE origin_thread_id IS NOT NULL;
+
+-- Short-lived links that a sandboxed frame loads a deck's files through. Only the SHA-256 of each
+-- link's token is stored. `targets` is what the frame may show from other artifacts, decided for
+-- its reader when the link was issued: a JSON array of { address, artifactId, version }.
+CREATE TABLE artifact_frame_grants (
+  project_id TEXT NOT NULL,
+  token_hash TEXT NOT NULL CHECK (token_hash ~ '^[0-9a-f]{64}$'),
+  artifact_id TEXT NOT NULL,
+  version INTEGER NOT NULL CHECK (version > 0),
+  targets JSONB NOT NULL CHECK (jsonb_typeof(targets) = 'array'),
+  created_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, token_hash),
+  FOREIGN KEY (project_id, artifact_id) REFERENCES artifacts (project_id, id) ON DELETE CASCADE,
+  CHECK (expires_at > created_at)
+);
+
+CREATE INDEX idx_artifact_frame_grants_expiry ON artifact_frame_grants (project_id, expires_at);
+-- Deleting an artifact cascades here, and Postgres does not index a foreign key by itself.
+CREATE INDEX idx_artifact_frame_grants_artifact ON artifact_frame_grants (project_id, artifact_id);

package/src/migrations/064-drop-output-diagnostics.sql

@@ -0,0 +1,14 @@
+-- The Agent delivers files by publishing artifacts, so a run no longer collects an output
+-- directory or reports on it. Stored `output_*` diagnostics go; a run left with none stores none.
+UPDATE agent_runs
+SET diagnostics = (
+  SELECT jsonb_agg(item.value ORDER BY item.position)
+  FROM jsonb_array_elements(agent_runs.diagnostics) WITH ORDINALITY AS item(value, position)
+  WHERE item.value->>'code' NOT LIKE 'output\_%'
+)
+WHERE jsonb_typeof(diagnostics) = 'array'
+  AND EXISTS (
+    SELECT 1
+    FROM jsonb_array_elements(agent_runs.diagnostics) AS item(value)
+    WHERE item.value->>'code' LIKE 'output\_%'
+  );

package/src/migrations/065-plan-work-payload-statistics.sql

@@ -0,0 +1,5 @@
+-- A plan's work is analyzed whenever a stream has staged enough of it, and most of that ANALYZE
+-- went into the statistics of `payload`, which no query reads: the plan queries filter on the
+-- typed columns and only extract values from `payload`, and an extracted value has no statistics.
+-- A query that filters `payload` itself (`@>`, `?`) would need them back.
+ALTER TABLE ontology_replacement_plan_work ALTER COLUMN payload SET STATISTICS 0;

package/src/migrations/066-activity.sql

@@ -0,0 +1,61 @@
+-- App activity: one source per verified session, the visits it opened, and their page views.
+-- Foreground activity moves a visit's `last_seen_at` and stores no row, unless it opens a visit.
+-- A session id names an `auth_sessions` row for a user and a `share_sessions` row for a share; it
+-- is not a secret, and no foreign key holds it, so history outlives its sessions. Ids compare
+-- byte by byte, as the other providers sort them.
+CREATE TABLE activity_sources (
+  project_id TEXT NOT NULL,
+  actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'share')),
+  session_id TEXT NOT NULL CHECK (length(session_id) > 0),
+  visit_id TEXT NOT NULL,
+  last_seen_at TIMESTAMPTZ NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence >= 0),
+  window_start TIMESTAMPTZ NOT NULL,
+  window_count INTEGER NOT NULL CHECK (window_count >= 0),
+  PRIMARY KEY (project_id, actor_type, session_id)
+);
+
+CREATE TABLE activity_visits (
+  project_id TEXT NOT NULL,
+  id TEXT COLLATE "C" NOT NULL,
+  actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'share')),
+  user_id TEXT COLLATE "C",
+  grant_id TEXT,
+  session_id TEXT NOT NULL CHECK (length(session_id) > 0),
+  started_at TIMESTAMPTZ NOT NULL,
+  last_seen_at TIMESTAMPTZ NOT NULL CHECK (last_seen_at >= started_at),
+  page_views INTEGER NOT NULL CHECK (page_views >= 0),
+  attribution JSONB CHECK (attribution IS NULL OR jsonb_typeof(attribution) = 'object'),
+  PRIMARY KEY (project_id, id),
+  CHECK (
+    (actor_type = 'user' AND user_id IS NOT NULL AND grant_id IS NULL)
+    OR (actor_type = 'share' AND user_id IS NULL AND grant_id IS NOT NULL)
+  )
+);
+
+-- A period reads the visits it overlaps. A visit lasts less than a day, so they started in
+-- `[from - 1 day, to)`: both period indexes bound `started_at` on both sides. `last_seen_at` is
+-- left out of every index, so the update each batch makes touches none of them. The user index
+-- also serves deleting one user's history.
+CREATE INDEX idx_activity_visits_started
+  ON activity_visits (project_id, started_at, id);
+CREATE INDEX idx_activity_visits_user
+  ON activity_visits (project_id, user_id, started_at, id);
+-- A session's visits, to join them with the session and the executions it authorized.
+CREATE INDEX idx_activity_visits_session
+  ON activity_visits (project_id, actor_type, session_id);
+
+CREATE TABLE activity_page_views (
+  project_id TEXT NOT NULL,
+  visit_id TEXT COLLATE "C" NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence > 0),
+  id TEXT NOT NULL,
+  route TEXT NOT NULL,
+  received_at TIMESTAMPTZ NOT NULL,
+  attribution JSONB CHECK (attribution IS NULL OR jsonb_typeof(attribution) = 'object'),
+  PRIMARY KEY (project_id, visit_id, sequence),
+  FOREIGN KEY (project_id, visit_id) REFERENCES activity_visits (project_id, id) ON DELETE CASCADE
+);
+
+-- Finds a retried page view by the id its browser chose.
+CREATE INDEX idx_activity_page_views_id ON activity_page_views (project_id, id);

package/src/migrations/067-activity-timeline.sql

@@ -0,0 +1,15 @@
+-- A visit's timeline reads what its session started: the roots it authorized in a window, then
+-- everything they caused. A signed-in session is the credential of its roots, a shared link's
+-- session their delegation; a child names its parent. Agent executions copy their parent's
+-- session: the root indexes hold only executions without a parent, so they never see those, and
+-- end with `id` so the root read's order needs no sort. A user's connection history reads
+-- `idx_auth_sessions_user_created`, which already exists.
+CREATE INDEX idx_executions_session_roots
+  ON executions (project_id, authority_session_id, created_at, id)
+  WHERE authority_session_id IS NOT NULL AND parent_execution_id IS NULL;
+CREATE INDEX idx_executions_delegation_roots
+  ON executions (project_id, authority_delegation_session_id, created_at, id)
+  WHERE authority_delegation_session_id IS NOT NULL AND parent_execution_id IS NULL;
+CREATE INDEX idx_executions_parent
+  ON executions (project_id, parent_execution_id)
+  WHERE parent_execution_id IS NOT NULL;

package/src/migrations/068-activity-interactions.sql

@@ -0,0 +1,20 @@
+-- Interactions an app marks, such as a button: their name and route, never a value. They share
+-- the visit's sequence with its page views, so a visit reads both in the order they happened, and
+-- cascade with the visit, which counts them as it counts its page views.
+ALTER TABLE activity_visits
+  ADD COLUMN interactions INTEGER NOT NULL DEFAULT 0 CHECK (interactions >= 0);
+
+CREATE TABLE activity_interactions (
+  project_id TEXT NOT NULL,
+  visit_id TEXT COLLATE "C" NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence > 0),
+  id TEXT NOT NULL,
+  name TEXT NOT NULL CHECK (length(name) BETWEEN 1 AND 100),
+  route TEXT NOT NULL,
+  received_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, visit_id, sequence),
+  FOREIGN KEY (project_id, visit_id) REFERENCES activity_visits (project_id, id) ON DELETE CASCADE
+);
+
+-- Finds a retried interaction by the id its browser chose.
+CREATE INDEX idx_activity_interactions_id ON activity_interactions (project_id, id);

package/src/migrations.ts

@@ -432,6 +432,13 @@ export const postgresStorageMigrations = defineMigrations<PostgresMigrationConte
     pgSql("059-file-download-grants", fileDownloadGrantsSql),
     pgSql("060-drained-source-versions", drainedSourceVersionsSql),
     pgSql("061-terminal-action-runs", terminalActionRunsSql),
+    pgSql("062-drop-auth-audience", dropAuthAudienceSql),
+    pgSql("063-artifacts", artifactsSql),
+    pgSql("064-drop-output-diagnostics", dropOutputDiagnosticsSql),
+    pgSql("065-plan-work-payload-statistics", planWorkPayloadStatisticsSql),
+    pgSql("066-activity", activitySql),
+    pgSql("067-activity-timeline", activityTimelineSql),
+    pgSql("068-activity-interactions", activityInteractionsSql),
   ],
 })
 
@@ -461,3 +468,16 @@ import drainedSourceVersionsSql from "./migrations/060-drained-source-versions.s
   type: "text",
 }
 import terminalActionRunsSql from "./migrations/061-terminal-action-runs.sql" with { type: "text" }
+import dropAuthAudienceSql from "./migrations/062-drop-auth-audience.sql" with { type: "text" }
+import artifactsSql from "./migrations/063-artifacts.sql" with { type: "text" }
+import dropOutputDiagnosticsSql from "./migrations/064-drop-output-diagnostics.sql" with {
+  type: "text",
+}
+import planWorkPayloadStatisticsSql from "./migrations/065-plan-work-payload-statistics.sql" with {
+  type: "text",
+}
+import activitySql from "./migrations/066-activity.sql" with { type: "text" }
+import activityTimelineSql from "./migrations/067-activity-timeline.sql" with { type: "text" }
+import activityInteractionsSql from "./migrations/068-activity-interactions.sql" with {
+  type: "text",
+}

package/src/ontology-storage/replacement-plans.ts

@@ -50,11 +50,13 @@ const IDENTITIES = "ontology_replacement_plan_identities"
 const SORT_KEY = "encode(convert_to(identity_key, 'UTF8'), 'hex')"
 
 /**
- * Rows a plan writes at once before its tables are analyzed again. Autovacuum lags behind a bulk
- * write, and with the statistics of near-empty tables the planner scans a plan's whole work for
- * each keyed lookup instead of seeking it.
+ * Rows a plan writes before its tables are analyzed again: identities when it opens or expands,
+ * work once a stream has staged it. Every plan fills and empties the same tables, so their
+ * statistics describe the plans that were there when they were last analyzed. Until they describe
+ * this one, the planner expects none of its rows and reads its whole work for each key it looks
+ * up. Below this many rows, those reads cost less than an ANALYZE.
  */
-const ANALYZE_ROWS = 10_000
+const ANALYZE_ROWS = 1_000
 
 /** The plan a session applies: its work rows carry the candidate's source version as `work_id`. */
 export interface PgReplacementPlan {
@@ -240,7 +242,7 @@ export class PgOntologyReplacementPlanStorage implements OntologyReplacementPlan
     input: StreamReplacementPlanStateInput
   ): AsyncIterable<ReplacementPlanStatePage> {
     assertPageRows(input.pageRows)
-    await runPgTransaction(this.sql, async (sql) => {
+    const versionId = await runPgTransaction(this.sql, async (sql) => {
       const { candidate } = await requirePlan(sql, input)
       if (input.entityKind === "object" && candidate.projection_kind !== "object") {
         throw new MaterializationConflictError(
@@ -258,6 +260,7 @@ export class PgOntologyReplacementPlanStorage implements OntologyReplacementPlan
         const expanded = await expandLinks(sql, candidate.version_id, input.projectId, "pending")
         if (expanded >= ANALYZE_ROWS && !isWithinPgTransaction(this.sql)) await analyzePlans(sql)
       }
+      return candidate.version_id
     })
     let after = ""
     let streamed = 0
@@ -296,8 +299,8 @@ export class PgOntologyReplacementPlanStorage implements OntologyReplacementPlan
       if (!page) {
         // Every page is staged by now: later lookups and the commit join this work. Never in the
         // commit transaction, where ANALYZE would hold a lock other commits queue behind.
-        if (streamed >= ANALYZE_ROWS && !isWithinPgTransaction(this.sql)) {
-          await analyzePlans(this.sql)
+        if (streamed > 0 && !isWithinPgTransaction(this.sql)) {
+          await analyzeStagedWork(this.sql, versionId)
         }
         return
       }
@@ -994,6 +997,21 @@ async function analyzePlans(sql: SQLClient): Promise<void> {
   await sql`ANALYZE ${sql(IDENTITIES)}, ${sql(PG_PLAN_WORK_TABLE)}`
 }
 
+/**
+ * Analyzes the plan tables once the plan holds `ANALYZE_ROWS` rows of work. Counted in work rows,
+ * not identities: an object stages its classification, its existence, its change and its event.
+ */
+async function analyzeStagedWork(sql: SQLClient, versionId: string): Promise<void> {
+  const [staged] = await sql<{ readonly rows: number | string }[]>`
+    SELECT COUNT(*) AS rows FROM (
+      SELECT 1 FROM ${sql(PG_PLAN_WORK_TABLE)} WHERE work_id = ${versionId} LIMIT ${ANALYZE_ROWS}
+    ) AS work
+  `
+
+  if (Number(staged?.rows ?? 0) < ANALYZE_ROWS) return
+  await analyzePlans(sql)
+}
+
 /**
  * Deletes the work of the identities of `kind` left to plan: an identity to plan holds none. The
  * keys come first, so the work is sought by key whatever the plan tables' statistics.

package/src/ontology-storage/sources.ts

@@ -19,6 +19,7 @@ import type {
   AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  ActiveOntologySource,
   AdoptedSourceMaterialization,
   AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecutionInput,
@@ -26,6 +27,7 @@ import type {
   CleanupTerminalSourceMaterializationsInput,
   CleanupTerminalSourceMaterializationsResult,
   GetActiveOntologySourceInput,
+  ListActiveOntologySourcesInput,
   MarkSourceMaterializationReadyInput,
   OntologySourceRecord,
   OntologySourceStorage,
@@ -237,6 +239,32 @@ export class PgOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async listActive(
+    input: ListActiveOntologySourcesInput
+  ): Promise<readonly ActiveOntologySource[]> {
+    return this.runRootOperation(async (sql) => {
+      assertNonblank(input.projectId, "Source project id")
+
+      // Served by the partial index on active sources.
+      const rows = await sql<ActiveSourceRow[]>`
+        SELECT source_id, dataset_id, dataset_version_id, dataset_version_created_at,
+          projection_revision
+        FROM ontology_sources
+        WHERE project_id = ${input.projectId} AND status = 'active'
+      `
+
+      return rows.map((row) => ({
+        source: { projectionId: row.source_id },
+        datasetVersion: {
+          datasetId: row.dataset_id,
+          versionId: row.dataset_version_id,
+          createdAt: toIsoString(row.dataset_version_created_at),
+        },
+        projectionRevision: row.projection_revision,
+      }))
+    })
+  }
+
   async adopt(
     input: AdoptSourceMaterializationInput
   ): Promise<AdoptedSourceMaterialization | null> {
@@ -620,3 +648,12 @@ export class PgOntologySourceStorage implements OntologySourceStorage {
 function numberOrNull(value: number | string | null): number | null {
   return value === null ? null : Number(value)
 }
+
+type ActiveSourceRow = Pick<
+  PgOntologySourceRow,
+  | "source_id"
+  | "dataset_id"
+  | "dataset_version_id"
+  | "dataset_version_created_at"
+  | "projection_revision"
+>

package/src/pg-action-run-storage.ts

@@ -136,6 +136,29 @@ export class PgActionRunStorage implements ActionRunStorage {
     return row ? rowToActionRunRecord(row) : null
   }
 
+  async getByExecutionIds(params: {
+    readonly projectId: string
+    readonly executionIds: readonly string[]
+  }): Promise<readonly ActionRunRecord[]> {
+    const executionIds = [...new Set(params.executionIds)]
+    if (executionIds.length === 0) {
+      return []
+    }
+
+    const rows = await this.sql<DatabaseRow[]>`
+      SELECT *
+      FROM action_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 ? [rowToActionRunRecord(row)] : []
+    })
+  }
+
   async list(input: ListActionRunsInput): Promise<ListActionRunsResult> {
     if ((input.statuses && input.statuses.length === 0) || input.actionIds?.length === 0) {
       return {