@requence/event-sourcing 0.0.1 → 1.0.0

package/src/tests/projectionProcessManager.spec.ts

@@ -0,0 +1,203 @@
+import { setTimeout } from 'node:timers/promises'
+
+import { describe, expect, it } from 'bun:test'
+import { z } from 'zod/v4'
+
+import { createUserAggregate, setupEventStore } from './setup.ts'
+import { createAggregateRoot } from '../createAggregateRoot.ts'
+
+describe('Projection & ProcessManager', () => {
+  it('is settled when all chained events are handled', async () => {
+    const usersAggregate = createUserAggregate()
+    const { eventStore } = setupEventStore(usersAggregate)
+
+    const users = new Map<string, { name: string; age?: number }>()
+    eventStore.createProjection('user').withEventHandlers({
+      onUserCreated({ streamId, payload }) {
+        if (users.size > 0) {
+          throw new Error('wtf')
+        }
+        users.set(streamId, { name: payload.name })
+      },
+      async onUserUpdated({ streamId, payload }) {
+        await setTimeout(50)
+        users.get(streamId)!.age = payload.age
+      },
+    })
+
+    eventStore.createProcessManager('user').withEventHandlers({
+      async onUserCreated({ streamId }) {
+        await setTimeout(50)
+        usersAggregate.loadStream(streamId).update(40)
+      },
+    })
+
+    await usersAggregate.newStream().create('Torsten').update(30).settled()
+
+    expect(users.size).toBe(1)
+    expect(Array.from(users.values()).at(0)).toEqual({
+      name: 'Torsten',
+      age: 40,
+    })
+  })
+
+  it('is settled when all deeply chained events are handled', async () => {
+    const groupAggregate = createAggregateRoot('group')
+      .withInitialState({
+        id: null as string | null,
+      })
+      .withEvents({
+        GroupCreated: z.object({
+          name: z.string(),
+        }),
+        GroupDeleted: z.null(),
+      })
+      .withEventHandlers((state) => ({
+        onGroupCreated({ streamId }) {
+          state.id = streamId
+        },
+      }))
+      .withCommands((_state, event) => ({
+        create(name: string) {
+          return event('GroupCreated', { name })
+        },
+        delete() {
+          return event('GroupDeleted', null)
+        },
+      }))
+
+    const projectAggregate = createAggregateRoot('project')
+      .withEvents({
+        ProjectCreated: z.object({
+          name: z.string(),
+          groupId: z.uuid(),
+        }),
+        ProjectDeleted: z.null(),
+      })
+      .withCommands((event) => ({
+        create(name: string, groupId: string) {
+          return event('ProjectCreated', { name, groupId })
+        },
+        delete() {
+          return event('ProjectDeleted', null)
+        },
+      }))
+
+    const { eventStore } = setupEventStore([groupAggregate, projectAggregate])
+
+    const groups = new Map<string, string>()
+    eventStore.createProjection('group').withEventHandlers({
+      onGroupCreated({ streamId: groupId, payload }) {
+        groups.set(groupId, payload.name)
+      },
+      onGroupDeleted({ streamId: groupId }) {
+        groups.delete(groupId)
+      },
+    })
+
+    const projects = new Map<string, string>()
+    eventStore.createProjection('project').withEventHandlers({
+      onProjectCreated({ streamId: projectId, payload }) {
+        projects.set(projectId, payload.name)
+      },
+      onProjectDeleted({ streamId: projectId }) {
+        projects.delete(projectId)
+      },
+    })
+
+    eventStore
+      .createProcessManager('cascade')
+      .withState({
+        projectsByGroup: new Map<string, Set<string>>(),
+      })
+      .withEventHandlers((state) => ({
+        async onProjectCreated({ streamId: projectId, payload: { groupId } }) {
+          await setTimeout(20)
+          if (!state.projectsByGroup.has(groupId)) {
+            state.projectsByGroup.set(groupId, new Set())
+          }
+          state.projectsByGroup.get(groupId)!.add(projectId)
+        },
+        async onGroupDeleted({ streamId: groupId }) {
+          await setTimeout(20)
+          const projectIds = state.projectsByGroup.get(groupId)
+
+          projectIds?.forEach((projectId) => {
+            projectAggregate.loadStream(projectId).delete()
+          })
+          state.projectsByGroup.delete(groupId)
+        },
+      }))
+
+    const groupState = await groupAggregate.newStream().create('groupA').state()
+    await Promise.all([
+      projectAggregate
+        .newStream()
+        .create('projectA1', groupState.id!)
+        .settled(),
+      projectAggregate
+        .newStream()
+        .create('projectA2', groupState.id!)
+        .settled(),
+    ])
+
+    expect(groups.size).toBe(1)
+    expect(projects.size).toBe(2)
+
+    await groupAggregate.loadStream(groupState.id!).delete().settled()
+
+    expect(groups.size).toBe(0)
+    expect(projects.size).toBe(0)
+  })
+
+  it('can change commands with process manager', async () => {
+    const orderOfOperations: string[] = []
+    const userAggregate = createAggregateRoot('users')
+      .withEvents({
+        UserCreated: z.object({
+          name: z.string(),
+        }),
+        UserAgeSet: z.object({
+          age: z.int(),
+        }),
+        UserRoleSet: z.object({
+          role: z.string(),
+        }),
+      })
+      .withCommands((event) => ({
+        async *create(name: string) {
+          await setTimeout(10)
+          yield event('UserCreated', { name })
+          orderOfOperations.push('created')
+        },
+        async *setAge(age: number) {
+          await setTimeout(20)
+          yield event('UserAgeSet', { age })
+          orderOfOperations.push('age set')
+        },
+        async *setRole(role: string) {
+          await setTimeout(30)
+          yield event('UserRoleSet', { role })
+          orderOfOperations.push('role set')
+        },
+      }))
+    const { eventStore } = setupEventStore(userAggregate)
+
+    eventStore.createProcessManager('user').withEventHandlers({
+      async onUserCreated({ streamId }) {
+        await setTimeout(30)
+        orderOfOperations.push('injected')
+        userAggregate.loadStream(streamId).setRole('Admin')
+      },
+    })
+
+    await userAggregate.newStream().create('Torsten').setAge(40).settled()
+
+    expect(orderOfOperations).toEqual([
+      'created',
+      'age set',
+      'injected',
+      'role set',
+    ])
+  })
+})

package/src/tests/setup.ts

@@ -0,0 +1,230 @@
+import { setTimeout } from 'node:timers/promises'
+
+import { z } from 'zod/v4'
+
+import type { AnyAggregateRoot } from '../createAggregateRoot.ts'
+import type { Checkpoint } from '../createCheckpointApi.ts'
+import {
+  type AggregateRootSnapshot,
+  ConcurrencyError,
+  type Event,
+  type ProjectionSnapshot,
+  createAggregateRoot,
+  createEventStore,
+  isStreamEvents,
+  isStreamId,
+} from '../index.ts'
+import type { LockCreator } from '../lock.ts'
+
+export function createUserAggregate() {
+  return createAggregateRoot('users')
+    .withEvents({
+      UserCreated: z.object({
+        name: z.string(),
+      }),
+      UserUpdated: z.object({
+        age: z.int(),
+      }),
+      Test: z.function({
+        input: [z.number()],
+        output: z.string(),
+      }),
+    })
+    .withCommands((event) => ({
+      create(name: string) {
+        return event('UserCreated', { name })
+      },
+      update(age: number) {
+        return event('UserUpdated', { age })
+      },
+    }))
+}
+
+export function setupEventStore<const Root extends AnyAggregateRoot>(
+  aggregateRoot: Root | Root[],
+  options?: { preloadEvents?: Event[]; autoInit?: boolean; lock?: LockCreator },
+) {
+  const aggregateRoots = Array.isArray(aggregateRoot)
+    ? aggregateRoot
+    : [aggregateRoot]
+  const pseudoEventStore: Event[] = options?.preloadEvents
+    ? [...options.preloadEvents]
+    : []
+  const pseudoCheckpointStore = new Set<Checkpoint>()
+  const pseudoAggregateRootSnapshotStore = new Map<
+    string,
+    AggregateRootSnapshot
+  >()
+  const pseudoProjectionSnapshotStore = new Set<ProjectionSnapshot>()
+  const pseudoProjectionAppliedCount = new Map<string, number>()
+  const eventStore = createEventStore({
+    aggregateRoots,
+    lock: options?.lock,
+    autoInit: options?.autoInit,
+    appendEvents({ id, stream }, events, expectedVersion) {
+      const lastEvent = pseudoEventStore.findLast(
+        (e) => e.streamId === id && e.streamType === stream,
+      )
+
+      const currentVersion = lastEvent?.streamVersion ?? 0
+
+      if (currentVersion !== expectedVersion) {
+        throw new ConcurrencyError(
+          { id, stream },
+          expectedVersion,
+          currentVersion,
+        )
+      }
+
+      const extendedEvents: Event[] = events.map((event, index) => ({
+        ...event,
+        createdAt: new Date(),
+        position: pseudoEventStore.length + index,
+        streamId: id,
+        streamType: stream,
+        streamVersion: expectedVersion + index + 1,
+      }))
+
+      pseudoEventStore.push(...extendedEvents)
+      return extendedEvents
+    },
+    async *loadEvents(select, range) {
+      let streamTypes: string[] | null = null
+      let streamIds: string[] | null = null
+      let eventTypes: string[] | null = null
+      if (select) {
+        const selects = Array.isArray(select) ? select : [select]
+        streamTypes = selects.map((select) => select.stream)
+        streamIds = selects
+          .map((select) => (isStreamId(select) ? select.id : null))
+          .filter(Boolean) as string[]
+        eventTypes = selects.flatMap((select) =>
+          isStreamEvents(select) ? select.events : [],
+        )
+      }
+
+      const filteredEvents = pseudoEventStore.filter((event) => {
+        if (streamTypes?.length && !streamTypes.includes(event.streamType)) {
+          return false
+        }
+
+        if (streamIds?.length && !streamIds.includes(event.streamId)) {
+          return false
+        }
+
+        if (eventTypes?.length && !eventTypes.includes(event.type)) {
+          return false
+        }
+
+        if (range?.from && event.position < range.from) {
+          return false
+        }
+
+        if (range?.to && event.position > range.to) {
+          return false
+        }
+
+        return true
+      })
+
+      await setTimeout(10)
+
+      for (const event of filteredEvents) {
+        yield event
+      }
+    },
+
+    checkpoint: {
+      get(type, name) {
+        for (const checkpoint of pseudoCheckpointStore) {
+          if (checkpoint.type === type && checkpoint.name === name) {
+            return checkpoint
+          }
+        }
+      },
+      upsert(checkpoint) {
+        let persistedCheckpoint: Checkpoint | undefined
+        for (const c of pseudoCheckpointStore) {
+          if (c.type === checkpoint.type && c.name === checkpoint.name) {
+            persistedCheckpoint = c
+            break
+          }
+        }
+
+        if (persistedCheckpoint) {
+          persistedCheckpoint.lastEventPosition = checkpoint.lastEventPosition
+        } else {
+          pseudoCheckpointStore.add(checkpoint)
+        }
+      },
+      delete(type, name) {
+        for (const checkpoint of pseudoCheckpointStore) {
+          if (checkpoint.type === type && checkpoint.name === name) {
+            pseudoCheckpointStore.delete(checkpoint)
+          }
+        }
+      },
+    },
+    aggregateRootSnapshot: {
+      put(snapshot) {
+        pseudoAggregateRootSnapshotStore.set(snapshot.streamId, snapshot)
+      },
+      get(select) {
+        return pseudoAggregateRootSnapshotStore.get(select.id)
+      },
+      delete(target, fromPosition) {
+        for (const [key, value] of pseudoAggregateRootSnapshotStore) {
+          if (key === target.id && value.lastEventPosition > fromPosition) {
+            pseudoAggregateRootSnapshotStore.delete(key)
+          }
+        }
+      },
+    },
+    projectionSnapshot: {
+      put(snapshot) {
+        pseudoProjectionSnapshotStore.add(snapshot)
+      },
+      get(select) {
+        return Array.from(pseudoProjectionSnapshotStore)
+          .toReversed()
+          .find(
+            (snapshot) =>
+              snapshot.projectionId === select.id &&
+              snapshot.projectionType === select.projection,
+          )
+      },
+      delete(target, fromPosition) {
+        for (const snapshot of pseudoProjectionSnapshotStore) {
+          if (target.id && snapshot.projectionId !== target.id) {
+            continue
+          }
+
+          if (snapshot.projectionType !== target.projection) {
+            continue
+          }
+
+          if (fromPosition && snapshot.lastEventPosition < fromPosition) {
+            continue
+          }
+
+          pseudoProjectionSnapshotStore.delete(snapshot)
+        }
+      },
+      incrementAppliedCount(select) {
+        const key = `${select.projection}-${select.id}`
+        const nextCount = (pseudoProjectionAppliedCount.get(key) ?? 0) + 1
+        pseudoProjectionAppliedCount.set(key, nextCount)
+        return nextCount
+      },
+    },
+  })
+
+  return {
+    eventStore,
+    pseudoCheckpointStore,
+    pseudoEventStore,
+    pseudoAggregateRootSnapshotStore,
+    pseudoProjectionSnapshotStore,
+    pseudoProjectionAppliedCount,
+  }
+}

package/src/tests/transaction.spec.ts

@@ -0,0 +1,185 @@
+import { setTimeout } from 'node:timers/promises'
+
+import { describe, expect, it } from 'bun:test'
+import { z } from 'zod/v4'
+
+import { createAggregateRoot } from '../createAggregateRoot.ts'
+import { createUserAggregate, setupEventStore } from './setup.ts'
+import { CommandError } from '../errors.ts'
+
+describe('transaction', () => {
+  const createAggregateRoots = () => {
+    const aggA = createAggregateRoot('A')
+      .withEvents({
+        ACreated: z.object({
+          name: z.string(),
+        }),
+      })
+      .withCommands((event) => ({
+        async create(name: string) {
+          await setTimeout(200)
+          return event('ACreated', { name })
+        },
+      }))
+
+    const aggB = createAggregateRoot('B')
+      .withEvents({
+        BCreated: z.object({
+          name: z.string(),
+        }),
+      })
+      .withCommands((event) => ({
+        create(name: string) {
+          return event('BCreated', { name })
+        },
+        async update() {
+          await setTimeout(100)
+          throw new Error('Cannot update')
+        },
+      }))
+
+    return { aggA, aggB }
+  }
+
+  it('can commit events', async () => {
+    const { aggA, aggB } = createAggregateRoots()
+    const { eventStore, pseudoEventStore } = setupEventStore([aggA, aggB])
+
+    let aCreated = 0
+    let bCreated = 0
+
+    eventStore.createProcessManager('test').withEventHandlers({
+      onACreated() {
+        aCreated += 1
+      },
+      onBCreated() {
+        bCreated += 1
+      },
+    })
+
+    await eventStore.transaction(() => {
+      aggA.newStream().create('valueA')
+      aggB.newStream().create('valueB')
+    })
+
+    expect(pseudoEventStore.length).toBe(2)
+    expect(aCreated).toBe(1)
+    expect(bCreated).toBe(1)
+  })
+
+  it('does not commit on error inside transaction block', async () => {
+    const { aggA, aggB } = createAggregateRoots()
+    const { eventStore, pseudoEventStore } = setupEventStore([aggA, aggB])
+
+    expect(
+      eventStore.transaction(() => {
+        aggA.newStream().create('valueA')
+        aggB.newStream().create('valueB')
+        throw new Error('stop')
+      }),
+    ).rejects.toThrow('stop')
+
+    expect(pseudoEventStore.length).toBe(0)
+  })
+
+  it('does not commit on error in command', async () => {
+    const { aggA, aggB } = createAggregateRoots()
+    const { eventStore, pseudoEventStore } = setupEventStore([aggA, aggB])
+
+    expect(
+      eventStore.transaction(() => {
+        aggA.newStream().create('valueA')
+        aggB.newStream().create('valueB').update()
+      }),
+    ).rejects.toThrow(CommandError)
+
+    expect(pseudoEventStore.length).toBe(0)
+  })
+
+  it('awaits multiple commands', async () => {
+    const userAggregate = createUserAggregate()
+    const { eventStore, pseudoEventStore } = setupEventStore(userAggregate)
+
+    await eventStore.transaction(async () => {
+      userAggregate.newStream().create('Torsten').update(40)
+    })
+
+    expect(pseudoEventStore.length).toBe(2)
+  })
+
+  it('keeps order of created events', async () => {
+    const aggA = createAggregateRoot('a')
+      .withEvents({
+        Created: z.literal('a'),
+      })
+      .withCommands((event) => ({
+        create: () => event('Created', 'a'),
+      }))
+
+    const aggB = createAggregateRoot('a')
+      .withEvents({
+        Created: z.literal('b'),
+        Updated: z.literal('b'),
+      })
+      .withCommands((event) => ({
+        create: () => event('Created', 'b'),
+        update: () => event('Updated', 'b'),
+      }))
+
+    const { eventStore, pseudoEventStore } = setupEventStore([aggA, aggB])
+
+    await eventStore.transaction(async () => {
+      aggA.newStream('a1').create()
+      aggB.newStream('b1').create().update()
+      aggA.newStream('a2').create()
+    })
+
+    expect(pseudoEventStore.at(0)).toMatchObject({
+      type: 'Created',
+      payload: 'a',
+      streamId: 'a1',
+    })
+    expect(pseudoEventStore.at(1)).toMatchObject({
+      type: 'Created',
+      payload: 'b',
+      streamId: 'b1',
+    })
+    expect(pseudoEventStore.at(2)).toMatchObject({
+      type: 'Updated',
+      payload: 'b',
+      streamId: 'b1',
+    })
+    expect(pseudoEventStore.at(3)).toMatchObject({
+      type: 'Created',
+      payload: 'a',
+      streamId: 'a2',
+    })
+  })
+
+  it('can access state inside transaction', async () => {
+    expect.assertions(1)
+
+    const aggregateRoot = createAggregateRoot('test')
+      .withInitialState({
+        created: false,
+      })
+      .withEvents({
+        Created: z.null(),
+      })
+      .withEventHandlers((state) => ({
+        onCreated() {
+          state.created = true
+        },
+      }))
+      .withCommands((_, event) => ({
+        create() {
+          return event('Created', null)
+        },
+      }))
+    const { eventStore } = setupEventStore(aggregateRoot)
+    await eventStore.transaction(async () => {
+      const state = await aggregateRoot.newStream().create().state()
+      expect(state.created).toBeTrue()
+    })
+  })
+})

package/src/transaction.ts

@@ -0,0 +1,93 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+async function awaitAll(getPromises: () => Promise<any>[]) {
+  let promises = getPromises()
+
+  while (true) {
+    await Promise.all(promises)
+    const nextPromises = getPromises()
+    if (nextPromises.length > promises.length) {
+      promises = nextPromises
+    } else {
+      break
+    }
+  }
+}
+
+export type TransactionDelay = {
+  resolve: () => void
+  reject: (error: Error) => void
+  commit: () => Promise<void>
+}
+
+export default function createTransaction() {
+  const transactionStore = new AsyncLocalStorage<{
+    delayPromises: Promise<void>[]
+    commitPromises: Promise<void>[]
+    afterHandlers: Array<() => Promise<any>>
+  }>()
+
+  return {
+    get active() {
+      return Boolean(transactionStore.getStore())
+    },
+
+    delay(): TransactionDelay {
+      const store = transactionStore.getStore()
+      if (!store) {
+        return {
+          resolve: () => {},
+          reject: () => {},
+          commit: () => Promise.resolve(),
+        }
+      }
+
+      const idx = store.commitPromises.length
+      const { resolve, reject, promise } = Promise.withResolvers<void>()
+      store.delayPromises.push(promise)
+
+      const { promise: commitPromise, resolve: resolveCommitPromise } =
+        Promise.withResolvers<void>()
+      store.commitPromises.push(commitPromise)
+
+      return {
+        resolve,
+        reject,
+        async commit() {
+          if (idx > 0) {
+            await store.commitPromises.at(idx - 1)
+          }
+
+          resolveCommitPromise()
+          await awaitAll(() => store.delayPromises)
+        },
+      }
+    },
+
+    after(onAfter: () => Promise<any>) {
+      transactionStore.getStore()?.afterHandlers.push(onAfter)
+    },
+
+    async run<T extends () => any>(handler: T) {
+      const { resolve, reject, promise } = Promise.withResolvers<void>()
+      const delayPromises = [promise]
+      const afterHandlers: Array<() => Promise<any>> = []
+      let result
+      try {
+        result = await transactionStore.run(
+          { delayPromises, afterHandlers, commitPromises: [] },
+          handler,
+        )
+        resolve()
+      } catch (error) {
+        reject(error)
+      }
+      await awaitAll(() => delayPromises)
+      await Promise.all(afterHandlers.map((handler) => handler()))
+
+      return result
+    },
+  }
+}
+
+export type Transaction = ReturnType<typeof createTransaction>