@requence/event-sourcing 1.0.1 → 1.0.2

package/src/createProcessManager.ts

@@ -54,6 +54,8 @@ type ProcessManagerAfterEffectHandlers<Events extends EventTemplate> =
 export type InternalProcessManager = {
   apply: (event: BaseOutputEvent) => Promise<void>
   applyAfter: (event: BaseOutputEvent) => Promise<void>
+  beginSession: () => Promise<void>
+  endSession: () => void
   setRelatedStreamEvents: (
     generateRelatedStreamEvents: (
       eventHandlers: EventHandlers<EventTemplate>,
@@ -139,6 +141,7 @@ export function buildProcessManagerCreator(params: {
     let state: any = null
     let initialState: any = null
     let exclusive = true
+    let sessionActive = false
     let generateRelatedStreamEvents: (
       eventHandlers: EventHandlers<any>,
     ) => StreamEvents[]
@@ -238,6 +241,26 @@ export function buildProcessManagerCreator(params: {
       async isReady() {
         await hydrated
       },
+      async beginSession() {
+        if (!hasState) return
+        const checkpoint = await params.checkpoint.get(
+          'processManager',
+          name,
+        )
+        if (checkpoint) {
+          state = checkpoint.metadata?.state ?? clone(initialState)
+          lastEventPosition = checkpoint.lastEventPosition
+        } else {
+          state = clone(initialState)
+          lastEventPosition = -1
+        }
+        sessionActive = true
+      },
+      endSession() {
+        if (!hasState) return
+        state = null
+        sessionActive = false
+      },
       async apply(event) {
         await apply(event, false)
       },
@@ -302,6 +325,13 @@ export function buildProcessManagerCreator(params: {
       },
       async state() {
         await hydrated
+        if (!sessionActive && hasState) {
+          const checkpoint = await params.checkpoint.get(
+            'processManager',
+            name,
+          )
+          return checkpoint?.metadata?.state ?? clone(initialState)
+        }
         return state
       },
       async init(catchUp) {
@@ -338,6 +368,10 @@ export function buildProcessManagerCreator(params: {
           },
         })
 
+        // Release state after hydration — it will be loaded
+        // from the checkpoint on the next beginSession call
+        state = null
+
         resolveHydrated()
       },
       $inferState: null as never,

package/src/index.ts

@@ -3,7 +3,7 @@ import type {
   StreamEvents,
   StreamId,
   StreamIdEvents,
-} from './utilityTypes.d.ts'
+} from './utilityTypes.ts'
 
 export { createEventStore } from './createEventStore.ts'
 export type { BaseOutputEvent as Event } from './utilityTypes.d.ts'

package/src/tests/processManagerMultiInstance.spec.ts

@@ -0,0 +1,214 @@
+import { describe, expect, it } from 'bun:test'
+
+import { z } from 'zod/v4'
+
+import type { Checkpoint } from '../createCheckpointApi.ts'
+import type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js'
+import {
+  type Event,
+  ConcurrencyError,
+  createAggregateRoot,
+  createEventStore,
+  isStreamEvents,
+  isStreamId,
+} from '../index.ts'
+
+/**
+ * Shared backing store — simulates a real database that multiple
+ * event store instances connect to (e.g. Postgres + RabbitMQ).
+ */
+function createSharedDatabase() {
+  const events: Event[] = []
+  const checkpoints = new Set<Checkpoint>()
+
+  return {
+    events,
+    checkpoints,
+    appendEvents(
+      { id, stream }: { id: string; stream: string },
+      newEvents: any[],
+      expectedVersion: number,
+    ) {
+      const lastEvent = events.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[] = newEvents.map((event, index) => ({
+        ...event,
+        createdAt: new Date(),
+        position: events.length + index,
+        streamId: id,
+        streamType: stream,
+        streamVersion: expectedVersion + index + 1,
+      }))
+
+      events.push(...extendedEvents)
+      return extendedEvents
+    },
+    async *loadEvents(
+      select: any,
+      range?: { from?: number; to?: number },
+    ): AsyncGenerator<BaseOutputEvent> {
+      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((s: any) => s.stream)
+        streamIds = selects
+          .map((s: any) => (isStreamId(s) ? s.id : null))
+          .filter(Boolean) as string[]
+        eventTypes = selects.flatMap((s: any) =>
+          isStreamEvents(s) ? s.events : [],
+        )
+      }
+
+      for (const event of events) {
+        if (streamTypes?.length && !streamTypes.includes(event.streamType))
+          continue
+        if (streamIds?.length && !streamIds.includes(event.streamId)) continue
+        if (eventTypes?.length && !eventTypes.includes(event.type)) continue
+        if (range?.from !== undefined && event.position < range.from) continue
+        if (range?.to !== undefined && event.position > range.to) continue
+        yield event
+      }
+    },
+    checkpoint: {
+      get(type: string, name: string) {
+        for (const cp of checkpoints) {
+          if (cp.type === type && cp.name === name) return cp
+        }
+      },
+      upsert(checkpoint: Checkpoint) {
+        let persisted: Checkpoint | undefined
+        for (const c of checkpoints) {
+          if (c.type === checkpoint.type && c.name === checkpoint.name) {
+            persisted = c
+            break
+          }
+        }
+        if (persisted) {
+          persisted.lastEventPosition = checkpoint.lastEventPosition
+          persisted.metadata = checkpoint.metadata
+        } else {
+          checkpoints.add(checkpoint)
+        }
+      },
+      delete(type: string, name: string) {
+        for (const cp of checkpoints) {
+          if (cp.type === type && cp.name === name) {
+            checkpoints.delete(cp)
+          }
+        }
+      },
+    },
+  }
+}
+
+/**
+ * Creates an event store instance that connects to the shared database.
+ * Each instance gets its own aggregate root instance (just like a real
+ * multi-instance deployment would).
+ */
+function createInstance(
+  sharedDb: ReturnType<typeof createSharedDatabase>,
+  opts?: {
+    onEventsEmitted?: (events: BaseOutputEvent[]) => MaybePromise<void>
+  },
+) {
+  const aggregate = createAggregateRoot('counters')
+    .withEvents({
+      CounterIncremented: z.object({ amount: z.number() }),
+    })
+    .withCommands((event) => ({
+      increment(amount: number) {
+        return event('CounterIncremented', { amount })
+      },
+    }))
+
+  const eventStore = createEventStore({
+    aggregateRoots: [aggregate],
+    autoInit: false,
+    appendEvents(...args) {
+      const appended = sharedDb.appendEvents(...args)
+      // Simulate event distribution (like RabbitMQ fanout)
+      opts?.onEventsEmitted?.(appended)
+      return appended
+    },
+    loadEvents: sharedDb.loadEvents.bind(sharedDb),
+    checkpoint: sharedDb.checkpoint,
+  })
+
+  return { aggregate, eventStore }
+}
+
+describe('ProcessManager Multi-Instance', () => {
+  it('state does not diverge when two instances process events independently', async () => {
+    const sharedDb = createSharedDatabase()
+
+    // --- Instance A ---
+    const instanceA = createInstance(sharedDb)
+    const pmA = instanceA.eventStore
+      .createProcessManager('counter-pm')
+      .withState({ total: 0 })
+      .withEventHandlers((state) => ({
+        async onCounterIncremented({ payload }) {
+          state.total += payload.amount
+        },
+      }))
+
+    await instanceA.eventStore.init()
+    await instanceA.eventStore.isReady()
+
+    // --- Instance B (simulates second deployment) ---
+    const instanceB = createInstance(sharedDb)
+    const pmB = instanceB.eventStore
+      .createProcessManager('counter-pm')
+      .withState({ total: 0 })
+      .withEventHandlers((state) => ({
+        async onCounterIncremented({ payload }) {
+          state.total += payload.amount
+        },
+      }))
+
+    await instanceB.eventStore.init()
+    await instanceB.eventStore.isReady()
+
+    // Both instances should read the same initial state from the checkpoint
+    expect(await pmA.state()).toEqual({ total: 0 })
+    expect(await pmB.state()).toEqual({ total: 0 })
+
+    // Instance A processes an event
+    await instanceA.aggregate.newStream().increment(10).settled()
+
+    // Instance A reads updated state from checkpoint
+    expect(await pmA.state()).toEqual({ total: 10 })
+
+    // Instance B also reads the correct state from the shared checkpoint
+    // (state is loaded from DB, not stale memory)
+    expect(await pmB.state()).toEqual({ total: 10 })
+
+    // Instance B processes a second event — it loads { total: 10 } from
+    // the checkpoint before processing, so the result is correct.
+    await instanceB.aggregate.newStream().increment(5).settled()
+
+    const stateBAfterSecondEvent = await pmB.state()
+    expect(stateBAfterSecondEvent).toEqual({ total: 15 })
+
+    // The checkpoint in the database reflects the correct cumulative state
+    const checkpoint = sharedDb.checkpoint.get('processManager', 'counter-pm')!
+    expect(checkpoint.metadata).toEqual({ state: { total: 15 } })
+
+    // Instance A also sees the correct state (loaded from shared checkpoint)
+    expect(await pmA.state()).toEqual({ total: 15 })
+  })
+})

package/src/{utilityTypes.d.ts → utilityTypes.ts}

@@ -4,19 +4,19 @@ export type Prettify<T> = {
   [K in keyof T]: T[K]
 } & {}
 
-interface Stream {
+export interface Stream {
   stream: string
 }
 
-interface StreamEvents extends Stream {
+export interface StreamEvents extends Stream {
   events: string[]
 }
 
-interface StreamId extends Stream {
+export interface StreamId extends Stream {
   id: string
 }
 
-interface StreamIdEvents extends StreamEvents {
+export interface StreamIdEvents extends StreamEvents {
   id: string
 }
 

package/dist/chunk-m07vf8q9.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/createProcessManager.ts"],
-  "sourcesContent": [
-    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport {\n  type CheckpointApi,\n  type CheckpointMethods,\n  createCheckpointApi,\n} from './createCheckpointApi.ts'\nimport type { LoadEvents, OnProgress } from './createEventStore.ts'\nimport {\n  ProcessManagerEventHandlerExecutionError,\n  RefreshingSkipError,\n} from './errors.ts'\nimport { isRefreshing, withRefreshing } from './refresh.ts'\nimport { clone } from './superjson.ts'\nimport type {\n  AfterEffectHandlers,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  Keys,\n  Merge,\n  StreamEvents,\n} from './utilityTypes.js'\n\ntype ProcessManagerInfo = {\n  name: string\n  event: BaseOutputEvent\n}\nconst processManagerInfoStore = new AsyncLocalStorage<ProcessManagerInfo>()\n\nfunction withProcessManagerInfo(\n  info: ProcessManagerInfo,\n  handler: () => Promise<void>,\n) {\n  return processManagerInfoStore.run(info, handler)\n}\n\nexport function getProcessManagerInfo() {\n  return processManagerInfoStore.getStore()\n}\n\nexport function isInsideProcessManager() {\n  return Boolean(getProcessManagerInfo())\n}\n\ntype ProcessManagerEventHandlers<Events extends EventTemplate> = EventHandlers<\n  Events,\n  { refreshing: boolean }\n>\n\ntype ProcessManagerAfterEffectHandlers<Events extends EventTemplate> =\n  AfterEffectHandlers<Events, { refreshing: boolean }>\n\nexport type InternalProcessManager = {\n  apply: (event: BaseOutputEvent) => Promise<void>\n  applyAfter: (event: BaseOutputEvent) => Promise<void>\n  setRelatedStreamEvents: (\n    generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<EventTemplate>,\n    ) => StreamEvents[],\n  ) => void\n  isReady(): Promise<void>\n  beginRefresh(): Promise<void>\n  progressRefresh(\n    index: number,\n    event: BaseOutputEvent,\n    after: boolean,\n  ): Promise<void>\n  endRefresh(): void\n  init(catchUp: boolean): Promise<void>\n  hasState(): boolean\n}\n\nexport type ProcessManagerApi<\n  State = never,\n  Events extends EventTemplate = never,\n  Flags extends {\n    withState: boolean\n    withEventHandlers: boolean\n    concurrent: boolean\n    withAfterEffects: boolean\n  } = {\n    withState: false\n    withEventHandlers: false\n    concurrent: false\n    withAfterEffects: false\n  },\n> = {\n  withState: <NextState>(\n    state: NextState,\n  ) => Omit<\n    ProcessManagerApi<NextState, Events, Merge<Flags, { withState: true }>>,\n    Keys<Merge<Flags, { withState: true }>>\n  >\n  withEventHandlers: (\n    handlers: [State] extends [never]\n      ? ProcessManagerEventHandlers<Events>\n      : (state: State) => ProcessManagerEventHandlers<Events>,\n  ) => Omit<\n    ProcessManagerApi<State, Events, Merge<Flags, { withEventHandlers: true }>>,\n    Keys<Merge<Flags, { withEventHandlers: true }>>\n  >\n  withAfterEffects: (\n    handlers: [State] extends [never]\n      ? ProcessManagerAfterEffectHandlers<Events>\n      : (state: State) => ProcessManagerAfterEffectHandlers<Events>,\n  ) => Omit<\n    ProcessManagerApi<State, Events, Merge<Flags, { withAfterEffects: true }>>,\n    Keys<Merge<Flags, { withAfterEffects: true }>>\n  >\n  concurrent: () => Omit<\n    ProcessManagerApi<State, Events, Merge<Flags, { concurrent: true }>>,\n    Keys<Merge<Flags, { concurrent: true }>>\n  >\n  isReady(): Promise<void>\n  $inferState: State\n} & (Flags['withState'] extends true\n  ? {\n      refreshState: () => Promise<void>\n      state: () => Promise<State>\n    }\n  : {})\n\nexport function buildProcessManagerCreator(params: {\n  loadEvents: LoadEvents\n  checkpoint: CheckpointMethods\n  onRefresh?: OnProgress\n}) {\n  return (name: string): ProcessManagerApi => {\n    let idle = true\n    let createEventHandlers: (\n      state: any,\n    ) => ProcessManagerEventHandlers<any> = () => ({})\n    let createAfterEffects: (\n      state: any,\n    ) => ProcessManagerAfterEffectHandlers<any> = () => ({})\n\n    let hasState = false\n    let state: any = null\n    let initialState: any = null\n    let exclusive = true\n    let generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<any>,\n    ) => StreamEvents[]\n    let checkpointApi: CheckpointApi\n    let lastEventPosition = -1\n    const { promise: hydrated, resolve: resolveHydrated } =\n      Promise.withResolvers<void>()\n\n    const locks = new Map<string, Promise<void>>()\n    const apply = async (\n      event: BaseOutputEvent,\n      after: boolean,\n      hydrating = false,\n    ) => {\n      const handler = after\n        ? createAfterEffects(state)[`after${event.type}`]\n        : createEventHandlers(state)[`on${event.type}`]\n\n      if (!handler) {\n        return Promise.resolve()\n      }\n\n      if (hydrating) {\n        lastEventPosition = event.position\n      } else {\n        await hydrated\n        // event was already applied through hydration\n        if (event.position <= lastEventPosition) {\n          return\n        }\n      }\n      const unlocked = !exclusive\n        ? Promise.resolve()\n        : (locks.get(event.streamId)?.catch(() => {}) ?? Promise.resolve())\n\n      const runner = (async () => {\n        await unlocked\n        const refreshing = isRefreshing()\n        await withProcessManagerInfo(\n          {\n            name,\n            event,\n          },\n          async () => {\n            try {\n              await handler(event, { refreshing })\n            } catch (error) {\n              if (error instanceof RefreshingSkipError) {\n                if (refreshing) {\n                  return\n                }\n\n                throw new Error(\n                  'RefreshingSkipError should never be thrown outside refresh',\n                )\n              }\n\n              if (!(error instanceof Error)) {\n                throw error\n              }\n\n              throw new ProcessManagerEventHandlerExecutionError(\n                name,\n                after ? `after${event.type}` : `on${event.type}`,\n                event,\n                error,\n              )\n            }\n          },\n        )\n        await checkpointApi.upsert(event, { state })\n      })()\n\n      if (exclusive) {\n        locks.set(event.streamId, runner)\n\n        runner\n          .finally(() => {\n            if (locks.get(event.streamId) === runner) {\n              locks.delete(event.streamId)\n            }\n          })\n          .catch(() => {})\n        return runner\n      }\n\n      return Promise.resolve()\n    }\n\n    let resolveRefresh: null | (() => void) = null\n\n    const api = {\n      name,\n      hasState() {\n        return hasState\n      },\n      async isReady() {\n        await hydrated\n      },\n      async apply(event) {\n        await apply(event, false)\n      },\n      async applyAfter(event) {\n        await apply(event, true)\n      },\n      withState(nextState) {\n        state = clone(nextState)\n        initialState = clone(nextState)\n        hasState = true\n        return api as any\n      },\n      concurrent() {\n        exclusive = false\n        return api\n      },\n      withEventHandlers(handlers) {\n        createEventHandlers =\n          typeof handlers === 'function' ? (handlers as any) : () => handlers\n\n        return api\n      },\n      withAfterEffects(handlers) {\n        createAfterEffects =\n          typeof handlers === 'function' ? (handlers as any) : () => handlers\n\n        return api\n      },\n      setRelatedStreamEvents(generate) {\n        generateRelatedStreamEvents = generate\n      },\n      async beginRefresh() {\n        params.onRefresh?.begin?.(name)\n        await checkpointApi.clear()\n        lastEventPosition = -1\n        state = initialState\n      },\n      async progressRefresh(index, event, after) {\n        await apply(event, after, true)\n\n        if (\n          !checkpointApi.relatedStreamEvents ||\n          checkpointApi.relatedStreamEvents.some((streamEvent) =>\n            streamEvent.events.includes(event.type),\n          )\n        ) {\n          params.onRefresh?.progress?.(name, index, event)\n        }\n      },\n      endRefresh() {\n        params.onRefresh?.end?.(name)\n        resolveHydrated()\n      },\n      async refreshState() {\n        if (!idle) {\n          await refresh()\n          return\n        }\n        const { promise, resolve } = Promise.withResolvers<void>()\n        resolveRefresh = resolve\n        return promise\n      },\n      async state() {\n        await hydrated\n        return state\n      },\n      async init(catchUp) {\n        idle = false\n        const relatedStreamEvents = generateRelatedStreamEvents({\n          ...createEventHandlers(null),\n          ...createAfterEffects(null),\n        })\n\n        checkpointApi = createCheckpointApi({\n          ...params.checkpoint,\n          name,\n          relatedStreamEvents,\n          type: 'processManager',\n          loadEvents: params.loadEvents,\n          apply: (event) => apply(event, false, true),\n          applyAfter: (event) => apply(event, true, true),\n        })\n\n        if (resolveRefresh) {\n          await refresh()\n          return\n        }\n        if (!catchUp) {\n          return\n        }\n\n        await checkpointApi.rehydrated({\n          getMetadata() {\n            return { state }\n          },\n          onMetadata(metadata) {\n            state = metadata.state ?? state\n          },\n        })\n\n        resolveHydrated()\n      },\n      $inferState: null as never,\n    } as ProcessManagerApi & InternalProcessManager\n\n    async function refresh() {\n      await withRefreshing(async () => {\n        await api.beginRefresh()\n        await checkpointApi.rehydrated({\n          getMetadata() {\n            return { state }\n          },\n          onProgress(index, event) {\n            params.onRefresh?.progress?.(name, index, event)\n          },\n        })\n      })\n      api.endRefresh()\n    }\n\n    return api\n  }\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "F1319F7D0A1BF35E64756E2164756E21",
-  "names": []
-}

package/dist/chunk-wmz6a1jk.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/createEventStore.ts"],
-  "sourcesContent": [
-    "import type {\n  AggregateRootApi,\n  AggregateRootSnapshotMethods,\n  AnyAggregateRoot,\n  InternalAggregateRootApi,\n} from './createAggregateRoot.ts'\nimport type { CheckpointMethods } from './createCheckpointApi.ts'\nimport {\n  type EventListenerApi,\n  type InternalEventListener,\n  createEventListener,\n} from './createEventListener.ts'\nimport {\n  type InternalProcessManager,\n  type ProcessManagerApi,\n  buildProcessManagerCreator,\n} from './createProcessManager.ts'\nimport {\n  type InternalProjection,\n  type ProjectionApi,\n  type ProjectionApiWithSnapshots,\n  type ProjectionSnapshotMethods,\n  buildProjectionCreator,\n} from './createProjection.ts'\nimport lock, { type LockCreator } from './lock.ts'\nimport { withRefreshing } from './refresh.ts'\nimport createTransaction from './transaction.ts'\nimport type {\n  BaseInputEvent,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  MaybePromise,\n  Stream,\n  StreamEvents,\n  StreamId,\n  StreamIdEvents,\n} from './utilityTypes.js'\nimport {\n  type WrappedEvent,\n  unwrapEvent,\n  wrappedEventBuilder,\n} from './wrappedEventBuilder.ts'\n\nexport type LoadEvents = (\n  select:\n    | Stream\n    | StreamId\n    | Stream[]\n    | StreamId[]\n    | StreamEvents\n    | StreamEvents[]\n    | StreamIdEvents\n    | StreamIdEvents[]\n    | null,\n  range?: { from: number; to?: number },\n) => AsyncGenerator<BaseOutputEvent>\n\ntype AppendEvents = (\n  streamId: StreamId,\n  events: BaseInputEvent[],\n  expectedVersion: number,\n) => MaybePromise<BaseOutputEvent[]>\n\nexport type InternalAppendEvents = (\n  streamId: StreamId,\n  events: BaseInputEvent[],\n  expectedVersion: number,\n) => MaybePromise<BaseOutputEvent[]>\n\nexport type EmitEvents = (events: BaseOutputEvent[]) => Promise<void>\n\nexport type EventsFromRoot<Root> =\n  Root extends Omit<AggregateRootApi<any, any, infer E>, any> ? E : never\n\nexport type OnProgress = {\n  begin?: (projectionName: string) => void\n  progress?: (\n    projectionName: string,\n    index: number,\n    event: BaseOutputEvent,\n  ) => void\n  end?: (projectionName: string) => void\n}\n\ninterface BaseEventStoreParams<Root extends AnyAggregateRoot> {\n  loadEvents: LoadEvents\n  appendEvents: AppendEvents\n  aggregateRoots: Root[]\n  checkpoint: CheckpointMethods\n  lock?: LockCreator\n  projectionSnapshot?: ProjectionSnapshotMethods\n  onProjectionReplay?: OnProgress\n  onProcessManagerRefresh?: OnProgress\n  autoInit?: boolean\n}\n\nexport interface EventStoreParamsWithAggregateRootSnapshots<\n  Root extends AnyAggregateRoot,\n> extends BaseEventStoreParams<Root> {\n  aggregateRootSnapshot: AggregateRootSnapshotMethods\n  postProcessEvent?: (\n    event: WrappedEvent<EventsFromRoot<Root>>,\n    aggregateRoot: Root,\n  ) => WrappedEvent\n}\n\nexport interface EventStoreParamsWithoutAggregateRootSnapshots<\n  Root extends AnyAggregateRoot,\n> extends BaseEventStoreParams<Root> {\n  aggregateRoots: Root[]\n  aggregateRootSnapshot?: never\n  postProcessEvent?: (\n    event: WrappedEvent<EventsFromRoot<Root>>,\n    aggregateRoot: Root,\n  ) => WrappedEvent\n}\n\nexport type EventStore<\n  Event extends EventTemplate,\n  Root extends AnyAggregateRoot,\n  SupportsProjectionSnapshots = boolean,\n> = {\n  createProjection(\n    name: string,\n  ): SupportsProjectionSnapshots extends true\n    ? ProjectionApiWithSnapshots<Event>\n    : ProjectionApi<Event>\n  createProcessManager(name: string): ProcessManagerApi<never, Event>\n  createEventListener(name: string): EventListenerApi<Event>\n  rebuild: () => Promise<void>\n  isReady: () => Promise<void>\n  init: () => Promise<EventStore<Event, Root, SupportsProjectionSnapshots>>\n  getAggregateRoot<S extends Root['type']>(\n    type: S,\n  ): Root extends { type: S } ? Root : never\n  transaction<T extends () => any>(handler: T): Promise<Awaited<ReturnType<T>>>\n}\n\nexport function createEventStore<const Root extends AnyAggregateRoot>(\n  params: EventStoreParamsWithoutAggregateRootSnapshots<Root>,\n): EventStore<EventsFromRoot<Root>, Root, false>\nexport function createEventStore<const Root extends AnyAggregateRoot>(\n  params: EventStoreParamsWithAggregateRootSnapshots<Root>,\n): EventStore<EventsFromRoot<Root>, Root, true>\nexport function createEventStore<const Root extends AnyAggregateRoot>(\n  params:\n    | EventStoreParamsWithoutAggregateRootSnapshots<Root>\n    | EventStoreParamsWithAggregateRootSnapshots<Root>,\n) {\n  const transaction = createTransaction()\n  const { promise: initialized, resolve: resolveInitialized } =\n    Promise.withResolvers<void>()\n  const projections = new Map<string, InternalProjection>()\n  const processManagers = new Map<string, InternalProcessManager>()\n  const eventListeners = new Map<string, InternalEventListener>()\n  const aggregatRootsByEvents = new Map<\n    string,\n    { aggregateRoot: InternalAggregateRootApi; eventType: string }\n  >()\n\n  let allReplaying = false\n  let initializing = false\n\n  const assertInitializing = () => {\n    if (!initializing && params.autoInit === false) {\n      throw new Error(\n        'Cannot emit events because the event store is not initialized. Set autoInit to true, or explicitly call .init() before emitting events.',\n      )\n    }\n  }\n\n  let exclusiveEmitEventsChain: Promise<any> = Promise.resolve()\n  const emitEvents: EmitEvents = async (events) => {\n    exclusiveEmitEventsChain = exclusiveEmitEventsChain.then(async () => {\n      for (const event of events) {\n        await Promise.all(\n          [\n            ...processManagers.values(),\n            ...projections.values(),\n            ...eventListeners.values(),\n          ].map((listener) => listener.apply(event)),\n        )\n      }\n\n      for (const event of events) {\n        await Promise.all(\n          [...processManagers.values(), ...eventListeners.values()].map(\n            (processManager) => processManager.applyAfter(event),\n          ),\n        )\n      }\n    })\n\n    return exclusiveEmitEventsChain\n  }\n\n  const loadEvents: LoadEvents = (select, range) => {\n    assertInitializing()\n    return params.loadEvents(select, range)\n  }\n\n  let exclusiveAppendEventsChain: Promise<any> = initialized\n  const appendEvents: InternalAppendEvents = async (\n    streamId,\n    events,\n    expectedVersion,\n  ) => {\n    assertInitializing()\n    exclusiveAppendEventsChain = exclusiveAppendEventsChain.then(async () => {\n      if (events.length === 0) {\n        return []\n      }\n      await new Promise((resolve) => setImmediate(resolve)) // edge case for sync setup, see 'can execute after effect' test\n\n      const processedEvents = events.map((rawEvent) => {\n        const event = structuredClone(rawEvent)\n        if (params.postProcessEvent) {\n          const wrappedEvent = wrappedEventBuilder(event) as WrappedEvent<any>\n          const { aggregateRoot } = aggregatRootsByEvents.get(event.type)!\n          const processedEvent = unwrapEvent(\n            params.postProcessEvent(\n              wrappedEvent,\n              aggregateRoot as unknown as Root,\n            ),\n          )\n          Object.assign(event, processedEvent)\n        }\n\n        return event\n      })\n\n      return params.appendEvents(streamId, processedEvents, expectedVersion)\n    })\n\n    return exclusiveAppendEventsChain\n  }\n\n  for (const aggregateRoot of params.aggregateRoots as unknown as InternalAggregateRootApi[]) {\n    aggregateRoot.eventTypes.forEach((eventType) => {\n      aggregatRootsByEvents.set(eventType, {\n        aggregateRoot,\n        eventType,\n      })\n    })\n\n    aggregateRoot.linkEventStore(\n      loadEvents,\n      appendEvents,\n      emitEvents,\n      transaction,\n      params.lock ?? lock(5000),\n      params.aggregateRootSnapshot,\n    )\n  }\n\n  const baseCreateProjection = buildProjectionCreator({\n    loadEvents,\n    checkpoint: params.checkpoint,\n    snapshot: params.projectionSnapshot,\n    onReplay: params.onProjectionReplay,\n  })\n\n  const baseCreateProcessManager = buildProcessManagerCreator({\n    loadEvents,\n    checkpoint: params.checkpoint,\n    onRefresh: params.onProcessManagerRefresh,\n  })\n\n  const getRelatedStreamEvents = (\n    handlers: EventHandlers<any>,\n  ): StreamEvents[] => {\n    const relatedStreamEvents = new Map<string, Set<string>>()\n    for (const handlerName of Object.keys(handlers)) {\n      const sanitizedHandlerName = handlerName.replace(/^(on|after)/, '')\n      if (!aggregatRootsByEvents.has(sanitizedHandlerName)) {\n        throw new Error(\n          `event handler ${handlerName} has no corresponding event in any aggregate root`,\n        )\n      }\n      const {\n        aggregateRoot: { type: aggregateRootName },\n        eventType,\n      } = aggregatRootsByEvents.get(sanitizedHandlerName)!\n      if (!relatedStreamEvents.has(aggregateRootName)) {\n        relatedStreamEvents.set(aggregateRootName, new Set())\n      }\n      relatedStreamEvents.get(aggregateRootName)!.add(eventType)\n    }\n\n    return Array.from(relatedStreamEvents, ([stream, events]) => ({\n      stream,\n      events: Array.from(events),\n    }))\n  }\n\n  const initialize = async () => {\n    initializing = true\n    await Promise.all(\n      projections.values().map((projection) => projection.init(true)),\n    )\n    await Promise.all(\n      processManagers\n        .values()\n        .map((processManager) => processManager.init(true)),\n    )\n    resolveInitialized()\n  }\n  setImmediate(() => {\n    if (allReplaying || params.autoInit === false) {\n      return\n    }\n\n    initialize()\n  })\n\n  const api = {\n    createProjection(name) {\n      if (projections.has(name)) {\n        throw new Error(`Projection ${name} is already registered`)\n      }\n      const api = baseCreateProjection(name)\n      const internalApi = api as unknown as InternalProjection\n      internalApi.setRelatedStreamEvents((handlers) =>\n        getRelatedStreamEvents(handlers),\n      )\n      projections.set(name, internalApi)\n      if (initializing) {\n        internalApi.init(true)\n      }\n      return api\n    },\n    createProcessManager(name) {\n      if (processManagers.has(name)) {\n        throw new Error(`Process Manager ${name} is already registered`)\n      }\n      const api = baseCreateProcessManager(name)\n\n      const internalApi = api as unknown as InternalProcessManager\n      internalApi.setRelatedStreamEvents((handlers) =>\n        getRelatedStreamEvents(handlers),\n      )\n      processManagers.set(name, internalApi)\n      if (initializing) {\n        internalApi.init(true)\n      }\n      return api\n    },\n    createEventListener(name) {\n      if (eventListeners.has(name)) {\n        throw new Error(`Event Listener ${name} is already registered`)\n      }\n\n      const api = createEventListener(name)\n\n      const internalApi = api as unknown as InternalEventListener\n      eventListeners.set(name, internalApi)\n      return api\n    },\n    async isReady() {\n      await initialized\n      await Promise.all([\n        ...projections.values().map((projection) => projection.isReady()),\n        ...processManagers.values().map((projection) => projection.isReady()),\n      ])\n    },\n    async rebuild() {\n      allReplaying = true\n      initializing = true\n      const replayProjections = Array.from(projections.values()).filter(\n        (projection) => projection.canReplay(),\n      )\n      const replayProcessManagers = Array.from(processManagers.values()).filter(\n        (processManager) => processManager.hasState(),\n      )\n\n      await Promise.all([\n        ...replayProjections.map((projection) => projection.init(false)),\n        ...replayProcessManagers.map((projection) => projection.init(false)),\n        ...replayProjections.map((projection) => projection.beginReplay()),\n        ...replayProcessManagers.map((processManager) =>\n          processManager.beginRefresh(),\n        ),\n      ])\n\n      await withRefreshing(async () => {\n        let index = 0\n        for await (const event of loadEvents(null)) {\n          index++\n          await Promise.all([\n            ...replayProjections.map((projection) =>\n              projection.progressReplay(index, event),\n            ),\n            ...replayProcessManagers.map((processManager) =>\n              processManager.progressRefresh(index, event, false),\n            ),\n            ...Array.from(eventListeners.values(), (listener) =>\n              listener.apply(event),\n            ),\n          ])\n          await Promise.all([\n            ...replayProcessManagers.map((processManager) =>\n              processManager.progressRefresh(index, event, true),\n            ),\n            ...Array.from(eventListeners.values(), (listener) =>\n              listener.applyAfter(event),\n            ),\n          ])\n        }\n      })\n\n      await Promise.all([\n        ...replayProjections.map((projection) => projection.endReplay()),\n        ...replayProcessManagers.map((processManager) =>\n          processManager.endRefresh(),\n        ),\n      ])\n\n      await Promise.all(\n        projections.values().map(async (projection) => {\n          if (!projection.canReplay()) {\n            await projection.init(true)\n          }\n        }),\n      )\n      resolveInitialized()\n    },\n    async init() {\n      if (initializing) {\n        return api\n      }\n      await initialize()\n      return api\n    },\n    getAggregateRoot(type) {\n      return params.aggregateRoots.find(\n        (aggregateRoot) => aggregateRoot.type === type,\n      ) as any\n    },\n    async transaction(handler) {\n      return transaction.run(handler)\n    },\n  } as EventStore<any, Root>\n\n  return api\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "7493A3991CE6299464756E2164756E21",
-  "names": []
-}

package/dist/utilityTypes.d.js

@@ -1,2 +0,0 @@
-
-//# debugId=58F9CE05763C4DBF64756E2164756E21