@livestore/common 0.3.0-dev.3 → 0.3.0-dev.30

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') {
@@ -231,5 +230,5 @@ export const compareEventIds = (a: EventId.EventId, b: EventId.EventId) => {
   if (a.global !== b.global) {
     return a.global - b.global
   }
-  return a.local - b.local
+  return a.client - b.client
 }

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
@@ -20,25 +20,29 @@ export const emptyHistoryDag = (): HistoryDag =>
   })
 
 // TODO consider making `ROOT_ID` parent to itself
-export const rootParentId = { global: EventId.ROOT.global - 1, local: 0 } satisfies EventId.EventId
+export const rootParentId = EventId.make({ global: EventId.ROOT.global - 1, client: EventId.clientDefault })
 
 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
 }
 
 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',
+  sessionId: undefined,
 }
 
 export const EMPTY_FACT_VALUE = Symbol('EMPTY_FACT_VALUE')

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

@@ -3,7 +3,7 @@ import { factsToString, validateFacts } from './facts.js'
 import { emptyHistoryDag, type HistoryDagNode, rootParentId } from './history-dag-common.js'
 
 export const eventIdToString = (eventId: EventId.EventId) =>
-  eventId.local === 0 ? eventId.global.toString() : `${eventId.global}.${eventId.local}`
+  eventId.client === 0 ? eventId.global.toString() : `${eventId.global}.${eventId.client}`
 
 export const historyDagFromNodes = (dagNodes: HistoryDagNode[], options?: { skipFactsCheck: boolean }) => {
   if (options?.skipFactsCheck !== true) {
@@ -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 * as EventId from '../../schema/EventId.js'
-import type * as MutationEvent from '../../schema/MutationEvent.js'
-import type { MutationDef, MutationEventFactsSnapshot } from '../../schema/mutations.js'
+import type { EventDef, EventDefFactsSnapshot } from '../../schema/EventDef.js'
+import * as EventId from '../../schema/EventId.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.PartialAny[]
-    mutationDefs: Record<string, MutationDef.Any>
+    rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
+    eventDefs: Record<string, EventDef.Any>
   }) => FactValidationResult
 }
 
 export type RebaseOutput = {
-  rebasedLocalEvents: MutationEvent.PartialAny[]
+  rebasedLocalEvents: LiveStoreEvent.PartialAnyDecoded[]
 }
 
 export type RebaseFn = (input: RebaseInput) => RebaseOutput
@@ -43,12 +43,16 @@ export const rebaseEvents = ({
   pendingLocalEvents,
   newRemoteEvents,
   currentFactsSnapshot,
+  clientId,
+  sessionId,
 }: {
   pendingLocalEvents: HistoryDagNode[]
   newRemoteEvents: HistoryDagNode[]
   rebaseFn: RebaseFn
-  currentFactsSnapshot: MutationEventFactsSnapshot
-}): MutationEvent.Any[] => {
+  currentFactsSnapshot: EventDefFactsSnapshot
+  clientId: string
+  sessionId: string
+}): ReadonlyArray<LiveStoreEvent.AnyDecoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -72,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(),
           }),
@@ -89,10 +93,12 @@ export const rebaseEvents = ({
   return rebasedLocalEvents.map(
     (event, index) =>
       ({
-        id: { global: headGlobalId + index + 1, local: 0 } satisfies EventId.EventId,
-        parentId: { global: headGlobalId + index, local: 0 } satisfies EventId.EventId,
-        mutation: event.mutation,
+        id: EventId.make({ global: headGlobalId + index + 1, client: EventId.clientDefault }),
+        parentId: EventId.make({ global: headGlobalId + index, client: EventId.clientDefault }),
+        name: event.name,
         args: event.args,
-      }) satisfies MutationEvent.Any,
+        clientId,
+        sessionId,
+      }) 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))
+  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 }, facts: "" }
-        { id: 1, parentId: 0, mutation: "add", args: { value: 1 }, 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 }, facts: "?multiplyByZero -multiplyByZero" }
-        { id: 1, parentId: 0, mutation: "multiply", args: { value: 2 }, 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 }, 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 }, facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "add", args: { value: 1 }, 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 }, facts: "" }
-        { id: 2, parentId: 0, mutation: "multiply", args: { value: 0 }, facts: "+multiplyByZero" }
-        { id: 3, parentId: 2, mutation: "multiply", args: { value: 2 }, facts: "?multiplyByZero +multiplyByZero -multiplyByZero" }
-        { id: 4, parentId: 3, mutation: "add", args: { value: 1 }, 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: "" }
       ]
     `)
   })