@sixb/core 0.1.1 → 0.1.3

package/src/materializer/edits/load-state.ts

@@ -8,13 +8,15 @@ import type {
 } from "../../storage/ontology"
 import type { MaterializerContext } from "../context"
 import { loadState, oneStateRequest } from "../effective/load-state"
-import type { EditWorkingState } from "./operations"
-import { buildEditReadSet, isKnownLinkRef } from "./read-set"
+import { resolveEffectiveLinkSlotMember, usableLinkSlotOverride } from "../effective/resolve"
+import { buildEditReadSet, isKnownLinkRef, linkCardinality } from "./read-set"
 import {
   distinctCardinalityOneScopes,
+  type EditWorkingState,
   mergeWorkingState,
-  resolveLink,
-  workingLinkFromState,
+  resolveLinkEdge,
+  resolveObject,
+  workingLinkEdgeFromState,
 } from "./working-state"
 
 export async function loadEditWorkingState(
@@ -25,13 +27,21 @@ export async function loadEditWorkingState(
 ): Promise<EditWorkingState> {
   const state: EditWorkingState = {
     objects: new Map(),
-    links: new Map(),
-    scopeSnapshots: new Map(),
+    links: {
+      edges: new Map(),
+      slots: new Map(),
+    },
   }
   const readSet = buildEditReadSet(context.ontology, operations)
   const explicitLinkKeys = new Set(readSet.links.map(linkRefKey))
   const incidentLinks = new Map<string, MaterializationLinkState>()
-  const ignoredLinks: EditWorkingState["links"] = new Map()
+  const loadedState: EditWorkingState = {
+    objects: state.objects,
+    links: {
+      edges: new Map(),
+      slots: state.links.slots,
+    },
+  }
   const revivingObjects = new Set(
     operations.filter(isRevivingObjectOperation).map((operation) => objectRefKey(operation.ref))
   )
@@ -41,16 +51,22 @@ export async function loadEditWorkingState(
     requests: oneStateRequest(readSet),
     pageRows: context.batching.statePageRows,
   })) {
-    mergeWorkingState(state.objects, ignoredLinks, state.scopeSnapshots, page)
+    mergeWorkingState(context.ontology, loadedState, page)
     for (const link of page.links) {
       const key = linkRefKey(link.ref)
-      if (explicitLinkKeys.has(key) && !state.links.has(key)) {
-        state.links.set(key, workingLinkFromState(link))
+      if (
+        linkCardinality(context.ontology, link.ref) !== "one" &&
+        explicitLinkKeys.has(key) &&
+        !state.links.edges.has(key)
+      ) {
+        state.links.edges.set(key, workingLinkEdgeFromState(link))
       }
       if (readSet.incidentObjects.length > 0) incidentLinks.set(key, link)
     }
   }
 
+  await mergeMissingLinkSlotEndpoints(context, storage, session, state)
+
   await mergeIncidentState(
     context,
     storage,
@@ -111,12 +127,25 @@ async function mergeIncidentState(
     ) {
       return true
     }
-    return Boolean(resolveLink(context.ontology, workingLinkFromState(link), state.objects))
+    if (linkCardinality(context.ontology, link.ref) === "one") {
+      return Boolean(
+        resolveEffectiveLinkSlotMember({
+          ref: link.ref,
+          source: link.source,
+          override: usableLinkSlotOverride(link.slotOverride),
+          endpointExists: (ref) => {
+            const object = state.objects.get(objectRefKey(ref))
+            return Boolean(object && resolveObject(context.ontology, object))
+          },
+        })
+      )
+    }
+    return Boolean(resolveLinkEdge(context.ontology, workingLinkEdgeFromState(link), state.objects))
   })
   const missingScopes = distinctCardinalityOneScopes(
     context.ontology,
     relevantStates,
-    state.scopeSnapshots
+    state.links.slots
   )
   if (missingScopes.length > 0) {
     await mergeLoadedState(context, storage, session, state, {
@@ -128,12 +157,46 @@ async function mergeIncidentState(
     })
   }
 
+  await mergeMissingLinkSlotEndpoints(context, storage, session, state)
+
   for (const link of relevantStates) {
+    if (linkCardinality(context.ontology, link.ref) === "one") continue
     const key = linkRefKey(link.ref)
-    if (state.links.has(key)) continue
-    state.links.set(key, workingLinkFromState(link))
+    if (state.links.edges.has(key)) continue
+    state.links.edges.set(key, workingLinkEdgeFromState(link))
+  }
+  context.observeCoreBuffer?.(
+    "edits.incident-links",
+    state.links.edges.size + state.links.slots.size
+  )
+}
+
+async function mergeMissingLinkSlotEndpoints(
+  context: MaterializerContext,
+  storage: OntologyMaterializationStorage,
+  session: MaterializationSession,
+  state: EditWorkingState
+): Promise<void> {
+  const missing = new Map<string, OntologyObjectRef>()
+  for (const working of state.links.slots.values()) {
+    const refs = [
+      working.ref.source,
+      working.source?.assertion.ref.target,
+      working.override?.target,
+      working.before?.ref.target,
+    ]
+    for (const ref of refs) {
+      if (ref && !state.objects.has(objectRefKey(ref))) missing.set(objectRefKey(ref), ref)
+    }
   }
-  context.observeCoreBuffer?.("edits.incident-links", state.links.size)
+  if (missing.size === 0) return
+  await mergeLoadedState(context, storage, session, state, {
+    objects: [...missing.values()],
+    links: [],
+    linkScopes: [],
+    incidentObjects: [],
+    points: [],
+  })
 }
 
 async function mergeLoadedState(
@@ -144,5 +207,5 @@ async function mergeLoadedState(
   request: MaterializationStateRequestChunk
 ): Promise<void> {
   const loaded = await loadState(context, storage, session, request)
-  mergeWorkingState(state.objects, state.links, state.scopeSnapshots, loaded)
+  mergeWorkingState(context.ontology, state, loaded)
 }

package/src/materializer/edits/operations.ts

@@ -1,7 +1,7 @@
+import { stableJsonStringify } from "../../json"
 import { MaterializationValidationError } from "../../materialization/errors"
 import type { OntologyEditOperation, OntologyOperationOutcome } from "../../materialization/model"
-import { linkRefKey, objectRefKey } from "../../materialization/refs"
-import type { MaterializationLinkScopeState } from "../../storage/ontology"
+import { linkRefKey, linkScopeKey, objectRefKey } from "../../materialization/refs"
 import type { MaterializerContext } from "../context"
 import { diffEffectiveObject } from "../effective/diff"
 import {
@@ -16,28 +16,18 @@ import type { TimedCommitIdentity } from "../shared/identity"
 import { applyLinkEdit, applyObjectEdit } from "./apply"
 import { linkCardinality } from "./read-set"
 import {
-  resolveLink,
+  type EditWorkingState,
+  resolveLinkEdge,
+  resolveLinkSlot,
   resolveObject,
   validateWorkingCardinality,
-  type WorkingLink,
+  type WorkingLinkEdge,
   type WorkingObject,
 } from "./working-state"
 
 type ObjectOperation = Extract<OntologyEditOperation, { readonly kind: `object.${string}` }>
 type LinkOperation = Extract<OntologyEditOperation, { readonly kind: `link.${string}` }>
 
-/**
- * Transaction-local edit working set.
- *
- * Loaded snapshots remain pinned to the commit start while each successful operation updates the
- * mutable override. Operation N+1 can therefore observe operation N before anything is durable.
- */
-export interface EditWorkingState {
-  readonly objects: Map<string, WorkingObject>
-  readonly links: Map<string, WorkingLink>
-  readonly scopeSnapshots: Map<string, MaterializationLinkScopeState>
-}
-
 /**
  * Undo record for one override the current operation group replaced.
  *
@@ -103,11 +93,13 @@ function applyObjectOperation(
     operation,
     sourceProperties: working.source?.assertion.properties ?? null,
     authority: working.override,
+    editedAt: working.editedAt,
+    committedAt: identity.committedAt,
     effectiveExists: currentEffective !== null,
     ...normalized,
   })
 
-  applyObjectTransition(context, state, working, transition.next, journal)
+  applyObjectTransition(context, state, working, transition.next, transition.editedAt, journal)
 
   return objectOperationOutcome(operation, working, transition.changed, context, identity)
 }
@@ -156,21 +148,26 @@ function applyObjectTransition(
   state: EditWorkingState,
   working: WorkingObject,
   next: WorkingObject["override"],
+  nextEditedAt: Readonly<Record<string, string>>,
   journal?: EditUndoJournal
 ): void {
   const previous = working.override
+  const previousEditedAt = working.editedAt
   working.override = next
+  working.editedAt = { ...nextEditedAt }
   try {
     const resolved = resolveObject(context.ontology, working)
     if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
-    validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots)
+    validateWorkingCardinality(state.links.slots)
   } catch (error) {
     working.override = previous
+    working.editedAt = previousEditedAt
     throw error
   }
   journal?.push({
     restore: () => {
       working.override = previous
+      working.editedAt = previousEditedAt
     },
   })
 }
@@ -209,10 +206,13 @@ function applyLinkOperation(
   cardinality: "one" | "many" | undefined,
   journal?: EditUndoJournal
 ): OntologyOperationOutcome {
-  const working = requireWorkingLink(state, operation)
   validateLinkEndpoints(context, state, operation)
   const normalizedProperties = validateLinkOperation(context, operation)
-  const currentEffective = resolveLink(context.ontology, working, state.objects)
+  if (cardinality === "one") {
+    return applyLinkSlotOperation(context, state, operation, normalizedProperties, journal)
+  }
+  const working = requireWorkingLinkEdge(state, operation)
+  const currentEffective = resolveLinkEdge(context.ontology, working, state.objects)
   const transitionInput = {
     operation,
     hasSource: working.source !== null,
@@ -220,12 +220,66 @@ function applyLinkOperation(
     effectiveExists: currentEffective !== null,
   }
   const transition = applyLinkEdit({ ...transitionInput, normalizedProperties })
-  applyLinkTransition(context, state, working, transition.next, cardinality, journal)
+  applyLinkEdgeTransition(working, transition.next, journal)
   return { id: operation.id, ok: true, authority: authorityOutcome(transition.changed) }
 }
 
-function requireWorkingLink(state: EditWorkingState, operation: LinkOperation): WorkingLink {
-  const working = state.links.get(linkRefKey(operation.ref))
+function applyLinkSlotOperation(
+  context: MaterializerContext,
+  state: EditWorkingState,
+  operation: LinkOperation,
+  normalizedProperties: ReturnType<typeof validateLinkAuthorityProperties> | undefined,
+  journal?: EditUndoJournal
+): OntologyOperationOutcome {
+  const key = linkScopeKey(operation.ref.source, operation.ref.linkId)
+  const working = state.links.slots.get(key)
+  if (!working) {
+    throw new MaterializationValidationError("Link slot state was not loaded.")
+  }
+  const current = resolveLinkSlot(context.ontology, working, state.objects)
+  const previous = working.override
+  let next = previous
+
+  switch (operation.kind) {
+    case "link.upsert":
+      if (current && linkRefKey(current.ref) !== linkRefKey(operation.ref)) {
+        throw new MaterializationValidationError(
+          `Link scope '${operation.ref.source.objectTypeId}.${operation.ref.linkId}' has cardinality one.`
+        )
+      }
+      next = {
+        kind: "set",
+        target: operation.ref.target,
+        ...(normalizedProperties !== undefined ? { properties: normalizedProperties } : {}),
+      }
+      break
+    case "link.delete":
+      if (current && linkRefKey(current.ref) === linkRefKey(operation.ref)) {
+        next = { kind: "clear", target: operation.ref.target }
+      }
+      break
+    case "link.reset":
+      if (previous && objectRefKey(previous.target) === objectRefKey(operation.ref.target)) {
+        next = null
+      }
+      break
+  }
+
+  const changed = stableJsonStringify(previous) !== stableJsonStringify(next)
+  working.override = next
+  journal?.push({
+    restore: () => {
+      working.override = previous
+    },
+  })
+  return { id: operation.id, ok: true, authority: authorityOutcome(changed) }
+}
+
+function requireWorkingLinkEdge(
+  state: EditWorkingState,
+  operation: LinkOperation
+): WorkingLinkEdge {
+  const working = state.links.edges.get(linkRefKey(operation.ref))
   if (!working) throw new MaterializationValidationError("Link state was not loaded.")
   return working
 }
@@ -252,24 +306,13 @@ function validateLinkOperation(
   return validateLinkAuthorityProperties(context.ontology, operation.ref, operation.properties)
 }
 
-function applyLinkTransition(
-  context: Pick<MaterializerContext, "ontology">,
-  state: EditWorkingState,
-  working: WorkingLink,
-  next: WorkingLink["override"],
-  cardinality: "one" | "many" | undefined,
+function applyLinkEdgeTransition(
+  working: WorkingLinkEdge,
+  next: WorkingLinkEdge["override"],
   journal?: EditUndoJournal
 ): void {
   const previous = working.override
   working.override = next
-  try {
-    if (cardinality === "one") {
-      validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots)
-    }
-  } catch (error) {
-    working.override = previous
-    throw error
-  }
   journal?.push({
     restore: () => {
       working.override = previous

package/src/materializer/edits/plan.ts

@@ -9,6 +9,8 @@ import {
   compareObjectRefs,
   linkRefKey,
   linkRefSortKey,
+  linkScopeKey,
+  linkScopeSortKey,
   objectRefKey,
   objectRefSortKey,
 } from "../../materialization/refs"
@@ -23,25 +25,28 @@ import {
   buildLinkMaterializationEventDraft,
   buildObjectMaterializationEventDraft,
 } from "../effective/build-events"
-import { diffEffectiveLink, diffEffectiveObject } from "../effective/diff"
+import { diffEffectiveLink, diffEffectiveLinkSlot, diffEffectiveObject } from "../effective/diff"
 import { validateEffectiveObject } from "../effective/validate"
 import { stageWorkBounded } from "../execution/work-executor"
 import {
-  appendLinkEffectivePlan,
-  appendLinkOverridePlan,
-  appendObjectEffectivePlan,
-  appendObjectOverridePlan,
+  appendEffectiveLinkWork,
+  appendEffectiveObjectWork,
+  appendLinkEdgeOverrideWork,
+  appendLinkSlotOverrideWork,
+  appendObjectOverrideWork,
   classificationWork,
   eventWork,
   planWork,
 } from "../execution/work-records"
 import type { TimedCommitIdentity } from "../shared/identity"
-import type { EditWorkingState } from "./operations"
 import {
-  resolveLink,
+  type EditWorkingState,
+  resolveLinkEdge,
+  resolveLinkSlot,
   resolveObject,
   validateWorkingCardinality,
-  type WorkingLink,
+  type WorkingLinkEdge,
+  type WorkingLinkSlot,
   type WorkingObject,
 } from "./working-state"
 
@@ -53,6 +58,7 @@ export interface EditPlanChanges {
 interface EditPlanContext {
   readonly identity: TimedCommitIdentity
   readonly origin: OntologyMaterializationOrigin
+  readonly correlationId: string
   readonly actor?: EventActor
 }
 
@@ -63,17 +69,17 @@ export async function stageEditPlan(
   state: EditWorkingState,
   planContext: EditPlanContext
 ): Promise<EditPlanChanges> {
-  validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots)
+  validateWorkingCardinality(state.links.slots)
 
   const objectChanges: EffectiveObjectChange[] = []
   for (const working of sortedObjects(state.objects)) {
-    const change = await stageObjectPlan(context, storage, session, working, planContext)
+    const change = await stageObject(context, storage, session, working, planContext)
     if (change) objectChanges.push(change)
   }
 
   const linkChanges: EffectiveLinkChange[] = []
-  for (const working of sortedLinks(state.links)) {
-    const change = await stageLinkPlan(
+  for (const working of sortedLinkEdges(state.links.edges)) {
+    const change = await stageLinkEdge(
       context,
       storage,
       session,
@@ -83,11 +89,69 @@ export async function stageEditPlan(
     )
     if (change) linkChanges.push(change)
   }
+  for (const working of sortedLinkSlots(state.links.slots)) {
+    linkChanges.push(
+      ...(await stageLinkSlot(context, storage, session, state.objects, working, planContext))
+    )
+  }
 
   return { objects: objectChanges, links: linkChanges }
 }
 
-async function stageObjectPlan(
+/**
+ * Stages one slot-level authority change and translates it back to physical edge writes/events.
+ * Replacing the selected target therefore becomes an ordered delete of the old edge followed by a
+ * create of the new edge, while the override itself remains keyed only by `(source, linkId)`.
+ */
+async function stageLinkSlot(
+  context: MaterializerContext,
+  storage: OntologyMaterializationStorage,
+  session: MaterializationSession,
+  objects: EditWorkingState["objects"],
+  working: WorkingLinkSlot,
+  planContext: EditPlanContext
+): Promise<EffectiveLinkChange[]> {
+  const overrideItems: MaterializationPlanWorkItem[] = []
+  appendLinkSlotOverrideWork(overrideItems, working, planContext.identity)
+  const resolved = resolveLinkSlot(context.ontology, working, objects)
+  const changes = diffEffectiveLinkSlot({
+    before: working.before,
+    resolved,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt,
+  })
+
+  const representative =
+    resolved?.ref ??
+    working.before?.ref ??
+    (working.override
+      ? {
+          source: working.ref.source,
+          linkId: working.ref.linkId,
+          target: working.override.target,
+        }
+      : null)
+  const scopeSortKey = linkScopeSortKey(working.ref.source, working.ref.linkId)
+  const work: MaterializationWorkRecord[] = overrideItems.map((item) =>
+    planWork(item, scopeSortKey)
+  )
+  if (representative) {
+    work.push(
+      classificationWork("link", linkRefKey(representative), linkRefSortKey(representative))
+    )
+  }
+  for (const change of changes) {
+    const effectiveItems: MaterializationPlanWorkItem[] = []
+    appendEffectiveLinkWork(effectiveItems, change)
+    const sortKey = linkRefSortKey(change.ref)
+    work.push(...effectiveItems.map((item) => planWork(item, sortKey)))
+    work.push(eventWork(buildLinkEvent(context, planContext, change)))
+  }
+  await stageWorkBounded(context, storage, session, work)
+  return changes
+}
+
+async function stageObject(
   context: MaterializerContext,
   storage: OntologyMaterializationStorage,
   session: MaterializationSession,
@@ -95,7 +159,7 @@ async function stageObjectPlan(
   planContext: EditPlanContext
 ): Promise<EffectiveObjectChange | null> {
   const items: MaterializationPlanWorkItem[] = []
-  appendObjectOverridePlan(items, working, planContext.identity)
+  appendObjectOverrideWork(items, working, planContext.identity)
 
   const resolved = resolveObject(context.ontology, working)
   if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
@@ -105,7 +169,7 @@ async function stageObjectPlan(
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
   })
-  if (change) appendObjectEffectivePlan(items, change)
+  if (change) appendEffectiveObjectWork(items, change)
 
   const sortKey = objectRefSortKey(working.ref)
   const work: MaterializationWorkRecord[] = [
@@ -119,25 +183,25 @@ async function stageObjectPlan(
   return change
 }
 
-async function stageLinkPlan(
+async function stageLinkEdge(
   context: MaterializerContext,
   storage: OntologyMaterializationStorage,
   session: MaterializationSession,
   objects: EditWorkingState["objects"],
-  working: WorkingLink,
+  working: WorkingLinkEdge,
   planContext: EditPlanContext
 ): Promise<EffectiveLinkChange | null> {
   const items: MaterializationPlanWorkItem[] = []
-  appendLinkOverridePlan(items, working, planContext.identity)
+  appendLinkEdgeOverrideWork(items, working, planContext.identity)
 
-  const resolved = resolveLink(context.ontology, working, objects)
+  const resolved = resolveLinkEdge(context.ontology, working, objects)
   const change = diffEffectiveLink({
     before: working.before,
     resolved,
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
   })
-  if (change) appendLinkEffectivePlan(items, change)
+  if (change) appendEffectiveLinkWork(items, change)
 
   const sortKey = linkRefSortKey(working.ref)
   const work: MaterializationWorkRecord[] = [
@@ -178,6 +242,7 @@ function materializationEventContext(
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
     origin: planContext.origin,
+    correlationId: planContext.correlationId,
   }
   if (planContext.actor === undefined) return base
   return { ...base, actor: planContext.actor }
@@ -187,6 +252,14 @@ function sortedObjects(objects: EditWorkingState["objects"]): WorkingObject[] {
   return [...objects.values()].sort((left, right) => compareObjectRefs(left.ref, right.ref))
 }
 
-function sortedLinks(links: EditWorkingState["links"]): WorkingLink[] {
-  return [...links.values()].sort((left, right) => compareLinkRefs(left.ref, right.ref))
+function sortedLinkEdges(edges: EditWorkingState["links"]["edges"]): WorkingLinkEdge[] {
+  return [...edges.values()].sort((left, right) => compareLinkRefs(left.ref, right.ref))
+}
+
+function sortedLinkSlots(slots: EditWorkingState["links"]["slots"]): WorkingLinkSlot[] {
+  return [...slots.values()].sort((left, right) =>
+    linkScopeKey(left.ref.source, left.ref.linkId).localeCompare(
+      linkScopeKey(right.ref.source, right.ref.linkId)
+    )
+  )
 }