@sixb/sqlite 0.1.5 → 0.1.7

package/src/ontology-storage/materialization-state.ts

@@ -22,6 +22,7 @@ import {
   startScopeAccumulator,
 } from "@sixb/core/internal/ontology-storage-provider"
 import type {
+  MaterializationLinkScopeRevision,
   MaterializationLinkScopeState,
   MaterializationLinkState,
   MaterializationObjectState,
@@ -83,6 +84,19 @@ interface LinkScopeRow extends EffectiveLinkRow {
   readonly scope_sort_key: string
 }
 
+function linkScopeRequestJson(
+  scopes: readonly { readonly source: OntologyObjectRef; readonly linkId: string }[]
+): string {
+  return canonicalJson(
+    scopes.map(({ source, linkId }) => ({
+      scopeSortKey: linkScopeSortKey(source, linkId),
+      sourceTypeId: source.objectTypeId,
+      sourceId: source.primaryId,
+      linkId,
+    }))
+  )
+}
+
 interface ObjectOverrideRow extends SqliteStoredOverrideRow {
   readonly object_type_id: string
   readonly primary_id: string
@@ -426,23 +440,18 @@ export class SqliteMaterializationStateReader {
     })
   }
 
-  linkScopes(
+  linkScopeRevisions(
+    scopes: readonly { readonly source: OntologyObjectRef; readonly linkId: string }[]
+  ): readonly MaterializationLinkScopeRevision[] {
+    if (scopes.length === 0) return []
+    return this.readEffectiveLinkScopes(scopes, linkScopeRequestJson(scopes)).revisions
+  }
+
+  linkSlotStates(
     scopes: readonly { readonly source: OntologyObjectRef; readonly linkId: string }[]
   ): readonly MaterializationLinkScopeState[] {
     if (scopes.length === 0) return []
-    const requested = scopes.map(({ source, linkId }) => ({
-      scopeSortKey: linkScopeSortKey(source, linkId),
-      sourceTypeId: source.objectTypeId,
-      sourceId: source.primaryId,
-      linkId,
-    }))
-    const accumulators = new Map(
-      scopes.map(({ source, linkId }) => {
-        const key = linkScopeSortKey(source, linkId)
-        return [key, startScopeAccumulator(source, linkId)] as const
-      })
-    )
-    const requestedJson = canonicalJson(requested)
+    const requestedJson = linkScopeRequestJson(scopes)
     const sourceRows = this.db
       .query(
         `WITH requested AS (
@@ -491,6 +500,31 @@ export class SqliteMaterializationStateReader {
         return [linkScopeSortKey(stored.ref.source, stored.ref.linkId), stored] as const
       })
     )
+    const { revisions, effective } = this.readEffectiveLinkScopes(scopes, requestedJson)
+    return scopes.map(({ source, linkId }, index) => {
+      const key = linkScopeSortKey(source, linkId)
+      return {
+        ...revisions[index]!,
+        sourceAssertion: sources.get(key) ?? null,
+        override: overrides.get(key) ?? null,
+        effective: effective.get(key) ?? null,
+      }
+    })
+  }
+
+  private readEffectiveLinkScopes(
+    scopes: readonly { readonly source: OntologyObjectRef; readonly linkId: string }[],
+    requestedJson: string
+  ): {
+    readonly revisions: readonly MaterializationLinkScopeRevision[]
+    readonly effective: ReadonlyMap<string, EffectiveLinkSnapshot | null>
+  } {
+    const accumulators = new Map(
+      scopes.map(({ source, linkId }) => {
+        const key = linkScopeSortKey(source, linkId)
+        return [key, startScopeAccumulator(source, linkId)] as const
+      })
+    )
     const effective = new Map<string, EffectiveLinkSnapshot | null>()
     const rows = this.db
       .query(
@@ -526,26 +560,12 @@ export class SqliteMaterializationStateReader {
       appendScopeSnapshot(accumulator, snapshot)
       effective.set(row.scope_sort_key, accumulator.effectiveCount === 1 ? snapshot : null)
     }
-    return scopes.map(({ source, linkId }) => {
-      const key = linkScopeSortKey(source, linkId)
-      return {
-        ...finishScopeAccumulator(accumulators.get(key)!),
-        sourceAssertion: sources.get(key) ?? null,
-        override: overrides.get(key) ?? null,
-        effective: effective.get(key) ?? null,
-      }
-    })
-  }
-
-  linkScope(source: OntologyObjectRef, linkId: string): MaterializationLinkScopeState {
-    const [scope] = this.linkScopes([{ source, linkId }])
-    if (!scope) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        "Link scope lookup returned no row."
-      )
+    return {
+      revisions: scopes.map(({ source, linkId }) =>
+        finishScopeAccumulator(accumulators.get(linkScopeSortKey(source, linkId))!)
+      ),
+      effective,
     }
-    return scope
   }
 
   *incidentLinks(

package/src/ontology-storage/materializations.ts

@@ -88,10 +88,9 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
         this.assertSource(expected, input.commit.projectId)
       for (const expected of input.expected.objects) this.assertObject(reader, expected)
       for (const expected of input.expected.links) this.assertLink(reader, expected)
-      for (const expected of input.expected.linkScopes) {
-        if (
-          reader.linkScope(expected.source, expected.linkId).fingerprint !== expected.fingerprint
-        ) {
+      const linkScopeRevisions = 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}.`
@@ -151,7 +150,7 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
         yield {
           objects: [],
           links: [],
-          linkScopes: reader.linkScopes(scopes.slice(offset, offset + input.pageRows)),
+          linkScopes: reader.linkSlotStates(scopes.slice(offset, offset + input.pageRows)),
           points: [],
         }
       }

package/src/workflow-run-storage.ts

@@ -491,7 +491,7 @@ export class SqliteWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunSt
       projectId: input.projectId,
       executionId: input.executionId,
       nodeRunId: input.nodeRunId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       workflowExecutionId: parent.execution_id,
     })
 
@@ -499,14 +499,14 @@ export class SqliteWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunSt
       this.db
         .query(`
           INSERT INTO workflow_agent_node_runs (
-            project_id, node_run_id, execution_id, agent_id, status, prompt, attempt, created_at
+            project_id, node_run_id, execution_id, actor_id, status, prompt, attempt, created_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         `)
         .run(
           input.projectId,
           input.nodeRunId,
           input.executionId,
-          input.agentId,
+          input.actorId,
           "queued",
           input.prompt,
           0,
@@ -659,9 +659,9 @@ export class SqliteWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunSt
     if (hasEmptyStatuses(input)) return { runs: [], total: 0, hasMore: false }
     const whereClauses = ["project_id = ?"]
     const args: SqliteValue[] = [input.projectId]
-    if (input.agentId) {
-      whereClauses.push("agent_id = ?")
-      args.push(input.agentId)
+    if (input.actorId) {
+      whereClauses.push("actor_id = ?")
+      args.push(input.actorId)
     }
     appendRunListFilters(whereClauses, args, input)
     const result = queryRunList<WorkflowAgentNodeRunDatabaseRow>({
@@ -1073,7 +1073,7 @@ interface WorkflowAgentNodeRunDatabaseRow {
   project_id: string
   node_run_id: string
   execution_id: string
-  agent_id: string
+  actor_id: string
   status: WorkflowAgentNodeRunRecord["status"]
   prompt: string
   model_id: string | null
@@ -1107,7 +1107,7 @@ function rowToWorkflowAgentNodeRunRecord(
     projectId: row.project_id,
     nodeRunId: row.node_run_id,
     executionId: row.execution_id,
-    agentId: row.agent_id,
+    actorId: row.actor_id,
     status: row.status,
     prompt: row.prompt,
     ...(row.model_id ? { modelId: row.model_id } : {}),