@livestore/common 0.3.0-dev.28 → 0.3.0-dev.29

package/src/sync/ClientSessionSyncProcessor.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
 import type { Runtime, Scope } from '@livestore/utils/effect'
 import { BucketQueue, Effect, FiberHandle, Queue, Schema, Stream, Subscribable } from '@livestore/utils/effect'
@@ -5,17 +6,17 @@ import * as otel from '@opentelemetry/api'
 
 import type { ClientSession, UnexpectedError } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
-import { getMutationDef, LEADER_MERGE_COUNTER_TABLE, type LiveStoreSchema } from '../schema/mod.js'
-import * as MutationEvent from '../schema/MutationEvent.js'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
+import { getEventDef, LEADER_MERGE_COUNTER_TABLE, type LiveStoreSchema } from '../schema/mod.js'
 import { sql } from '../util.js'
 import * as SyncState from './syncstate.js'
 
 /**
  * Rebase behaviour:
- * - We continously pull mutations from the leader and apply them to the local store.
+ * - We continously pull events from the leader and apply them to the local store.
  * - If there was a race condition (i.e. the leader and client session have both advacned),
- *   we'll need to rebase the local pending mutations on top of the leader's head.
- * - The goal is to never block the UI, so we'll interrupt rebasing if a new mutations is pushed by the client session.
+ *   we'll need to rebase the local pending events on top of the leader's head.
+ * - The goal is to never block the UI, so we'll interrupt rebasing if a new events is pushed by the client session.
  * - We also want to avoid "backwards-jumping" in the UI, so we'll transactionally apply a read model changes during a rebase.
  * - We might need to make the rebase behaviour configurable e.g. to let users manually trigger a rebase
  *
@@ -25,7 +26,7 @@ export const makeClientSessionSyncProcessor = ({
   schema,
   clientSession,
   runtime,
-  applyMutation,
+  applyEvent,
   rollback,
   refreshTables,
   span,
@@ -35,8 +36,8 @@ export const makeClientSessionSyncProcessor = ({
   schema: LiveStoreSchema
   clientSession: ClientSession
   runtime: Runtime.Runtime<Scope.Scope>
-  applyMutation: (
-    mutationEventDecoded: MutationEvent.PartialAnyDecoded,
+  applyEvent: (
+    eventDecoded: LiveStoreEvent.PartialAnyDecoded,
     options: { otelContext: otel.Context; withChangeset: boolean },
   ) => {
     writeTables: Set<string>
@@ -54,36 +55,36 @@ export const makeClientSessionSyncProcessor = ({
    */
   confirmUnsavedChanges: boolean
 }): ClientSessionSyncProcessor => {
-  const mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema)
+  const eventSchema = LiveStoreEvent.makeEventDefSchemaMemo(schema)
 
   const syncStateRef = {
     // The initial state is identical to the leader's initial state
     current: new SyncState.SyncState({
       localHead: clientSession.leaderThread.initialState.leaderHead,
       upstreamHead: clientSession.leaderThread.initialState.leaderHead,
-      // Given we're starting with the leader's snapshot, we don't have any pending mutations intially
+      // Given we're starting with the leader's snapshot, we don't have any pending events intially
       pending: [],
     }),
   }
 
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
-  const isClientEvent = (mutationEventEncoded: MutationEvent.EncodedWithMeta) =>
-    getMutationDef(schema, mutationEventEncoded.mutation).options.clientOnly
+  const isClientEvent = (eventEncoded: LiveStoreEvent.EncodedWithMeta) =>
+    getEventDef(schema, eventEncoded.name).eventDef.options.clientOnly
 
   /** We're queuing push requests to reduce the number of messages sent to the leader by batching them */
-  const leaderPushQueue = BucketQueue.make<MutationEvent.EncodedWithMeta>().pipe(Effect.runSync)
+  const leaderPushQueue = BucketQueue.make<LiveStoreEvent.EncodedWithMeta>().pipe(Effect.runSync)
 
   const push: ClientSessionSyncProcessor['push'] = (batch, { otelContext }) => {
     // TODO validate batch
 
     let baseEventId = syncStateRef.current.localHead
-    const encodedMutationEvents = batch.map(({ mutation, args }) => {
-      const mutationDef = getMutationDef(schema, mutation)
-      const nextIdPair = EventId.nextPair(baseEventId, mutationDef.options.clientOnly)
+    const encodedEventDefs = batch.map(({ name, args }) => {
+      const eventDef = getEventDef(schema, name)
+      const nextIdPair = EventId.nextPair(baseEventId, eventDef.eventDef.options.clientOnly)
       baseEventId = nextIdPair.id
-      return new MutationEvent.EncodedWithMeta(
-        Schema.encodeUnknownSync(mutationEventSchema)({
-          mutation,
+      return new LiveStoreEvent.EncodedWithMeta(
+        Schema.encodeUnknownSync(eventSchema)({
+          name,
           args,
           ...nextIdPair,
           clientId: clientSession.clientId,
@@ -94,9 +95,9 @@ export const makeClientSessionSyncProcessor = ({
 
     const mergeResult = SyncState.merge({
       syncState: syncStateRef.current,
-      payload: { _tag: 'local-push', newEvents: encodedMutationEvents },
+      payload: { _tag: 'local-push', newEvents: encodedEventDefs },
       isClientEvent,
-      isEqualEvent: MutationEvent.isEqualEncoded,
+      isEqualEvent: LiveStoreEvent.isEqualEncoded,
     })
 
     if (mergeResult._tag === 'unexpected-error') {
@@ -104,7 +105,7 @@ export const makeClientSessionSyncProcessor = ({
     }
 
     span.addEvent('local-push', {
-      batchSize: encodedMutationEvents.length,
+      batchSize: encodedEventDefs.length,
       mergeResult: TRACE_VERBOSE ? JSON.stringify(mergeResult) : undefined,
     })
 
@@ -116,18 +117,18 @@ export const makeClientSessionSyncProcessor = ({
     syncStateUpdateQueue.offer(mergeResult.newSyncState).pipe(Effect.runSync)
 
     const writeTables = new Set<string>()
-    for (const mutationEvent of mergeResult.newEvents) {
+    for (const event of mergeResult.newEvents) {
       // TODO avoid encoding and decoding here again
-      const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
-      const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
+      const decodedEventDef = Schema.decodeSync(eventSchema)(event)
+      const res = applyEvent(decodedEventDef, { otelContext, withChangeset: true })
       for (const table of res.writeTables) {
         writeTables.add(table)
       }
-      mutationEvent.meta.sessionChangeset = res.sessionChangeset
+      event.meta.sessionChangeset = res.sessionChangeset
     }
 
-    // console.debug('pushToLeader', encodedMutationEvents.length, ...encodedMutationEvents.map((_) => _.toJSON()))
-    BucketQueue.offerAll(leaderPushQueue, encodedMutationEvents).pipe(Effect.runSync)
+    // console.debug('pushToLeader', encodedEventDefs.length, ...encodedEventDefs.map((_) => _.toJSON()))
+    BucketQueue.offerAll(leaderPushQueue, encodedEventDefs).pipe(Effect.runSync)
 
     return { writeTables }
   }
@@ -160,7 +161,7 @@ export const makeClientSessionSyncProcessor = ({
 
     const backgroundLeaderPushing = Effect.gen(function* () {
       const batch = yield* BucketQueue.takeBetween(leaderPushQueue, 1, params.leaderPushBatchSize)
-      yield* clientSession.leaderThread.mutations.push(batch).pipe(
+      yield* clientSession.leaderThread.events.push(batch).pipe(
         Effect.catchTag('LeaderAheadError', () => {
           debugInfo.rejectCount++
           return BucketQueue.clear(leaderPushQueue)
@@ -177,7 +178,7 @@ export const makeClientSessionSyncProcessor = ({
 
     // NOTE We need to lazily call `.pull` as we want the cursor to be updated
     yield* Stream.suspend(() =>
-      clientSession.leaderThread.mutations.pull({
+      clientSession.leaderThread.events.pull({
         cursor: { mergeCounter: getMergeCounter(), eventId: syncStateRef.current.localHead },
       }),
     ).pipe(
@@ -193,7 +194,7 @@ export const makeClientSessionSyncProcessor = ({
             syncState: syncStateRef.current,
             payload,
             isClientEvent,
-            isEqualEvent: MutationEvent.isEqualEncoded,
+            isEqualEvent: LiveStoreEvent.isEqualEncoded,
           })
 
           if (mergeResult._tag === 'unexpected-error') {
@@ -257,15 +258,15 @@ export const makeClientSessionSyncProcessor = ({
           if (mergeResult.newEvents.length === 0) return
 
           const writeTables = new Set<string>()
-          for (const mutationEvent of mergeResult.newEvents) {
+          for (const event of mergeResult.newEvents) {
             // TODO apply changeset if available (will require tracking of write tables as well)
-            const decodedMutationEvent = Schema.decodeSync(mutationEventSchema)(mutationEvent)
-            const res = applyMutation(decodedMutationEvent, { otelContext, withChangeset: true })
+            const decodedEventDef = Schema.decodeSync(eventSchema)(event)
+            const res = applyEvent(decodedEventDef, { otelContext, withChangeset: true })
             for (const table of res.writeTables) {
               writeTables.add(table)
             }
 
-            mutationEvent.meta.sessionChangeset = res.sessionChangeset
+            event.meta.sessionChangeset = res.sessionChangeset
           }
 
           refreshTables(writeTables)
@@ -314,7 +315,7 @@ export const makeClientSessionSyncProcessor = ({
 
 export interface ClientSessionSyncProcessor {
   push: (
-    batch: ReadonlyArray<MutationEvent.PartialAnyDecoded>,
+    batch: ReadonlyArray<LiveStoreEvent.PartialAnyDecoded>,
     options: { otelContext: otel.Context },
   ) => {
     writeTables: Set<string>

package/src/sync/next/facts.ts

@@ -1,20 +1,20 @@
 import { notYetImplemented } from '@livestore/utils'
 
-import type * as EventId from '../../schema/EventId.js'
 import type {
+  EventDefFactInput,
+  EventDefFacts,
+  EventDefFactsGroup,
+  EventDefFactsSnapshot,
   FactsCallback,
-  MutationEventFactInput,
-  MutationEventFacts,
-  MutationEventFactsGroup,
-  MutationEventFactsSnapshot,
-} from '../../schema/mutations.js'
+} from '../../schema/EventDef.js'
+import type * as EventId from '../../schema/EventId.js'
 import { graphologyDag } from './graphology_.js'
 import { EMPTY_FACT_VALUE, type HistoryDag, type HistoryDagNode } from './history-dag-common.js'
 
 export const factsSnapshotForEvents = (
   events: HistoryDagNode[],
   endEventId: EventId.EventId,
-): MutationEventFactsSnapshot => {
+): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
   for (const event of events) {
@@ -31,7 +31,7 @@ export const factsSnapshotForEvents = (
 export const factsSnapshotForDag = (
   dag: HistoryDag,
   endEventId: EventId.EventId | undefined,
-): MutationEventFactsSnapshot => {
+): EventDefFactsSnapshot => {
   const facts = new Map<string, any>()
 
   const orderedEventIdStrs = graphologyDag.topologicalSort(dag)
@@ -56,20 +56,20 @@ export type FactValidationResult =
       success: false
       /** Index of the item that caused the validation to fail */
       index: number
-      requiredFacts: MutationEventFacts
+      requiredFacts: EventDefFacts
       mismatch: {
-        existing: MutationEventFacts
-        required: MutationEventFacts
+        existing: EventDefFacts
+        required: EventDefFacts
       }
-      currentSnapshot: MutationEventFacts
+      currentSnapshot: EventDefFacts
     }
 
 export const validateFacts = ({
   factGroups,
   initialSnapshot,
 }: {
-  factGroups: MutationEventFactsGroup[]
-  initialSnapshot: MutationEventFactsSnapshot
+  factGroups: EventDefFactsGroup[]
+  initialSnapshot: EventDefFactsSnapshot
 }): FactValidationResult => {
   const currentSnapshot = new Map(initialSnapshot)
 
@@ -102,13 +102,13 @@ export const validateFacts = ({
   }
 }
 
-export const applyFactGroups = (factGroups: MutationEventFactsGroup[], snapshot: MutationEventFactsSnapshot) => {
+export const applyFactGroups = (factGroups: EventDefFactsGroup[], snapshot: EventDefFactsSnapshot) => {
   for (const factGroup of factGroups) {
     applyFactGroup(factGroup, snapshot)
   }
 }
 
-export const applyFactGroup = (factGroup: MutationEventFactsGroup, snapshot: MutationEventFactsSnapshot) => {
+export const applyFactGroup = (factGroup: EventDefFactsGroup, snapshot: EventDefFactsSnapshot) => {
   for (const [key, value] of factGroup.modifySet) {
     snapshot.set(key, value)
   }
@@ -119,7 +119,7 @@ export const applyFactGroup = (factGroup: MutationEventFactsGroup, snapshot: Mut
 }
 
 /** Check if setA is a subset of setB */
-const isSubSetMapByValue = (setA: MutationEventFacts, setB: MutationEventFacts) => {
+const isSubSetMapByValue = (setA: EventDefFacts, setB: EventDefFacts) => {
   for (const [key, value] of setA) {
     if (setB.get(key) !== value) {
       return false
@@ -129,7 +129,7 @@ const isSubSetMapByValue = (setA: MutationEventFacts, setB: MutationEventFacts)
 }
 
 /** Check if setA is a subset of setB */
-const isSubSetMapByKey = (setA: MutationEventFacts, setB: MutationEventFacts) => {
+const isSubSetMapByKey = (setA: EventDefFacts, setB: EventDefFacts) => {
   for (const [key, _value] of setA) {
     if (!setB.has(key)) {
       return false
@@ -139,17 +139,16 @@ const isSubSetMapByKey = (setA: MutationEventFacts, setB: MutationEventFacts) =>
 }
 
 /** Check if groupA depends on groupB */
-export const dependsOn = (groupA: MutationEventFactsGroup, groupB: MutationEventFactsGroup): boolean =>
+export const dependsOn = (groupA: EventDefFactsGroup, groupB: EventDefFactsGroup): boolean =>
   factsIntersect(groupA.depRead, groupB.modifySet) ||
   factsIntersect(groupA.depRead, groupB.modifyUnset) ||
   factsIntersect(groupA.depRequire, groupB.modifySet) ||
   factsIntersect(groupA.depRequire, groupB.modifyUnset)
 
-export const replacesFacts = (groupA: MutationEventFactsGroup, groupB: MutationEventFactsGroup): boolean => {
-  const replaces = (a: MutationEventFacts, b: MutationEventFacts) => a.size > 0 && b.size > 0 && isSameMapByKey(a, b)
+export const replacesFacts = (groupA: EventDefFactsGroup, groupB: EventDefFactsGroup): boolean => {
+  const replaces = (a: EventDefFacts, b: EventDefFacts) => a.size > 0 && b.size > 0 && isSameMapByKey(a, b)
 
-  const noFactsOrSame = (a: MutationEventFacts, b: MutationEventFacts) =>
-    a.size === 0 || b.size === 0 || isSameMapByKey(a, b)
+  const noFactsOrSame = (a: EventDefFacts, b: EventDefFacts) => a.size === 0 || b.size === 0 || isSameMapByKey(a, b)
 
   return (
     (replaces(groupA.modifySet, groupB.modifySet) && noFactsOrSame(groupA.modifyUnset, groupB.modifyUnset)) ||
@@ -159,16 +158,16 @@ export const replacesFacts = (groupA: MutationEventFactsGroup, groupB: MutationE
   )
 }
 
-export const isSameMapByKey = (set: MutationEventFacts, otherSet: MutationEventFacts) =>
+export const isSameMapByKey = (set: EventDefFacts, otherSet: EventDefFacts) =>
   set.size === otherSet.size && isSubSetMapByKey(set, otherSet)
 
-export const factsToString = (facts: MutationEventFacts) => {
+export const factsToString = (facts: EventDefFacts) => {
   return Array.from(facts)
     .map(([key, value]) => (value === EMPTY_FACT_VALUE ? key : `${key}=${value}`))
     .join(', ')
 }
 
-export const factsIntersect = (setA: MutationEventFacts, setB: MutationEventFacts): boolean => {
+export const factsIntersect = (setA: EventDefFacts, setB: EventDefFacts): boolean => {
   for (const [key, _value] of setA) {
     if (setB.has(key)) {
       return true
@@ -177,16 +176,16 @@ export const factsIntersect = (setA: MutationEventFacts, setB: MutationEventFact
   return false
 }
 
-export const getFactsGroupForMutationArgs = ({
+export const getFactsGroupForEventArgs = ({
   factsCallback,
   args,
   currentFacts,
 }: {
   factsCallback: FactsCallback<any> | undefined
   args: any
-  currentFacts: MutationEventFactsSnapshot
-}): MutationEventFactsGroup => {
-  const depRead: MutationEventFactsSnapshot = new Map<string, any>()
+  currentFacts: EventDefFactsSnapshot
+}): EventDefFactsGroup => {
+  const depRead: EventDefFactsSnapshot = new Map<string, any>()
   const factsSnapshotProxy = new Proxy(currentFacts, {
     get: (target, prop) => {
       if (prop === 'has') {
@@ -201,12 +200,12 @@ export const getFactsGroupForMutationArgs = ({
         }
       }
 
-      notYetImplemented(`getFactsGroupForMutationArgs: ${prop.toString()} is not yet implemented`)
+      notYetImplemented(`getFactsGroupForEventArgs: ${prop.toString()} is not yet implemented`)
     },
   })
 
   const factsRes = factsCallback?.(args, factsSnapshotProxy)
-  const iterableToMap = (iterable: Iterable<MutationEventFactInput>) => {
+  const iterableToMap = (iterable: Iterable<EventDefFactInput>) => {
     const map = new Map()
     for (const item of iterable) {
       if (typeof item === 'string') {

package/src/sync/next/history-dag-common.ts

@@ -1,5 +1,5 @@
+import type { EventDefFactsGroup } from '../../schema/EventDef.js'
 import * as EventId from '../../schema/EventId.js'
-import type { MutationEventFactsGroup } from '../../schema/mutations.js'
 import { graphology } from './graphology_.js'
 
 export const connectionTypeOptions = ['parent', 'facts'] as const
@@ -25,10 +25,10 @@ export const rootParentId = EventId.make({ global: EventId.ROOT.global - 1, clie
 export type HistoryDagNode = {
   id: EventId.EventId
   parentId: EventId.EventId
-  mutation: string
+  name: string
   args: any
   /** Facts are being used for conflict detection and history compaction */
-  factsGroup: MutationEventFactsGroup
+  factsGroup: EventDefFactsGroup
   meta?: any
   clientId: string
   sessionId: string | undefined
@@ -38,7 +38,7 @@ export const rootEventNode: HistoryDagNode = {
   id: EventId.ROOT,
   parentId: rootParentId,
   // unused below
-  mutation: '__Root__',
+  name: '__Root__',
   args: {},
   factsGroup: { modifySet: new Map(), modifyUnset: new Map(), depRequire: new Map(), depRead: new Map() },
   clientId: 'root',

package/src/sync/next/history-dag.ts

@@ -14,7 +14,7 @@ export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skip
 
     if (validationResult.success === false) {
       throw new Error(
-        `Mutation ${dagNodes[validationResult.index]!.mutation} requires facts that have not been set yet.\nRequires: ${factsToString(validationResult.requiredFacts)}\nFacts Snapshot: ${factsToString(validationResult.currentSnapshot)}`,
+        `Event ${dagNodes[validationResult.index]!.name} requires facts that have not been set yet.\nRequires: ${factsToString(validationResult.requiredFacts)}\nFacts Snapshot: ${factsToString(validationResult.currentSnapshot)}`,
       )
     }
   }

package/src/sync/next/rebase-events.ts

@@ -1,11 +1,11 @@
+import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.js'
 import * as EventId from '../../schema/EventId.js'
-import type * as MutationEvent from '../../schema/MutationEvent.js'
-import type { MutationDef, MutationEventFactsSnapshot } from '../../schema/mutations.js'
+import type * as LiveStoreEvent from '../../schema/LiveStoreEvent.js'
 import {
   applyFactGroups,
   factsIntersect,
   type FactValidationResult,
-  getFactsGroupForMutationArgs,
+  getFactsGroupForEventArgs,
   validateFacts,
 } from './facts.js'
 import type { HistoryDagNode } from './history-dag-common.js'
@@ -19,13 +19,13 @@ export type RebaseInput = {
   newRemoteEvents: RebaseEventWithConflict[]
   pendingLocalEvents: RebaseEventWithConflict[]
   validate: (args: {
-    rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
-    mutationDefs: Record<string, MutationDef.Any>
+    rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
+    eventDefs: Record<string, EventDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: MutationEvent.PartialAnyDecoded[]
+  rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
 }
 
 export type RebaseFn = (input: RebaseInput) => RebaseOutput
@@ -49,10 +49,10 @@ export const rebaseEvents = ({
   pendingLocalEvents: HistoryDagNode[]
   newRemoteEvents: HistoryDagNode[]
   rebaseFn: RebaseFn
-  currentFactsSnapshot: MutationEventFactsSnapshot
+  currentFactsSnapshot: EventDefFactsSnapshot
   clientId: string
   sessionId: string
-}): ReadonlyArray<MutationEvent.AnyDecoded> => {
+}): ReadonlyArray<LiveStoreEvent.AnyDecoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -76,11 +76,11 @@ export const rebaseEvents = ({
         factsIntersect(pending.factsGroup.modifySet, remote.factsGroup.modifySet),
       ),
     })),
-    validate: ({ rebasedLocalEvents, mutationDefs }) =>
+    validate: ({ rebasedLocalEvents, eventDefs }) =>
       validateFacts({
         factGroups: rebasedLocalEvents.map((event) =>
-          getFactsGroupForMutationArgs({
-            factsCallback: mutationDefs[event.mutation]!.options.facts,
+          getFactsGroupForEventArgs({
+            factsCallback: eventDefs[event.name]!.options.facts,
             args: event.args,
             currentFacts: new Map(),
           }),
@@ -95,10 +95,10 @@ export const rebaseEvents = ({
       ({
         id: EventId.make({ global: headGlobalId + index + 1, client: EventId.clientDefault }),
         parentId: EventId.make({ global: headGlobalId + index, client: EventId.clientDefault }),
-        mutation: event.mutation,
+        name: event.name,
         args: event.args,
         clientId,
         sessionId,
-      }) satisfies MutationEvent.AnyDecoded,
+      }) satisfies LiveStoreEvent.AnyDecoded,
   )
 }

package/src/sync/next/test/compact-events.calculator.test.ts

@@ -1,16 +1,16 @@
-import { defineMutation } from '@livestore/common/schema'
+import { defineEvent } from '@livestore/common/schema'
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
 
 import { compactEvents } from '../compact-events.js'
 import { historyDagFromNodes } from '../history-dag.js'
 import { customSerializer } from './compact-events.test.js'
-import { toEventNodes } from './mutation-fixtures.js'
+import { toEventNodes } from './event-fixtures.js'
 
 expect.addSnapshotSerializer(customSerializer)
 
 const compact = (events: any[]) => {
-  const dag = historyDagFromNodes(toEventNodes(events, mutations, 'client-id', 'session-id'))
+  const dag = historyDagFromNodes(toEventNodes(events, eventDefs, 'client-id', 'session-id'))
   const compacted = compactEvents(dag)
 
   return Array.from(compacted.dag.nodeEntries())
@@ -23,98 +23,98 @@ const facts = {
   multiplyByZero: `multiplyByZero`,
 }
 
-const mutations = {
-  add: defineMutation('add', Schema.Struct({ value: Schema.Number }), 'UPDATE values SET value = value + $value', {}),
-  multiply: defineMutation(
-    'multiply',
-    Schema.Struct({ value: Schema.Number }),
-    'UPDATE values SET value = value * $value',
-    {
-      facts: ({ value }, currentFacts) => ({
-        modify: {
-          set: value === 0 || currentFacts.has(facts.multiplyByZero) ? [facts.multiplyByZero] : [],
-          unset: value === 0 ? [] : [facts.multiplyByZero],
-        },
-      }),
-    },
-  ),
+const eventDefs = {
+  add: defineEvent({
+    name: 'add',
+    schema: Schema.Struct({ value: Schema.Number }),
+  }),
+  multiply: defineEvent({
+    name: 'multiply',
+    schema: Schema.Struct({ value: Schema.Number }),
+    facts: ({ value }, currentFacts) => ({
+      modify: {
+        set: value === 0 || currentFacts.has(facts.multiplyByZero) ? [facts.multiplyByZero] : [],
+        unset: value === 0 ? [] : [facts.multiplyByZero],
+      },
+    }),
+  }),
   // TODO divide by zero
 }
 
 describe('compactEvents calculator', () => {
   it('1 + 1', () => {
     const expected = compact([
-      mutations.add({ value: 1 }), // 0
-      mutations.add({ value: 1 }), // 1
+      eventDefs.add({ value: 1 }), // 0
+      eventDefs.add({ value: 1 }), // 1
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
-        { id: 1, parentId: 0, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 1, parentId: 0, name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 2, parentId: 1, name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })
 
   it('2 * 2', () => {
     const expected = compact([
-      mutations.multiply({ value: 2 }), // 0
-      mutations.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 2 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
-        { id: 1, parentId: 0, mutation: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
+        { id: 1, parentId: 0, name: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
+        { id: 2, parentId: 1, name: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero -multiplyByZero" }
       ]
     `)
   })
 
   it('2 * 2 * 0', () => {
     const expected = compact([
-      mutations.multiply({ value: 2 }), // 0
-      mutations.multiply({ value: 2 }), // 1
-      mutations.multiply({ value: 0 }), // 2
+      eventDefs.multiply({ value: 2 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 0 }), // 2
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { id: 3, parentId: 0, name: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
       ]
     `)
   })
 
   it('2 * 2 * 0 + 1', () => {
     const expected = compact([
-      mutations.multiply({ value: 2 }), // 0
-      mutations.multiply({ value: 2 }), // 1
-      mutations.multiply({ value: 0 }), // 2
-      mutations.add({ value: 1 }), // 3
+      eventDefs.multiply({ value: 2 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 0 }), // 2
+      eventDefs.add({ value: 1 }), // 3
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 2, parentId: -1, mutation: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 3, parentId: 0, name: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { id: 4, parentId: 3, name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })
 
   it('1 + 2 * 0 * 2 + 1', () => {
     const expected = compact([
-      mutations.add({ value: 1 }), // 0
-      mutations.multiply({ value: 2 }), // 1
-      mutations.multiply({ value: 0 }), // 2
-      mutations.multiply({ value: 2 }), // 3
-      mutations.add({ value: 1 }), // 4
+      eventDefs.add({ value: 1 }), // 0
+      eventDefs.multiply({ value: 2 }), // 1
+      eventDefs.multiply({ value: 0 }), // 2
+      eventDefs.multiply({ value: 2 }), // 3
+      eventDefs.add({ value: 1 }), // 4
     ])
 
     expect(expected).toMatchInlineSnapshot(`
       [
-        { id: 0, parentId: -1, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
-        { id: 2, parentId: 0, mutation: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
-        { id: 4, parentId: 3, mutation: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 1, parentId: 0, name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
+        { id: 3, parentId: 1, name: "multiply", args: { value: 0 }, clientId: "client-id", sessionId: "session-id", facts: "+multiplyByZero" }
+        { id: 4, parentId: 3, name: "multiply", args: { value: 2 }, clientId: "client-id", sessionId: "session-id", facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
+        { id: 5, parentId: 4, name: "add", args: { value: 1 }, clientId: "client-id", sessionId: "session-id", facts: "" }
       ]
     `)
   })