@sixb/pg 0.1.1 → 0.1.2

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

@@ -18,6 +18,7 @@ import {
 import {
   appendScopeSnapshot,
   finishScopeAccumulator,
+  linkSlotOverrideValue,
   startScopeAccumulator,
 } from "@sixb/core/internal/ontology-storage-provider"
 import type {
@@ -27,6 +28,7 @@ import type {
   SourceReplacementLinkState,
   SourceReplacementObjectState,
   StoredLinkOverride,
+  StoredLinkSlotOverride,
   StoredObjectOverride,
   StoredSourceAssertion,
   StoredSourceLinkAssertion,
@@ -36,12 +38,11 @@ import type {
 import type { SQLClient } from "../pg-client"
 import {
   databaseSafeInteger,
-  jsonKeyParameter,
   jsonParameter,
   linkRefFromColumns,
   objectRefFromColumns,
-  type PgOntologyOverrideRow,
   type PgOntologySourceAssertionRow,
+  type PgStoredOverrideRow,
   toIsoString,
 } from "./shared"
 
@@ -94,12 +95,12 @@ interface LinkScopeRow extends EffectiveLinkRow {
   readonly link_sort_key: string
 }
 
-interface ObjectOverrideRow extends PgOntologyOverrideRow {
+interface ObjectOverrideRow extends PgStoredOverrideRow {
   readonly object_type_id: string
   readonly primary_id: string
 }
 
-interface LinkOverrideRow extends PgOntologyOverrideRow {
+interface LinkOverrideRow extends PgStoredOverrideRow {
   readonly source_type_id: string
   readonly source_primary_id: string
   readonly link_id: string
@@ -107,6 +108,17 @@ interface LinkOverrideRow extends PgOntologyOverrideRow {
   readonly target_primary_id: string
 }
 
+interface LinkSlotOverrideRow {
+  readonly source_type_id: string
+  readonly source_primary_id: string
+  readonly link_id: string
+  readonly target_type_id: string
+  readonly target_primary_id: string
+  readonly value: unknown
+  readonly last_commit_id: string
+  readonly updated_at: Date | string
+}
+
 export type ReplacementIdentity =
   | {
       readonly kind: "object"
@@ -193,10 +205,9 @@ export class PgMaterializationStateReader {
           SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
             AS requested_values(object_type_id TEXT, primary_id TEXT)
         )
-        SELECT overrides.* FROM ontology_overrides AS overrides
+        SELECT overrides.* FROM ontology_object_overrides AS overrides
         JOIN requested USING (object_type_id, primary_id)
         WHERE overrides.project_id = ${this.projectId}
-          AND overrides.entity_kind = 'object'
       `,
       this.sql<TelemetryRow[]>`
         WITH requested AS (
@@ -266,7 +277,7 @@ export class PgMaterializationStateReader {
       target_primary_id: ref.target.primaryId,
     }))
     const requestedParameter = jsonParameter(this.sql, requested)
-    const [effectiveRows, sourceRows, overrideRows] = await Promise.all([
+    const [effectiveRows, sourceRows, overrideRows, slotOverrideRows] = await Promise.all([
       this.sql<EffectiveLinkRow[]>`
         WITH requested AS (
           SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter}) AS requested_values(
@@ -305,12 +316,23 @@ export class PgMaterializationStateReader {
             target_type_id TEXT, target_primary_id TEXT
           )
         )
-        SELECT overrides.* FROM ontology_overrides AS overrides
+        SELECT overrides.* FROM ontology_link_overrides AS overrides
         JOIN requested USING (
           source_type_id, source_primary_id, link_id, target_type_id, target_primary_id
         )
         WHERE overrides.project_id = ${this.projectId}
-          AND overrides.entity_kind = 'link'
+          AND overrides.identity_kind = 'edge'
+      `,
+      this.sql<LinkSlotOverrideRow[]>`
+        WITH requested AS (
+          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter}) AS requested_values(
+            source_type_id TEXT, source_primary_id TEXT, link_id TEXT
+          )
+        )
+        SELECT overrides.* FROM ontology_link_overrides AS overrides
+        JOIN requested USING (source_type_id, source_primary_id, link_id)
+        WHERE overrides.project_id = ${this.projectId}
+          AND overrides.identity_kind = 'slot'
       `,
     ])
     const effective = new Map(
@@ -322,6 +344,12 @@ export class PgMaterializationStateReader {
         (row) => [linkRefKey(linkRefFromOverrideColumns(row)), storedLinkOverride(row)] as const
       )
     )
+    const slotOverrides = new Map(
+      slotOverrideRows.map((row) => {
+        const stored = storedLinkSlotOverride(row)
+        return [linkScopeSortKey(stored.ref.source, stored.ref.linkId), stored] as const
+      })
+    )
     return refs.map((ref) => {
       const key = linkRefKey(ref)
       const effectiveRow = effective.get(key)
@@ -329,6 +357,7 @@ export class PgMaterializationStateReader {
         ref: structuredClone(ref),
         source: sourceLink(sources.get(projectionEntityKey({ kind: "link", ref }))),
         override: overrides.get(key) ?? null,
+        slotOverride: slotOverrides.get(linkScopeSortKey(ref.source, ref.linkId)) ?? null,
         effective: effectiveRow ? effectiveLinkSnapshot(effectiveRow) : null,
       }
     })
@@ -390,15 +419,63 @@ export class PgMaterializationStateReader {
     const accumulators = new Map(
       scopes.map(({ source, linkId }) => {
         const key = linkScopeSortKey(source, linkId)
-        return [key, startScopeAccumulator(source, linkId, key)] as const
+        return [key, startScopeAccumulator(source, linkId)] as const
       })
     )
+    const requestedParameter = jsonParameter(this.sql, requested)
+    const [sourceRows, slotOverrideRows] = await Promise.all([
+      this.sql<PgOntologySourceAssertionRow[]>`
+        WITH requested AS (
+          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
+            AS requested_values(
+              scope_sort_key TEXT, source_type_id TEXT, source_id TEXT, link_id TEXT
+            )
+        )
+        SELECT rows.*
+        FROM ontology_source_rows AS rows
+        JOIN requested
+          ON requested.source_type_id = rows.source_type_id
+         AND requested.source_id = rows.source_primary_id
+         AND requested.link_id = rows.link_id
+        JOIN ontology_sources AS sources
+          ON sources.project_id = rows.project_id
+         AND sources.source_id = rows.source_id
+         AND sources.materialization_id = rows.materialization_id
+        WHERE rows.project_id = ${this.projectId}
+          AND rows.entity_kind = 'link'
+          AND sources.status = 'active'
+      `,
+      this.sql<LinkSlotOverrideRow[]>`
+        WITH requested AS (
+          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
+            AS requested_values(
+              scope_sort_key TEXT, source_type_id TEXT, source_id TEXT, link_id TEXT
+            )
+        )
+        SELECT overrides.*
+        FROM ontology_link_overrides AS overrides
+        JOIN requested
+          ON requested.source_type_id = overrides.source_type_id
+         AND requested.source_id = overrides.source_primary_id
+         AND requested.link_id = overrides.link_id
+        WHERE overrides.project_id = ${this.projectId}
+          AND overrides.identity_kind = 'slot'
+      `,
+    ])
+    const sources = activeScopeSourceMap(sourceRows)
+    const overrides = new Map(
+      slotOverrideRows.map((row) => {
+        const stored = storedLinkSlotOverride(row)
+        return [linkScopeSortKey(stored.ref.source, stored.ref.linkId), stored] as const
+      })
+    )
+    const effective = new Map<string, EffectiveLinkSnapshot | null>()
     let scopeCursor: string | null = null
     let linkCursor: string | null = null
     while (true) {
       const rows: LinkScopeRow[] = await this.sql`
         WITH requested AS (
-          SELECT DISTINCT * FROM jsonb_to_recordset(${jsonParameter(this.sql, requested)})
+          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
             AS requested_values(
               scope_sort_key TEXT, source_type_id TEXT, source_id TEXT, link_id TEXT
             )
@@ -423,16 +500,24 @@ export class PgMaterializationStateReader {
             `Unexpected link scope '${row.scope_sort_key}' returned by storage.`
           )
         }
-        appendScopeSnapshot(accumulator, effectiveLinkSnapshot(row))
+        const snapshot = effectiveLinkSnapshot(row)
+        appendScopeSnapshot(accumulator, snapshot)
+        effective.set(row.scope_sort_key, accumulator.effectiveCount === 1 ? snapshot : null)
       }
       if (rows.length < 500) break
       const last: LinkScopeRow = rows[rows.length - 1]!
       scopeCursor = last.scope_sort_key
       linkCursor = last.link_sort_key
     }
-    return scopes.map(({ source, linkId }) =>
-      finishScopeAccumulator(accumulators.get(linkScopeSortKey(source, linkId))!)
-    )
+    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,
+      }
+    })
   }
 
   async linkScope(
@@ -485,20 +570,20 @@ export class PgMaterializationStateReader {
           SELECT overrides.source_type_id, overrides.source_primary_id AS source_id,
             overrides.link_id, overrides.target_type_id,
             overrides.target_primary_id AS target_id
-          FROM ontology_overrides AS overrides
+          FROM ontology_link_overrides AS overrides
           JOIN requested
             ON requested.object_type_id = overrides.source_type_id
            AND requested.primary_id = overrides.source_primary_id
-          WHERE overrides.project_id = ${this.projectId} AND overrides.entity_kind = 'link'
+          WHERE overrides.project_id = ${this.projectId}
           UNION
           SELECT overrides.source_type_id, overrides.source_primary_id AS source_id,
             overrides.link_id, overrides.target_type_id,
             overrides.target_primary_id AS target_id
-          FROM ontology_overrides AS overrides
+          FROM ontology_link_overrides AS overrides
           JOIN requested
             ON requested.object_type_id = overrides.target_type_id
            AND requested.primary_id = overrides.target_primary_id
-          WHERE overrides.project_id = ${this.projectId} AND overrides.entity_kind = 'link'
+          WHERE overrides.project_id = ${this.projectId}
           UNION
           SELECT rows.source_type_id, rows.source_primary_id AS source_id,
             rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
@@ -609,6 +694,7 @@ export class PgMaterializationStateReader {
           ? sourceLink(candidate?.get(key))
           : state.source,
         override: state.override,
+        slotOverride: state.slotOverride,
         effective: state.effective,
         diffRequired: identities[index]!.diffRequired,
       }
@@ -701,16 +787,6 @@ export class PgMaterializationStateReader {
     )
   }
 
-  async overrideLastCommit(kind: "object" | "link", entityKey: string): Promise<string | null> {
-    const [row] = await this.sql<{ readonly last_commit_id: string }[]>`
-      SELECT last_commit_id FROM ontology_overrides
-      WHERE project_id = ${this.projectId}
-        AND entity_kind = ${kind}
-        AND entity_key = ${jsonKeyParameter(this.sql, entityKey)}
-    `
-    return row?.last_commit_id ?? null
-  }
-
   private async replacementSources(
     sourceId: string,
     materializationIds: readonly string[],
@@ -824,20 +900,20 @@ export class PgMaterializationStateReader {
         SELECT overrides.source_type_id, overrides.source_primary_id AS source_id,
           overrides.link_id, overrides.target_type_id,
           overrides.target_primary_id AS target_id
-        FROM ontology_overrides AS overrides
+        FROM ontology_link_overrides AS overrides
         JOIN incident_objects
           ON incident_objects.object_type_id = overrides.source_type_id
          AND incident_objects.primary_id = overrides.source_primary_id
-        WHERE overrides.project_id = ${this.projectId} AND overrides.entity_kind = 'link'
+        WHERE overrides.project_id = ${this.projectId}
         UNION
         SELECT overrides.source_type_id, overrides.source_primary_id AS source_id,
           overrides.link_id, overrides.target_type_id,
           overrides.target_primary_id AS target_id
-        FROM ontology_overrides AS overrides
+        FROM ontology_link_overrides AS overrides
         JOIN incident_objects
           ON incident_objects.object_type_id = overrides.target_type_id
          AND incident_objects.primary_id = overrides.target_primary_id
-        WHERE overrides.project_id = ${this.projectId} AND overrides.entity_kind = 'link'
+        WHERE overrides.project_id = ${this.projectId}
         UNION
         SELECT rows.source_type_id, rows.source_primary_id AS source_id,
           rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
@@ -879,6 +955,16 @@ export class PgMaterializationStateReader {
         FROM links
         JOIN affected_scopes USING (source_type_id, source_id, link_id)
         WHERE links.project_id = ${this.projectId}
+        UNION ALL
+        SELECT overrides.source_type_id, overrides.source_primary_id AS source_id,
+          overrides.link_id, overrides.target_type_id,
+          overrides.target_primary_id AS target_id, FALSE AS diff_required
+        FROM ontology_link_overrides AS overrides
+        JOIN affected_scopes
+          ON affected_scopes.source_type_id = overrides.source_type_id
+         AND affected_scopes.source_id = overrides.source_primary_id
+         AND affected_scopes.link_id = overrides.link_id
+        WHERE overrides.project_id = ${this.projectId} AND overrides.identity_kind = 'slot'
       ), selected AS (
         SELECT source_type_id, source_id, link_id, target_type_id, target_id,
           ${this.sql.unsafe(linkKeyExpression("all_links"))} AS identity_key,
@@ -939,6 +1025,26 @@ function activeSourceMap(
   return result
 }
 
+function activeScopeSourceMap(
+  rows: readonly PgOntologySourceAssertionRow[]
+): ReadonlyMap<string, StoredSourceLinkAssertion> {
+  const result = new Map<string, StoredSourceLinkAssertion>()
+  for (const row of rows) {
+    const source = sourceLink(storedSource(row))
+    if (!source) continue
+    const ref = source.assertion.ref
+    const key = linkScopeSortKey(ref.source, ref.linkId)
+    if (result.has(key)) {
+      throw new MaterializationConflictError(
+        "source-materialization",
+        `Multiple active sources assert cardinality-one link slot ${key}.`
+      )
+    }
+    result.set(key, source)
+  }
+  return result
+}
+
 function sourceObject(
   source: StoredSourceAssertion | undefined
 ): StoredSourceObjectAssertion | null {
@@ -969,6 +1075,19 @@ function storedLinkOverride(row: LinkOverrideRow): StoredLinkOverride {
   }
 }
 
+function storedLinkSlotOverride(row: LinkSlotOverrideRow): StoredLinkSlotOverride {
+  const ref = {
+    source: { objectTypeId: row.source_type_id, primaryId: row.source_primary_id },
+    linkId: row.link_id,
+  }
+  return {
+    ref,
+    value: linkSlotOverrideValue(row.value, linkScopeLabel(ref)),
+    lastCommitId: row.last_commit_id,
+    updatedAt: toIsoString(row.updated_at),
+  }
+}
+
 function linkRefFromOverrideColumns(row: LinkOverrideRow): OntologyLinkRef {
   return {
     source: { objectTypeId: row.source_type_id, primaryId: row.source_primary_id },
@@ -977,6 +1096,13 @@ function linkRefFromOverrideColumns(row: LinkOverrideRow): OntologyLinkRef {
   }
 }
 
+function linkScopeLabel(scope: {
+  readonly source: OntologyObjectRef
+  readonly linkId: string
+}): string {
+  return JSON.stringify([scope.source.objectTypeId, scope.source.primaryId, scope.linkId])
+}
+
 function storedSource(row: PgOntologySourceAssertionRow): StoredSourceAssertion {
   return {
     source: { projectionId: row.source_id },
@@ -1090,16 +1216,6 @@ function linkKeyExpression(alias?: string): string {
   ])
 }
 
-export function pointSortExpression(alias?: string): string {
-  const prefix = alias ? `${alias}.` : ""
-  return utf8SortExpression([
-    `to_jsonb(${prefix}object_type_id)::text`,
-    `to_jsonb(${prefix}object_id)::text`,
-    `to_jsonb(${prefix}property_id)::text`,
-    `to_jsonb(to_char(${prefix}at AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'))::text`,
-  ])
-}
-
 function utf8SortExpression(parts: readonly string[]): string {
   return `encode(convert_to(${jsonTupleExpression(parts)}, 'UTF8'), 'hex')`
 }

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

@@ -4,11 +4,7 @@ import {
   objectRefKey,
   telemetryPointKey,
 } from "@sixb/core/internal/materialization"
-import {
-  effectiveConflict,
-  type OverrideEntity,
-  overrideEntityColumns as overrideColumns,
-} from "@sixb/core/internal/ontology-storage-provider"
+import { effectiveConflict } from "@sixb/core/internal/ontology-storage-provider"
 import type { MaterializationPlanChunk } from "@sixb/core/storage"
 import type { SQLClient } from "../pg-client"
 import { assertTimestamp, jsonParameter } from "./shared"
@@ -25,82 +21,171 @@ export class PgMaterializationWriter {
   }
 
   private async applyOverrides(projectId: string, chunk: MaterializationPlanChunk): Promise<void> {
-    const upserts = [
-      ...chunk.overrides.objectUpserts.map((item) =>
-        overrideWrite({ kind: "object", ref: item.ref }, item)
-      ),
-      ...chunk.overrides.linkUpserts.map((item) =>
-        overrideWrite({ kind: "link", ref: item.ref }, item)
-      ),
-    ]
-    const inserts = upserts.filter((item) => item.expectedLastCommitId === null)
-    if (inserts.length > 0) {
-      const rows = await this.sql<{ readonly entity_kind: "object" | "link" }[]>`
+    const objectUpserts = chunk.overrides.objects.upserts.map((item) => ({
+      objectTypeId: item.ref.objectTypeId,
+      primaryId: item.ref.primaryId,
+      value: item.value,
+      lastCommitId: item.lastCommitId,
+      updatedAt: item.updatedAt,
+      expectedLastCommitId: item.expectedLastCommitId,
+    }))
+    const objectInserts = objectUpserts.filter((item) => item.expectedLastCommitId === null)
+    if (objectInserts.length > 0) {
+      const rows = await this.sql<{ readonly object_type_id: string }[]>`
         WITH staged AS (
-          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, inserts)}::jsonb)
+          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, objectInserts)}::jsonb)
         )
-        INSERT INTO ontology_overrides (
-          project_id, entity_kind, entity_key, entity_sort_key,
-          object_type_id, primary_id, source_type_id, source_primary_id,
-          link_id, target_type_id, target_primary_id,
-          value, last_commit_id, updated_at
+        INSERT INTO ontology_object_overrides (
+          project_id, object_type_id, primary_id, value, last_commit_id, updated_at
         )
-        SELECT ${projectId}, value->>'kind', value->'entityKey', value->>'sortKey',
-          value->>'objectTypeId', value->>'primaryId', value->>'sourceTypeId',
-          value->>'sourcePrimaryId', value->>'linkId', value->>'targetTypeId',
-          value->>'targetPrimaryId', value->'value', value->>'lastCommitId',
+        SELECT ${projectId}, value->>'objectTypeId', value->>'primaryId', value->'value',
+          value->>'lastCommitId',
           (value->>'updatedAt')::timestamptz
         FROM staged
         ON CONFLICT DO NOTHING
-        RETURNING entity_kind
+        RETURNING object_type_id
       `
-      if (rows.length !== inserts.length) throw overrideConflict(inserts[0]!.kind)
+      if (rows.length !== objectInserts.length) throw objectOverrideConflict()
     }
 
-    const updates = upserts.filter((item) => item.expectedLastCommitId !== null)
-    if (updates.length > 0) {
-      const rows = await this.sql<{ readonly entity_kind: "object" | "link" }[]>`
+    const objectUpdates = objectUpserts.filter((item) => item.expectedLastCommitId !== null)
+    if (objectUpdates.length > 0) {
+      const rows = await this.sql<{ readonly object_type_id: string }[]>`
         WITH staged AS (
-          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, updates)}::jsonb)
+          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, objectUpdates)}::jsonb)
         )
-        UPDATE ontology_overrides AS overrides
+        UPDATE ontology_object_overrides AS overrides
         SET value = staged.value->'value', last_commit_id = staged.value->>'lastCommitId',
           updated_at = (staged.value->>'updatedAt')::timestamptz
         FROM staged
         WHERE overrides.project_id = ${projectId}
-          AND overrides.entity_kind = staged.value->>'kind'
-          AND overrides.entity_key = staged.value->'entityKey'
+          AND overrides.object_type_id = staged.value->>'objectTypeId'
+          AND overrides.primary_id = staged.value->>'primaryId'
+          AND overrides.last_commit_id = staged.value->>'expectedLastCommitId'
+        RETURNING overrides.object_type_id
+      `
+      if (rows.length !== objectUpdates.length) throw objectOverrideConflict()
+    }
+
+    const objectDeletes = chunk.overrides.objects.deletes.map((item) => ({
+      objectTypeId: item.ref.objectTypeId,
+      primaryId: item.ref.primaryId,
+      expectedLastCommitId: item.expectedLastCommitId,
+    }))
+    if (objectDeletes.length > 0) {
+      const rows = await this.sql<{ readonly object_type_id: string }[]>`
+        WITH staged AS (
+          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, objectDeletes)}::jsonb)
+        )
+        DELETE FROM ontology_object_overrides AS overrides USING staged
+        WHERE overrides.project_id = ${projectId}
+          AND overrides.object_type_id = staged.value->>'objectTypeId'
+          AND overrides.primary_id = staged.value->>'primaryId'
+          AND overrides.last_commit_id = staged.value->>'expectedLastCommitId'
+        RETURNING overrides.object_type_id
+      `
+      if (rows.length !== objectDeletes.length) throw objectOverrideConflict()
+    }
+
+    const linkUpserts = [
+      ...chunk.overrides.links.edges.upserts.map((item) => ({
+        identityKind: "edge" as const,
+        identityKey: JSON.parse(linkRefKey(item.ref)) as unknown,
+        sourceTypeId: item.ref.source.objectTypeId,
+        sourcePrimaryId: item.ref.source.primaryId,
+        linkId: item.ref.linkId,
+        targetTypeId: item.ref.target.objectTypeId,
+        targetPrimaryId: item.ref.target.primaryId,
+        value: item.value,
+        lastCommitId: item.lastCommitId,
+        updatedAt: item.updatedAt,
+        expectedLastCommitId: item.expectedLastCommitId,
+      })),
+      ...chunk.overrides.links.slots.upserts.map((item) => ({
+        identityKind: "slot" as const,
+        identityKey: [item.ref.source.objectTypeId, item.ref.source.primaryId, item.ref.linkId],
+        sourceTypeId: item.ref.source.objectTypeId,
+        sourcePrimaryId: item.ref.source.primaryId,
+        linkId: item.ref.linkId,
+        targetTypeId: item.value.target.objectTypeId,
+        targetPrimaryId: item.value.target.primaryId,
+        value: item.value,
+        lastCommitId: item.lastCommitId,
+        updatedAt: item.updatedAt,
+        expectedLastCommitId: item.expectedLastCommitId,
+      })),
+    ]
+    const linkInserts = linkUpserts.filter((item) => item.expectedLastCommitId === null)
+    if (linkInserts.length > 0) {
+      const rows = await this.sql<{ readonly identity_kind: "edge" | "slot" }[]>`
+        WITH staged AS (
+          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, linkInserts)}::jsonb)
+        )
+        INSERT INTO ontology_link_overrides (
+          project_id, identity_kind, identity_key, source_type_id, source_primary_id, link_id,
+          target_type_id, target_primary_id, value, last_commit_id, updated_at
+        )
+        SELECT ${projectId}, value->>'identityKind', value->'identityKey',
+          value->>'sourceTypeId', value->>'sourcePrimaryId', value->>'linkId',
+          value->>'targetTypeId', value->>'targetPrimaryId', value->'value',
+          value->>'lastCommitId', (value->>'updatedAt')::timestamptz
+        FROM staged
+        ON CONFLICT DO NOTHING
+        RETURNING identity_kind
+      `
+      if (rows.length !== linkInserts.length)
+        throw linkOverrideConflict(linkInserts[0]!.identityKind)
+    }
+
+    const linkUpdates = linkUpserts.filter((item) => item.expectedLastCommitId !== null)
+    if (linkUpdates.length > 0) {
+      const rows = await this.sql<{ readonly identity_kind: "edge" | "slot" }[]>`
+        WITH staged AS (
+          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, linkUpdates)}::jsonb)
+        )
+        UPDATE ontology_link_overrides AS overrides
+        SET target_type_id = staged.value->>'targetTypeId',
+          target_primary_id = staged.value->>'targetPrimaryId',
+          value = staged.value->'value',
+          last_commit_id = staged.value->>'lastCommitId',
+          updated_at = (staged.value->>'updatedAt')::timestamptz
+        FROM staged
+        WHERE overrides.project_id = ${projectId}
+          AND overrides.identity_kind = staged.value->>'identityKind'
+          AND overrides.identity_key = staged.value->'identityKey'
           AND overrides.last_commit_id = staged.value->>'expectedLastCommitId'
-        RETURNING overrides.entity_kind
+        RETURNING overrides.identity_kind
       `
-      if (rows.length !== updates.length) throw overrideConflict(updates[0]!.kind)
+      if (rows.length !== linkUpdates.length)
+        throw linkOverrideConflict(linkUpdates[0]!.identityKind)
     }
 
-    const deletes = [
-      ...chunk.overrides.objectDeletes.map((item) => ({
-        kind: "object" as const,
-        entityKey: JSON.parse(objectRefKey(item.ref)) as unknown,
+    const linkDeletes = [
+      ...chunk.overrides.links.edges.deletes.map((item) => ({
+        identityKind: "edge" as const,
+        identityKey: JSON.parse(linkRefKey(item.ref)) as unknown,
         expectedLastCommitId: item.expectedLastCommitId,
       })),
-      ...chunk.overrides.linkDeletes.map((item) => ({
-        kind: "link" as const,
-        entityKey: JSON.parse(linkRefKey(item.ref)) as unknown,
+      ...chunk.overrides.links.slots.deletes.map((item) => ({
+        identityKind: "slot" as const,
+        identityKey: [item.ref.source.objectTypeId, item.ref.source.primaryId, item.ref.linkId],
         expectedLastCommitId: item.expectedLastCommitId,
       })),
     ]
-    if (deletes.length > 0) {
-      const rows = await this.sql<{ readonly entity_kind: "object" | "link" }[]>`
+    if (linkDeletes.length > 0) {
+      const rows = await this.sql<{ readonly identity_kind: "edge" | "slot" }[]>`
         WITH staged AS (
-          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, deletes)}::jsonb)
+          SELECT value FROM jsonb_array_elements(${jsonParameter(this.sql, linkDeletes)}::jsonb)
         )
-        DELETE FROM ontology_overrides AS overrides USING staged
+        DELETE FROM ontology_link_overrides AS overrides USING staged
         WHERE overrides.project_id = ${projectId}
-          AND overrides.entity_kind = staged.value->>'kind'
-          AND overrides.entity_key = staged.value->'entityKey'
+          AND overrides.identity_kind = staged.value->>'identityKind'
+          AND overrides.identity_key = staged.value->'identityKey'
           AND overrides.last_commit_id = staged.value->>'expectedLastCommitId'
-        RETURNING overrides.entity_kind
+        RETURNING overrides.identity_kind
       `
-      if (rows.length !== deletes.length) throw overrideConflict(deletes[0]!.kind)
+      if (rows.length !== linkDeletes.length)
+        throw linkOverrideConflict(linkDeletes[0]!.identityKind)
     }
   }
 
@@ -408,7 +493,7 @@ export class PgMaterializationWriter {
       INSERT INTO ontology_outbox (
         project_id, id, commit_id, commit_ordinal, envelope,
         available_at, attempts, lease_id, lease_expires_at,
-        published_at, last_error, created_at
+        published_at, last_failure, created_at
       )
       SELECT ${projectId}, value->>'id', ${commitId},
         (value->>'commitOrdinal')::bigint, value->'envelope',
@@ -426,30 +511,16 @@ export class PgMaterializationWriter {
   }
 }
 
-function overrideWrite(
-  entity: OverrideEntity,
-  item: {
-    readonly value: unknown
-    readonly lastCommitId: string
-    readonly updatedAt: string
-    readonly expectedLastCommitId: string | null
-  }
-) {
-  const key = entity.kind === "object" ? objectRefKey(entity.ref) : linkRefKey(entity.ref)
-  const columns = overrideColumns(entity)
-  return {
-    kind: entity.kind,
-    entityKey: JSON.parse(key) as unknown,
-    ...columns,
-    value: item.value,
-    lastCommitId: item.lastCommitId,
-    updatedAt: item.updatedAt,
-    expectedLastCommitId: item.expectedLastCommitId,
-  }
+function objectOverrideConflict(): MaterializationConflictError {
+  return effectiveConflict("Expected object override changed.")
 }
 
-function overrideConflict(kind: "object" | "link"): MaterializationConflictError {
-  return effectiveConflict(`Expected ${kind} override changed.`)
+function linkOverrideConflict(identityKind: "edge" | "slot"): MaterializationConflictError {
+  return effectiveConflict(
+    identityKind === "edge"
+      ? "Expected link edge override changed."
+      : "Expected link slot override changed."
+  )
 }
 
 function objectIdentityKey(item: {