@sixb/core 0.1.16 → 0.1.17

package/src/materializer/projections/replace.ts

@@ -23,6 +23,8 @@ import type {
   OntologyMaterializationStorage,
   OntologySourceRecord,
   OntologyStorage,
+  ReplacementPlanRef,
+  ReplacementPlanStatus,
 } from "../../storage/ontology"
 import type { MaterializerContext, MaterializerStorage } from "../context"
 import { replayCommitRecord, withSerializationRetry } from "../execution/commit-lifecycle"
@@ -34,7 +36,7 @@ import {
   type MaterializerExecution,
   prepareMaterializerExecution,
 } from "../execution/scope"
-import { drainStagedEvents, drainStagedWork } from "../execution/work-executor"
+import { applyStagedWork } from "../execution/work-executor"
 import type { MaterializerCommand } from "../materializer"
 import { throwIfAborted } from "../shared/abort"
 import {
@@ -51,7 +53,7 @@ import {
 } from "../shared/normalize"
 import { createProjectionRunMaterializationIdentity } from "../shared/projection-run"
 import { createProjectionEntryValidator } from "./entry-validator"
-import { planProjectionReplacement } from "./replacement-plan"
+import { type ProjectionReplacementPlanInput, planProjectionReplacement } from "./replacement-plan"
 import {
   type StagedProjectionMaterialization,
   stageProjectionMaterialization,
@@ -324,25 +326,68 @@ async function stageCandidateEntries(
   return stageProjectionMaterialization(context, { ...input, signal })
 }
 
+/**
+ * Rounds of planning a commit tolerates before it gives the delivery back: each round plans again
+ * only what changed under the previous one, and the next delivery resumes the same plan. A commit
+ * whose refresh finds few stale identities plans them in its own transaction instead, so a round
+ * ends with a commit unless writes keep changing many of the plan's inputs.
+ */
+const MAX_PLAN_ROUNDS = 3
+
 async function commitProjectionCandidate(
   context: MaterializerContext,
   command: PreparedProjectionReplacement,
   ready: ReadyProjectionReplacement
 ): Promise<ProjectionCommitResult> {
-  return withSerializationRetry(context, () =>
-    context.storage.transaction(
-      (storage) => executeProjectionTransaction(context, storage, command, ready),
-      { isolation: "serializable" }
+  const plans = context.storage.ontology.replacementPlans
+  const plan: ReplacementPlanRef = {
+    projectId: context.projectId,
+    source: command.source,
+    materializationId: ready.materializationId,
+    execution: command.execution,
+  }
+  // A resumed plan keeps the commit time it was opened with, since its planned rows and events
+  // carry that time; its session begins with the commit at exactly that time.
+  const { committedAt } = await plans.open({
+    ...plan,
+    commit: projectionCommit(context.projectId, command, ready.identity),
+  })
+  const commit = projectionCommit(context.projectId, command, { ...ready.identity, committedAt })
+  for (let round = 1; ; round += 1) {
+    await planProjectionReplacement(context, plans, plan, planInput(command, commit))
+    const attempt = await withSerializationRetry(context, () =>
+      context.storage.transaction(
+        (storage) => executeProjectionTransaction(context, storage, command, ready, commit, plan),
+        { isolation: "serializable" }
+      )
     )
-  )
+    if (attempt.kind === "committed") return attempt.result
+    if (round === MAX_PLAN_ROUNDS) {
+      throw new MaterializationConflictError(
+        "effective-state",
+        `Projection '${command.source.projectionId}' inputs kept changing while it was planned ` +
+          `(${attempt.unplanned} changed during the last of ${MAX_PLAN_ROUNDS} rounds).`
+      )
+    }
+  }
 }
 
+/**
+ * One commit transaction. `stale` commits only the refresh: the identities whose inputs changed
+ * since they were planned are unplanned, for the next round to plan again outside the transaction.
+ */
+type ProjectionCommitAttempt =
+  | { readonly kind: "committed"; readonly result: ProjectionCommitResult }
+  | { readonly kind: "stale"; readonly unplanned: number }
+
 async function executeProjectionTransaction(
   context: MaterializerContext,
   storage: MaterializerStorage,
   command: PreparedProjectionReplacement,
-  ready: ReadyProjectionReplacement
-): Promise<ProjectionCommitResult> {
+  ready: ReadyProjectionReplacement,
+  commit: OntologyCommitWrite,
+  plan: ReplacementPlanRef
+): Promise<ProjectionCommitAttempt> {
   await ensureMaterializerExecution(storage.executions, command.scopeExecution)
   await assertProjectionExecution(storage, context.projectId, command)
   const replay = await replayCommitRecord(
@@ -351,7 +396,7 @@ async function executeProjectionTransaction(
     command.scopeExecution.executionId,
     storage
   )
-  if (replay) return projectionReplayResult(replay, command)
+  if (replay) return { kind: "committed", result: projectionReplayResult(replay, command) }
 
   if (command.base) {
     const active = await storage.ontology.sources.getActive({
@@ -361,10 +406,11 @@ async function executeProjectionTransaction(
     validateProjectionWatermark(active, command.datasetVersion)
     assertDeltaBase(active, command)
   }
-  const origin = projectionOrigin(command)
   throwIfAborted(command.signal)
+  const status = await refreshProjectionPlan(context, storage, command, commit, plan)
+  if (!status.fresh) return { kind: "stale", unplanned: status.unplanned }
   const session = await storage.ontology.materializations.begin({
-    commit: projectionCommit(context.projectId, command, ready.identity, origin),
+    commit,
     expected: {
       sources: [ready.expectedSource],
       objects: [],
@@ -372,33 +418,48 @@ async function executeProjectionTransaction(
       linkScopes: [],
       points: [],
     },
+    plan: { source: command.source, materializationId: ready.materializationId },
   })
-  const counts = await planReadyProjection(
-    context,
-    storage.ontology.materializations,
-    session,
-    command,
-    ready,
-    origin
-  )
-  await drainStagedWork(context, storage, session, command.signal, true)
-  const eventCount = await drainStagedEvents(
-    context,
-    storage.ontology.materializations,
-    session,
-    ready.identity,
-    command.signal
-  )
+  const eventCount = await applyStagedWork(context, storage, session, command.signal, true)
   const result: ProjectionCommitResult = {
     kind: "projection",
-    commitId: ready.identity.commitId,
+    commitId: commit.id,
     created: true,
     eventCount,
-    committedAt: ready.identity.committedAt,
-    counts,
+    committedAt: commit.committedAt,
+    counts: status.counts,
   }
   throwIfAborted(command.signal)
-  return finalizeProjectionMaterialization(storage, session, command, ready, result)
+  return {
+    kind: "committed",
+    result: await finalizeProjectionMaterialization(
+      storage,
+      session,
+      command,
+      ready,
+      commit,
+      result
+    ),
+  }
+}
+
+/**
+ * Refreshes the plan within the commit transaction. When it finds no more stale identities than
+ * the transaction may plan itself, they are planned here: nothing can change them again before the
+ * commit, so the second refresh finds the plan fresh.
+ */
+async function refreshProjectionPlan(
+  context: MaterializerContext,
+  storage: MaterializerStorage,
+  command: PreparedProjectionReplacement,
+  commit: OntologyCommitWrite,
+  plan: ReplacementPlanRef
+): Promise<ReplacementPlanStatus> {
+  const plans = storage.ontology.replacementPlans
+  const status = await plans.refresh(plan)
+  if (status.fresh || status.unplanned > context.batching.transactionReplanRows) return status
+  await planProjectionReplacement(context, plans, plan, planInput(command, commit))
+  return plans.refresh(plan)
 }
 
 async function finalizeProjectionMaterialization(
@@ -406,12 +467,13 @@ async function finalizeProjectionMaterialization(
   session: Parameters<OntologyMaterializationStorage["finalize"]>[0]["session"],
   command: PreparedProjectionReplacement,
   ready: ReadyProjectionReplacement,
+  commit: OntologyCommitWrite,
   result: ProjectionCommitResult
 ): Promise<ProjectionCommitResult> {
   const applied = await storage.ontology.materializations.finalize({
     session,
     finalization: {
-      sourceActivations: [projectionActivation(command, ready)],
+      sourceActivations: [projectionActivation(command, ready, commit)],
       result,
     },
   })
@@ -431,8 +493,7 @@ function projectionOrigin(command: PreparedProjectionReplacement): OntologyMater
 function projectionCommit(
   projectId: string,
   command: PreparedProjectionReplacement,
-  identity: TimedCommitIdentity,
-  origin: OntologyMaterializationOrigin
+  identity: TimedCommitIdentity
 ): OntologyCommitWrite {
   return {
     projectId,
@@ -440,8 +501,7 @@ function projectionCommit(
     idempotencyKey: identity.idempotencyKey,
     requestHash: identity.requestHash,
     executionId: command.scopeExecution.executionId,
-    origin,
-    ...command.scopeExecution.attribution,
+    origin: projectionOrigin(command),
     ontologyRevision: command.runIdentity.ontologyRevision,
     projectionRevision: command.runIdentity.projectionRevision,
     ownershipHash: command.runIdentity.ownershipHash,
@@ -450,35 +510,18 @@ function projectionCommit(
   }
 }
 
-async function planReadyProjection(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: Parameters<OntologyMaterializationStorage["finalize"]>[0]["session"],
+function planInput(
   command: PreparedProjectionReplacement,
-  ready: ReadyProjectionReplacement,
-  origin: OntologyMaterializationOrigin
-) {
-  const input = {
-    source: command.source,
-    materializationId: ready.materializationId,
-    projectionKind: command.projectionKind,
-    identity: ready.identity,
-    origin,
-    correlationId: command.scopeExecution.correlationId,
-    attribution: command.scopeExecution.attribution,
-  }
-  if (command.signal === undefined) {
-    return planProjectionReplacement(context, storage, session, input)
-  }
-  return planProjectionReplacement(context, storage, session, {
-    ...input,
-    signal: command.signal,
-  })
+  commit: OntologyCommitWrite
+): ProjectionReplacementPlanInput {
+  const input = { projectionKind: command.projectionKind, commit }
+  return command.signal === undefined ? input : { ...input, signal: command.signal }
 }
 
 function projectionActivation(
   command: PreparedProjectionReplacement,
-  ready: ReadyProjectionReplacement
+  ready: ReadyProjectionReplacement,
+  commit: OntologyCommitWrite
 ) {
   return {
     source: command.source,
@@ -491,8 +534,8 @@ function projectionActivation(
     ownershipHash: command.runIdentity.ownershipHash,
     ontologyRevision: command.runIdentity.ontologyRevision,
     expected: ready.expectedSource,
-    lastCommitId: ready.identity.commitId,
-    updatedAt: ready.identity.committedAt,
+    lastCommitId: commit.id,
+    updatedAt: commit.committedAt,
   }
 }
 

package/src/materializer/projections/replacement-plan.ts

@@ -1,26 +1,22 @@
-import type {
-  EffectiveChangeCounts,
-  EffectiveLinkChange,
-  EffectiveObjectChange,
-  OntologyMaterializationOrigin,
-  OntologyObjectRef,
-  ProjectionSourceRef,
-} from "../../materialization/model"
+import type { EffectiveLinkChange, EffectiveObjectChange } from "../../materialization/model"
 import {
   linkRefKey,
   linkRefSortKey,
   linkScopeSortKey,
   objectRefKey,
   objectRefSortKey,
+  utf8JsonByteLength,
 } from "../../materialization/refs"
 import type {
   MaterializationPlanWorkItem,
-  MaterializationSession,
   MaterializationWorkRecord,
-  OntologyMaterializationStorage,
+  OntologyCommitWrite,
+  OntologyReplacementPlanStorage,
+  PlannedReplacementIdentity,
+  ReplacementPlanRef,
   SourceReplacementLinkState,
   SourceReplacementObjectState,
-  SourceReplacementStatePage,
+  StageReplacementPlanInput,
 } from "../../storage/ontology"
 import type { MaterializerContext } from "../context"
 import {
@@ -28,7 +24,6 @@ import {
   buildObjectMaterializationEventDraft,
 } from "../effective/build-events"
 import { diffEffectiveLink, diffEffectiveObject } from "../effective/diff"
-import { oneStateRequest } from "../effective/load-state"
 import {
   resolveEffectiveLink,
   resolveEffectiveLinkSlotMember,
@@ -37,8 +32,6 @@ import {
   usableLinkSlotOverride,
 } from "../effective/resolve"
 import { validateEffectiveObject } from "../effective/validate"
-import type { MaterializerAttribution } from "../execution/scope"
-import { stageWorkBounded, validateStagedCardinality } from "../execution/work-executor"
 import {
   appendEffectiveLinkWork,
   appendEffectiveObjectWork,
@@ -47,72 +40,84 @@ import {
   planWork,
 } from "../execution/work-records"
 import { throwIfAborted } from "../shared/abort"
-import type { TimedCommitIdentity } from "../shared/identity"
+import { chunkBySize } from "../shared/chunking"
 
 export interface ProjectionReplacementPlanInput {
-  readonly source: ProjectionSourceRef
-  readonly materializationId: string
   readonly projectionKind: "object" | "link"
-  readonly identity: TimedCommitIdentity
-  readonly origin: OntologyMaterializationOrigin
-  readonly correlationId: string
-  readonly attribution: MaterializerAttribution
+  /** The commit the plan carries, timed as the plan was opened. */
+  readonly commit: OntologyCommitWrite
   readonly signal?: AbortSignal
 }
 
+/**
+ * Plans every identity of the candidate's durable plan still to plan, outside any transaction.
+ * Objects come first: a link resolves against the existence its endpoints are planned to have.
+ */
 export async function planProjectionReplacement(
   context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
+  plans: OntologyReplacementPlanStorage,
+  plan: ReplacementPlanRef,
   input: ProjectionReplacementPlanInput
-): Promise<EffectiveChangeCounts> {
-  const counts = emptyCounts()
+): Promise<void> {
+  const staged = { ...plan, commit: input.commit }
   if (input.projectionKind === "object") {
-    await planObjectReplacement(context, storage, session, input, counts)
+    for await (const page of plans.streamState({
+      ...plan,
+      entityKind: "object",
+      pageRows: context.batching.statePageRows,
+    })) {
+      throwIfAborted(input.signal)
+      await stagePlanned(
+        context,
+        plans,
+        staged,
+        page.objects.map((state) => ({
+          identity: { kind: "object", ref: state.ref },
+          records: planReplacementObject(context, input, state),
+        }))
+      )
+    }
   }
-  await planLinkReplacement(context, storage, session, input, counts)
-  await validateStagedCardinality(context, storage, session, input.signal)
-  return counts
-}
-
-async function planObjectReplacement(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
-  input: ProjectionReplacementPlanInput,
-  counts: MutableCounts
-): Promise<void> {
-  for await (const page of storage.streamSourceReplacementState({
-    session,
-    source: input.source,
-    candidateMaterializationId: input.materializationId,
-    entityKind: "object",
+  for await (const page of plans.streamState({
+    ...plan,
+    entityKind: "link",
     pageRows: context.batching.statePageRows,
   })) {
     throwIfAborted(input.signal)
-    const work = planObjectPage(context, input, page, counts)
-    await stageWorkBounded(context, storage, session, work)
+    const endpoints = new Map(
+      page.endpoints.map((endpoint) => [objectRefKey(endpoint.ref), endpoint.exists] as const)
+    )
+    await stagePlanned(
+      context,
+      plans,
+      staged,
+      page.links.map((state) => ({
+        identity: { kind: "link", ref: state.ref },
+        records: planReplacementLink(context, input, state, endpoints),
+      }))
+    )
   }
 }
 
-function planObjectPage(
-  context: MaterializerContext,
-  input: ProjectionReplacementPlanInput,
-  page: SourceReplacementStatePage,
-  counts: MutableCounts
-): MaterializationWorkRecord[] {
-  const work: MaterializationWorkRecord[] = []
-  for (const state of page.objects) {
-    work.push(...planReplacementObject(context, input, state, counts))
+async function stagePlanned(
+  context: Pick<MaterializerContext, "batching">,
+  plans: OntologyReplacementPlanStorage,
+  plan: Omit<StageReplacementPlanInput, "planned">,
+  planned: readonly PlannedReplacementIdentity[]
+): Promise<void> {
+  for await (const chunk of chunkBySize(planned, {
+    maxRows: context.batching.planChunkRows,
+    maxBytes: context.batching.planChunkBytes,
+    byteLength: (value) => utf8JsonByteLength(value.records),
+  })) {
+    await plans.stage({ ...plan, planned: chunk })
   }
-  return work
 }
 
 function planReplacementObject(
   context: MaterializerContext,
   input: ProjectionReplacementPlanInput,
-  state: SourceReplacementObjectState,
-  counts: MutableCounts
+  state: SourceReplacementObjectState
 ): MaterializationWorkRecord[] {
   const resolved = resolveReplacementObject(context, state)
   if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
@@ -120,8 +125,8 @@ function planReplacementObject(
   const change = diffEffectiveObject({
     before: state.effective,
     resolved,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt,
+    commitId: input.commit.id,
+    committedAt: input.commit.committedAt,
   })
   const sortKey = objectRefSortKey(state.ref)
   const work: MaterializationWorkRecord[] = [
@@ -137,131 +142,27 @@ function planReplacementObject(
     work.push({ kind: "incident-object", recordKey: `incident:${sortKey}`, ref: state.ref })
   }
 
-  if (!change) {
-    counts.objectsUnchanged += 1
-    return work
-  }
-
-  incrementObjectCount(counts, change.kind)
-  appendObjectChangeWork(work, sortKey, context, input, change)
+  if (!change) return work
+  appendObjectChangeWork(work, sortKey, change)
   return work
 }
 
 function appendObjectChangeWork(
   work: MaterializationWorkRecord[],
   sortKey: string,
-  context: Pick<MaterializerContext, "projectId">,
-  input: ProjectionReplacementPlanInput,
   change: EffectiveObjectChange
 ): void {
   const items: MaterializationPlanWorkItem[] = []
   appendEffectiveObjectWork(items, change)
   for (const item of items) work.push(planWork(item, sortKey))
-  work.push(
-    eventWork(
-      buildObjectMaterializationEventDraft({
-        projectId: context.projectId,
-        commitId: input.identity.commitId,
-        committedAt: input.identity.committedAt,
-        origin: input.origin,
-        correlationId: input.correlationId,
-        attribution: input.attribution,
-        change,
-      })
-    )
-  )
-}
-
-async function planLinkReplacement(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
-  input: ProjectionReplacementPlanInput,
-  counts: MutableCounts
-): Promise<void> {
-  for await (const page of storage.streamSourceReplacementState({
-    session,
-    source: input.source,
-    candidateMaterializationId: input.materializationId,
-    entityKind: "link",
-    pageRows: context.batching.statePageRows,
-  })) {
-    throwIfAborted(input.signal)
-    const endpointExistence = await loadEndpointExistence(context, storage, session, page)
-    const work = planLinkPage(context, input, page, endpointExistence, counts)
-    await stageWorkBounded(context, storage, session, work)
-  }
-}
-
-async function loadEndpointExistence(
-  context: MaterializerContext,
-  storage: OntologyMaterializationStorage,
-  session: MaterializationSession,
-  page: SourceReplacementStatePage
-): Promise<ReadonlyMap<string, boolean>> {
-  const endpointRefs = collectEndpointRefs(page.links)
-  const endpointExistence = new Map<string, boolean>()
-  for (const value of await storage.readObjectExistence({
-    session,
-    refs: [...endpointRefs.values()],
-  })) {
-    endpointExistence.set(objectRefKey(value.ref), value.exists)
-  }
-
-  const missingEndpoints = [...endpointRefs.values()].filter(
-    (ref) => !endpointExistence.has(objectRefKey(ref))
-  )
-  if (missingEndpoints.length === 0) return endpointExistence
-
-  for await (const endpointPage of storage.streamState({
-    session,
-    requests: oneStateRequest({
-      objects: missingEndpoints,
-      links: [],
-      linkScopes: [],
-      incidentObjects: [],
-      points: [],
-    }),
-    pageRows: context.batching.statePageRows,
-  })) {
-    for (const endpoint of endpointPage.objects) {
-      endpointExistence.set(objectRefKey(endpoint.ref), endpoint.effective !== null)
-    }
-  }
-  return endpointExistence
-}
-
-function collectEndpointRefs(
-  links: readonly SourceReplacementLinkState[]
-): ReadonlyMap<string, OntologyObjectRef> {
-  const refs = new Map<string, OntologyObjectRef>()
-  for (const state of links) {
-    refs.set(objectRefKey(state.ref.source), state.ref.source)
-    refs.set(objectRefKey(state.ref.target), state.ref.target)
-  }
-  return refs
-}
-
-function planLinkPage(
-  context: MaterializerContext,
-  input: ProjectionReplacementPlanInput,
-  page: SourceReplacementStatePage,
-  endpointExistence: ReadonlyMap<string, boolean>,
-  counts: MutableCounts
-): MaterializationWorkRecord[] {
-  const work: MaterializationWorkRecord[] = []
-  for (const state of page.links) {
-    work.push(...planReplacementLink(context, input, state, endpointExistence, counts))
-  }
-  return work
+  work.push(eventWork(buildObjectMaterializationEventDraft(change)))
 }
 
 function planReplacementLink(
   context: MaterializerContext,
   input: ProjectionReplacementPlanInput,
   state: SourceReplacementLinkState,
-  endpointExistence: ReadonlyMap<string, boolean>,
-  counts: MutableCounts
+  endpointExistence: ReadonlyMap<string, boolean>
 ): MaterializationWorkRecord[] {
   const resolved = resolveReplacementLink(context, state, endpointExistence)
   const work = cardinalityWork(context, state, resolved !== null)
@@ -270,18 +171,13 @@ function planReplacementLink(
   const change = diffEffectiveLink({
     before: state.effective,
     resolved,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt,
+    commitId: input.commit.id,
+    committedAt: input.commit.committedAt,
   })
   const sortKey = linkRefSortKey(state.ref)
   work.push(classificationWork("link", linkRefKey(state.ref), sortKey))
-  if (!change) {
-    counts.linksUnchanged += 1
-    return work
-  }
-
-  incrementLinkCount(counts, change.kind)
-  appendLinkChangeWork(work, sortKey, context, input, change)
+  if (!change) return work
+  appendLinkChangeWork(work, sortKey, change)
   return work
 }
 
@@ -348,26 +244,12 @@ function cardinalityWork(
 function appendLinkChangeWork(
   work: MaterializationWorkRecord[],
   sortKey: string,
-  context: Pick<MaterializerContext, "projectId">,
-  input: ProjectionReplacementPlanInput,
   change: EffectiveLinkChange
 ): void {
   const items: MaterializationPlanWorkItem[] = []
   appendEffectiveLinkWork(items, change)
   for (const item of items) work.push(planWork(item, sortKey))
-  work.push(
-    eventWork(
-      buildLinkMaterializationEventDraft({
-        projectId: context.projectId,
-        commitId: input.identity.commitId,
-        committedAt: input.identity.committedAt,
-        origin: input.origin,
-        correlationId: input.correlationId,
-        attribution: input.attribution,
-        change,
-      })
-    )
-  )
+  work.push(eventWork(buildLinkMaterializationEventDraft(change)))
 }
 
 function resolveReplacementObject(
@@ -383,30 +265,3 @@ function resolveReplacementObject(
     latestTelemetry: state.latestTelemetry,
   })
 }
-
-function emptyCounts(): MutableCounts {
-  return {
-    objectsCreated: 0,
-    objectsUpdated: 0,
-    objectsDeleted: 0,
-    objectsUnchanged: 0,
-    linksCreated: 0,
-    linksUpdated: 0,
-    linksDeleted: 0,
-    linksUnchanged: 0,
-  }
-}
-
-type MutableCounts = { -readonly [K in keyof EffectiveChangeCounts]: EffectiveChangeCounts[K] }
-
-function incrementObjectCount(counts: MutableCounts, kind: EffectiveObjectChange["kind"]): void {
-  if (kind === "created") counts.objectsCreated += 1
-  else if (kind === "updated") counts.objectsUpdated += 1
-  else counts.objectsDeleted += 1
-}
-
-function incrementLinkCount(counts: MutableCounts, kind: EffectiveLinkChange["kind"]): void {
-  if (kind === "created") counts.linksCreated += 1
-  else if (kind === "updated") counts.linksUpdated += 1
-  else counts.linksDeleted += 1
-}