@sixb/sqlite 0.1.20 → 0.1.21

package/src/migrations/064-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. Timestamps are
+-- ISO-8601 UTC text and compare lexicographically.
+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 TEXT NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence >= 0),
+  window_start TEXT 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 NOT NULL,
+  actor_type TEXT NOT NULL CHECK (actor_type IN ('user', 'share')),
+  user_id TEXT,
+  grant_id TEXT,
+  session_id TEXT NOT NULL CHECK (length(session_id) > 0),
+  started_at TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL CHECK (last_seen_at >= started_at),
+  page_views INTEGER NOT NULL CHECK (page_views >= 0),
+  attribution TEXT CHECK (attribution IS NULL OR json_type(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 NOT NULL,
+  sequence INTEGER NOT NULL CHECK (sequence > 0),
+  id TEXT NOT NULL,
+  route TEXT NOT NULL,
+  received_at TEXT NOT NULL,
+  attribution TEXT CHECK (attribution IS NULL OR json_type(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/065-activity-timeline.sql

@@ -0,0 +1,19 @@
+-- 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.
+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;
+
+-- A user's connection history lists all their sessions, revoked and expired ones too, newest
+-- first.
+CREATE INDEX idx_auth_sessions_user_created
+  ON auth_sessions (project_id, user_id, created_at, id);

package/src/migrations/066-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 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 TEXT 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

@@ -273,6 +273,11 @@ export const sqliteStorageMigrations = defineMigrations({
     sqliteSql("059-drained-source-versions", drainedSourceVersionsSql),
     sqliteSql("060-terminal-action-runs", terminalActionRunsSql),
     sqliteSql("061-drop-auth-audience", dropAuthAudienceSql),
+    sqliteSql("062-artifacts", artifactsSql),
+    sqliteSql("063-drop-output-diagnostics", dropOutputDiagnosticsSql),
+    sqliteSql("064-activity", activitySql),
+    sqliteSql("065-activity-timeline", activityTimelineSql),
+    sqliteSql("066-activity-interactions", activityInteractionsSql),
   ],
 })
 
@@ -621,3 +626,12 @@ import drainedSourceVersionsSql from "./migrations/059-drained-source-versions.s
 }
 import terminalActionRunsSql from "./migrations/060-terminal-action-runs.sql" with { type: "text" }
 import dropAuthAudienceSql from "./migrations/061-drop-auth-audience.sql" with { type: "text" }
+import artifactsSql from "./migrations/062-artifacts.sql" with { type: "text" }
+import dropOutputDiagnosticsSql from "./migrations/063-drop-output-diagnostics.sql" with {
+  type: "text",
+}
+import activitySql from "./migrations/064-activity.sql" with { type: "text" }
+import activityTimelineSql from "./migrations/065-activity-timeline.sql" with { type: "text" }
+import activityInteractionsSql from "./migrations/066-activity-interactions.sql" with {
+  type: "text",
+}

package/src/ontology-storage/sources.ts

@@ -20,6 +20,7 @@ import type {
   AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  ActiveOntologySource,
   AdoptedSourceMaterialization,
   AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecutionInput,
@@ -27,6 +28,7 @@ import type {
   CleanupTerminalSourceMaterializationsInput,
   CleanupTerminalSourceMaterializationsResult,
   GetActiveOntologySourceInput,
+  ListActiveOntologySourcesInput,
   MarkSourceMaterializationReadyInput,
   OntologySourceRecord,
   OntologySourceStorage,
@@ -238,6 +240,36 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async listActive(
+    input: ListActiveOntologySourcesInput
+  ): Promise<readonly ActiveOntologySource[]> {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Source project id")
+
+      // Served by the partial index on active sources.
+      const rows = this.db
+        .query(
+          `
+            SELECT source_id, dataset_id, dataset_version_id, dataset_version_created_at,
+              projection_revision
+            FROM ontology_sources
+            WHERE project_id = ? AND status = 'active'
+          `
+        )
+        .all(input.projectId) as ActiveSourceRow[]
+
+      return rows.map((row) => ({
+        source: { projectionId: row.source_id },
+        datasetVersion: {
+          datasetId: row.dataset_id,
+          versionId: row.dataset_version_id,
+          createdAt: row.dataset_version_created_at,
+        },
+        projectionRevision: row.projection_revision,
+      }))
+    })
+  }
+
   async adopt(
     input: AdoptSourceMaterializationInput
   ): Promise<AdoptedSourceMaterialization | null> {
@@ -626,3 +658,12 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     return row
   }
 }
+
+type ActiveSourceRow = Pick<
+  SqliteOntologySourceRow,
+  | "source_id"
+  | "dataset_id"
+  | "dataset_version_id"
+  | "dataset_version_created_at"
+  | "projection_revision"
+>

package/src/share-grant-storage.ts

@@ -9,6 +9,7 @@ import {
 import type {
   CreateShareGrantInput,
   GetShareGrantByIdInput,
+  GetShareGrantsByIdsInput,
   ListShareGrantsInput,
   ListShareGrantsResult,
   RevokeShareGrantInput,
@@ -85,6 +86,30 @@ export class SqliteShareGrantStorage implements ShareGrantStorage {
     return this.getRow(normalized.projectId, normalized.id)
   }
 
+  async getByIds(input: GetShareGrantsByIdsInput): Promise<readonly ShareGrantRecord[]> {
+    const ids = [...new Set(input.ids)]
+    if (ids.length === 0) {
+      return []
+    }
+
+    const rows = this.db
+      .query(
+        `
+        SELECT *
+        FROM share_grants
+        WHERE project_id = ?
+          AND id IN (SELECT value FROM json_each(?))
+      `
+      )
+      .all(input.projectId, JSON.stringify(ids)) as SqliteShareGrantRow[]
+
+    const byId = new Map(rows.map((row) => [row.id, row]))
+    return ids.flatMap((id) => {
+      const row = byId.get(id)
+      return row ? [rowToRecord(row)] : []
+    })
+  }
+
   async list(input: ListShareGrantsInput): Promise<ListShareGrantsResult> {
     const normalized = normalizeListShareGrantsInput(input)
     const where = ["project_id = ?"]

package/src/workflow-run-storage.ts

@@ -358,6 +358,33 @@ export class SqliteWorkflowRunStorage 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 = this.db
+      .query(
+        `
+        SELECT *
+        FROM workflow_runs
+        WHERE project_id = ?
+          AND execution_id IN (SELECT value FROM json_each(?))
+      `
+      )
+      .all(params.projectId, JSON.stringify(executionIds)) as WorkflowRunDatabaseRow[]
+
+    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 {