@requence/event-sourcing 1.4.0 → 1.5.0

package/src/tests/storageDriverContract.ts

@@ -0,0 +1,612 @@
+import { describe, expect, it } from 'bun:test'
+
+import type {
+  Snapshot as AggregateRootSnapshot,
+  AggregateRootSnapshotMethods,
+} from '../createAggregateRoot.ts'
+import type { Checkpoint, CheckpointMethods } from '../createCheckpointApi.ts'
+import type { LoadEvents } from '../createEventStore.ts'
+import type {
+  Snapshot as ProjectionSnapshot,
+  ProjectionSnapshotMethods,
+} from '../createProjection.ts'
+import { ConcurrencyError } from '../errors.ts'
+import type {
+  BaseInputEvent,
+  BaseOutputEvent,
+  MaybePromise,
+  StreamId,
+} from '../utilityTypes.ts'
+
+export type StorageDriver = {
+  loadEvents: LoadEvents
+  appendEvents: (
+    streamId: StreamId,
+    events: BaseInputEvent[],
+    expectedVersion: number,
+  ) => MaybePromise<BaseOutputEvent[]>
+  checkpoint: CheckpointMethods
+  projectionSnapshot: ProjectionSnapshotMethods
+  aggregateRootSnapshot: AggregateRootSnapshotMethods
+}
+
+function inputEvent(
+  type: string,
+  payload: unknown,
+  overrides?: Partial<BaseInputEvent>,
+): BaseInputEvent {
+  return {
+    type,
+    payload,
+    metadata: {},
+    schemaVersion: 1,
+    ...overrides,
+  } as BaseInputEvent
+}
+
+// Works for drivers that throw synchronously (memory) and asynchronously.
+async function expectConcurrencyError(run: () => MaybePromise<unknown>) {
+  let error: unknown
+  try {
+    await run()
+  } catch (err) {
+    error = err
+  }
+  expect(error).toBeInstanceOf(ConcurrencyError)
+}
+
+async function collect(events: AsyncGenerator<BaseOutputEvent>) {
+  const resolved: BaseOutputEvent[] = []
+  for await (const event of events) {
+    resolved.push(event)
+  }
+  return resolved
+}
+
+function checkpointFixture(overrides?: Partial<Checkpoint>): Checkpoint {
+  return {
+    type: 'projection',
+    name: 'test',
+    lastEventPosition: 1,
+    metadata: {},
+    version: 1,
+    ...overrides,
+  }
+}
+
+/**
+ * Reusable contract suite exercising the raw storage methods every driver
+ * must supply to the core `createEventStore`. Call it once per driver with a
+ * factory producing a fresh, empty storage instance.
+ */
+export function runStorageDriverContract(
+  name: string,
+  makeStorage: () => MaybePromise<StorageDriver>,
+) {
+  describe(`storage driver contract: ${name}`, () => {
+    describe('appendEvents', () => {
+      it('persists events with stream versions, positions and createdAt', async () => {
+        const storage = await makeStorage()
+        const persisted = await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [
+            inputEvent('created', { total: 1 }),
+            inputEvent('updated', { total: 2 }),
+          ],
+          0,
+        )
+
+        expect(persisted).toHaveLength(2)
+        expect(persisted[0].streamVersion).toBe(1)
+        expect(persisted[1].streamVersion).toBe(2)
+        expect(persisted[0].streamId).toBe('o1')
+        expect(persisted[0].streamType).toBe('order')
+        expect(persisted[1].position).toBeGreaterThan(persisted[0].position)
+        expect(persisted[0].createdAt).toBeInstanceOf(Date)
+        expect(persisted[0].payload).toEqual({ total: 1 })
+      })
+
+      it('continues stream versions across appends', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', {})],
+          0,
+        )
+        const second = await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('updated', {})],
+          1,
+        )
+
+        expect(second[0].streamVersion).toBe(2)
+      })
+
+      it('throws ConcurrencyError when the expected version is stale', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', {})],
+          0,
+        )
+
+        await expectConcurrencyError(() =>
+          storage.appendEvents(
+            { stream: 'order', id: 'o1' },
+            [inputEvent('updated', {})],
+            0,
+          ),
+        )
+      })
+
+      it('throws ConcurrencyError when expecting events on a fresh stream', async () => {
+        const storage = await makeStorage()
+
+        await expectConcurrencyError(() =>
+          storage.appendEvents(
+            { stream: 'order', id: 'missing' },
+            [inputEvent('updated', {})],
+            3,
+          ),
+        )
+      })
+
+      it('tracks versions per stream independently', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', {})],
+          0,
+        )
+        const other = await storage.appendEvents(
+          { stream: 'order', id: 'o2' },
+          [inputEvent('created', {})],
+          0,
+        )
+
+        expect(other[0].streamVersion).toBe(1)
+      })
+
+      it('round-trips complex payloads and metadata through superjson types', async () => {
+        const storage = await makeStorage()
+        const createdAt = new Date('2024-05-04T03:02:01.000Z')
+        const payload = {
+          when: createdAt,
+          tags: new Map([['a', 1]]),
+          missing: undefined,
+          nested: { deep: [1, 2, 3] },
+        }
+
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', payload, { metadata: { at: createdAt } })],
+          0,
+        )
+
+        const [event] = await collect(
+          storage.loadEvents({ stream: 'order', id: 'o1' }),
+        )
+        expect(event.payload).toEqual(payload)
+        expect((event.metadata as any).at).toEqual(createdAt)
+      })
+    })
+
+    describe('loadEvents', () => {
+      it('yields all events globally ordered by position', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', { n: 1 })],
+          0,
+        )
+        await storage.appendEvents(
+          { stream: 'invoice', id: 'i1' },
+          [inputEvent('issued', { n: 2 })],
+          0,
+        )
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('updated', { n: 3 })],
+          1,
+        )
+
+        const events = await collect(storage.loadEvents(null))
+        expect(events).toHaveLength(3)
+        expect(events.map((event) => (event.payload as any).n)).toEqual([
+          1, 2, 3,
+        ])
+        for (let index = 1; index < events.length; index++) {
+          expect(events[index].position).toBeGreaterThan(
+            events[index - 1].position,
+          )
+        }
+      })
+
+      it('paginates beyond the chunk size without gaps or duplicates', async () => {
+        const storage = await makeStorage()
+        const total = 120
+        for (let index = 0; index < total; index += 20) {
+          await storage.appendEvents(
+            { stream: 'order', id: 'o1' },
+            Array.from({ length: 20 }, (_, offset) =>
+              inputEvent('created', { n: index + offset }),
+            ),
+            index,
+          )
+        }
+
+        const events = await collect(storage.loadEvents(null))
+        expect(events).toHaveLength(total)
+        expect(events.map((event) => (event.payload as any).n)).toEqual(
+          Array.from({ length: total }, (_, n) => n),
+        )
+      })
+
+      it('filters by stream type', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', {})],
+          0,
+        )
+        await storage.appendEvents(
+          { stream: 'invoice', id: 'i1' },
+          [inputEvent('issued', {})],
+          0,
+        )
+
+        const events = await collect(storage.loadEvents({ stream: 'order' }))
+        expect(events).toHaveLength(1)
+        expect(events[0].streamType).toBe('order')
+      })
+
+      it('filters by stream type and id', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [inputEvent('created', {})],
+          0,
+        )
+        await storage.appendEvents(
+          { stream: 'order', id: 'o2' },
+          [inputEvent('created', {})],
+          0,
+        )
+
+        const events = await collect(
+          storage.loadEvents({ stream: 'order', id: 'o2' }),
+        )
+        expect(events).toHaveLength(1)
+        expect(events[0].streamId).toBe('o2')
+      })
+
+      it('filters by stream events', async () => {
+        const storage = await makeStorage()
+        await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          [
+            inputEvent('created', {}),
+            inputEvent('updated', {}),
+            inputEvent('shipped', {}),
+          ],
+          0,
+        )
+
+        const events = await collect(
+          storage.loadEvents({
+            stream: 'order',
+            events: ['created', 'shipped'],
+          }),
+        )
+        expect(events.map((event) => event.type)).toEqual([
+          'created',
+          'shipped',
+        ])
+      })
+
+      it('honors range.from and range.to inclusively', async () => {
+        const storage = await makeStorage()
+        const persisted = await storage.appendEvents(
+          { stream: 'order', id: 'o1' },
+          Array.from({ length: 5 }, (_, n) => inputEvent('created', { n })),
+          0,
+        )
+
+        const from = persisted[1].position
+        const to = persisted[3].position
+        const events = await collect(storage.loadEvents(null, { from, to }))
+
+        expect(events.map((event) => event.position)).toEqual([
+          persisted[1].position,
+          persisted[2].position,
+          persisted[3].position,
+        ])
+      })
+    })
+
+    describe('checkpoint', () => {
+      it('inserts with a null expected version and reads it back', async () => {
+        const storage = await makeStorage()
+        const checkpoint = checkpointFixture({ metadata: { cursor: 'abc' } })
+
+        expect(await storage.checkpoint.upsert(checkpoint, null)).toBe(true)
+
+        const stored = await storage.checkpoint.get('projection', 'test')
+        expect(stored).toBeTruthy()
+        expect(stored!.lastEventPosition).toBe(1)
+        expect(stored!.version).toBe(1)
+        expect(stored!.metadata).toEqual({ cursor: 'abc' })
+      })
+
+      it('rejects an insert-only upsert when the checkpoint already exists', async () => {
+        const storage = await makeStorage()
+        await storage.checkpoint.upsert(checkpointFixture(), null)
+
+        expect(await storage.checkpoint.upsert(checkpointFixture(), null)).toBe(
+          false,
+        )
+      })
+
+      it('applies the write when the expected version matches', async () => {
+        const storage = await makeStorage()
+        await storage.checkpoint.upsert(checkpointFixture({ version: 1 }), null)
+
+        expect(
+          await storage.checkpoint.upsert(
+            checkpointFixture({ lastEventPosition: 9, version: 2 }),
+            1,
+          ),
+        ).toBe(true)
+
+        const stored = await storage.checkpoint.get('projection', 'test')
+        expect(stored!.lastEventPosition).toBe(9)
+        expect(stored!.version).toBe(2)
+      })
+
+      it('rejects the write when the expected version is stale', async () => {
+        const storage = await makeStorage()
+        await storage.checkpoint.upsert(checkpointFixture({ version: 2 }), null)
+
+        expect(
+          await storage.checkpoint.upsert(
+            checkpointFixture({ lastEventPosition: 9, version: 3 }),
+            1,
+          ),
+        ).toBe(false)
+
+        const stored = await storage.checkpoint.get('projection', 'test')
+        expect(stored!.lastEventPosition).toBe(1)
+        expect(stored!.version).toBe(2)
+      })
+
+      it('inserts when expecting a version on a missing checkpoint', async () => {
+        const storage = await makeStorage()
+
+        expect(
+          await storage.checkpoint.upsert(checkpointFixture({ version: 5 }), 4),
+        ).toBe(true)
+
+        const stored = await storage.checkpoint.get('projection', 'test')
+        expect(stored!.version).toBe(5)
+      })
+
+      it('keeps checkpoints of different types and names separate', async () => {
+        const storage = await makeStorage()
+        await storage.checkpoint.upsert(
+          checkpointFixture({ type: 'projection', lastEventPosition: 1 }),
+          null,
+        )
+        await storage.checkpoint.upsert(
+          checkpointFixture({ type: 'processManager', lastEventPosition: 2 }),
+          null,
+        )
+
+        const projection = await storage.checkpoint.get('projection', 'test')
+        const processManager = await storage.checkpoint.get(
+          'processManager',
+          'test',
+        )
+        expect(projection!.lastEventPosition).toBe(1)
+        expect(processManager!.lastEventPosition).toBe(2)
+        expect(await storage.checkpoint.get('projection', 'other')).toBeFalsy()
+      })
+
+      it('deletes a checkpoint', async () => {
+        const storage = await makeStorage()
+        await storage.checkpoint.upsert(checkpointFixture(), null)
+        await storage.checkpoint.delete('projection', 'test')
+
+        expect(await storage.checkpoint.get('projection', 'test')).toBeFalsy()
+      })
+    })
+
+    describe('projectionSnapshot', () => {
+      const snapshotFixture = (
+        overrides?: Partial<ProjectionSnapshot>,
+      ): ProjectionSnapshot => ({
+        projectionId: 'p1',
+        projectionType: 'orders',
+        lastEventPosition: 1,
+        state: { count: 1 },
+        metadata: { origin: 'test' },
+        schemaVersion: 1,
+        createdAt: new Date(),
+        ...overrides,
+      })
+
+      it('returns the snapshot with the highest event position', async () => {
+        const storage = await makeStorage()
+        await storage.projectionSnapshot.put(snapshotFixture())
+        await storage.projectionSnapshot.put(
+          snapshotFixture({ lastEventPosition: 7, state: { count: 7 } }),
+        )
+
+        const snapshot = await storage.projectionSnapshot.get({
+          projection: 'orders',
+          id: 'p1',
+        })
+        expect(snapshot!.lastEventPosition).toBe(7)
+        expect(snapshot!.state).toEqual({ count: 7 })
+        expect(snapshot!.metadata).toEqual({ origin: 'test' })
+        expect(snapshot!.createdAt).toBeInstanceOf(Date)
+      })
+
+      it('returns nothing for unknown projections', async () => {
+        const storage = await makeStorage()
+
+        expect(
+          await storage.projectionSnapshot.get({
+            projection: 'orders',
+            id: 'missing',
+          }),
+        ).toBeFalsy()
+      })
+
+      it('deletes snapshots above a position', async () => {
+        const storage = await makeStorage()
+        await storage.projectionSnapshot.put(
+          snapshotFixture({ lastEventPosition: 2 }),
+        )
+        await storage.projectionSnapshot.put(
+          snapshotFixture({ lastEventPosition: 9 }),
+        )
+
+        await storage.projectionSnapshot.delete(
+          { projection: 'orders', id: 'p1' },
+          5,
+        )
+
+        const snapshot = await storage.projectionSnapshot.get({
+          projection: 'orders',
+          id: 'p1',
+        })
+        expect(snapshot!.lastEventPosition).toBe(2)
+      })
+
+      it('deletes all snapshots of a projection', async () => {
+        const storage = await makeStorage()
+        await storage.projectionSnapshot.put(snapshotFixture())
+        await storage.projectionSnapshot.put(
+          snapshotFixture({ projectionId: 'p2' }),
+        )
+
+        await storage.projectionSnapshot.delete({ projection: 'orders' })
+
+        expect(
+          await storage.projectionSnapshot.get({
+            projection: 'orders',
+            id: 'p1',
+          }),
+        ).toBeFalsy()
+        expect(
+          await storage.projectionSnapshot.get({
+            projection: 'orders',
+            id: 'p2',
+          }),
+        ).toBeFalsy()
+      })
+
+      it('increments applied counts per projection instance', async () => {
+        const storage = await makeStorage()
+        const target = { projection: 'orders', id: 'p1' }
+
+        expect(
+          await storage.projectionSnapshot.incrementAppliedCount(target),
+        ).toBe(1)
+        expect(
+          await storage.projectionSnapshot.incrementAppliedCount(target),
+        ).toBe(2)
+        expect(
+          await storage.projectionSnapshot.incrementAppliedCount({
+            projection: 'orders',
+            id: 'p2',
+          }),
+        ).toBe(1)
+      })
+    })
+
+    describe('aggregateRootSnapshot', () => {
+      const snapshotFixture = (
+        overrides?: Partial<AggregateRootSnapshot>,
+      ): AggregateRootSnapshot => ({
+        streamId: 's1',
+        streamType: 'order',
+        streamVersion: 1,
+        lastEventPosition: 1,
+        state: { total: 1 },
+        metadata: { origin: 'test' },
+        schemaVersion: 1,
+        createdAt: new Date(),
+        ...overrides,
+      })
+
+      it('returns the snapshot with the highest stream version', async () => {
+        const storage = await makeStorage()
+        await storage.aggregateRootSnapshot.put(snapshotFixture())
+        await storage.aggregateRootSnapshot.put(
+          snapshotFixture({
+            streamVersion: 4,
+            lastEventPosition: 9,
+            state: { total: 4 },
+          }),
+        )
+
+        const snapshot = await storage.aggregateRootSnapshot.get({
+          stream: 'order',
+          id: 's1',
+        })
+        expect(snapshot!.streamVersion).toBe(4)
+        expect(snapshot!.state).toEqual({ total: 4 })
+        expect(snapshot!.createdAt).toBeInstanceOf(Date)
+      })
+
+      it('returns nothing for unknown streams', async () => {
+        const storage = await makeStorage()
+
+        expect(
+          await storage.aggregateRootSnapshot.get({
+            stream: 'order',
+            id: 'missing',
+          }),
+        ).toBeFalsy()
+      })
+
+      it('deletes snapshots above a stream version', async () => {
+        const storage = await makeStorage()
+        await storage.aggregateRootSnapshot.put(
+          snapshotFixture({ streamVersion: 4 }),
+        )
+
+        await storage.aggregateRootSnapshot.delete(
+          { stream: 'order', id: 's1' },
+          2,
+        )
+
+        expect(
+          await storage.aggregateRootSnapshot.get({
+            stream: 'order',
+            id: 's1',
+          }),
+        ).toBeFalsy()
+      })
+
+      it('keeps snapshots at or below the deletion version', async () => {
+        const storage = await makeStorage()
+        await storage.aggregateRootSnapshot.put(
+          snapshotFixture({ streamVersion: 2 }),
+        )
+
+        await storage.aggregateRootSnapshot.delete(
+          { stream: 'order', id: 's1' },
+          2,
+        )
+
+        const snapshot = await storage.aggregateRootSnapshot.get({
+          stream: 'order',
+          id: 's1',
+        })
+        expect(snapshot!.streamVersion).toBe(2)
+      })
+    })
+  })
+}

package/dist/chunk-3ejt4h7x.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/createProjection.ts"],
-  "sourcesContent": [
-    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport z from 'zod/v4'\n\nimport {\n  type CheckpointApi,\n  type CheckpointMethods,\n  createCheckpointApi,\n} from './createCheckpointApi.ts'\nimport type { LoadEvents, OnProgress } from './createEventStore.ts'\nimport {\n  ProjectionEventHandlerExecutionError,\n  ProjectionReplayLoopError,\n  ReplaySkipError,\n  ValidationError,\n} from './errors.ts'\nimport { isReplaying, withReplaying } from './replay.ts'\nimport type {\n  CompleteSnapshotGenerator,\n  InternalSnapshotGenerator,\n  SnapshotGenerator,\n} from './snapshotGenerator.ts'\nimport createSnapshotGenerator from './snapshotGenerator.ts'\nimport type {\n  AllEvents,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  Keys,\n  MaybePromise,\n  Merge,\n  OutputEvent,\n  StreamEvents,\n} from './utilityTypes.d.ts'\n\nconst hydratingStore = new AsyncLocalStorage<boolean>()\n\nfunction isHydrating() {\n  return hydratingStore.getStore() ?? false\n}\n\nasync function withHydrating(handler: () => Promise<void>) {\n  await hydratingStore.run(true, handler)\n}\n\ntype ProjectionInfo = {\n  name: string\n  event: BaseOutputEvent\n}\nconst projectionInfoStore = new AsyncLocalStorage<ProjectionInfo>()\n\nfunction withProjectionInfo(\n  info: ProjectionInfo,\n  handler: () => Promise<void>,\n) {\n  return projectionInfoStore.run(info, handler)\n}\n\nexport function getProjectionInfo() {\n  return projectionInfoStore.getStore()\n}\n\nexport function isInsideProjection() {\n  return Boolean(getProjectionInfo())\n}\n\ntype ReplayConfig = {\n  deleteOne?: (id: string) => MaybePromise<void>\n  deleteAll?: () => MaybePromise<void>\n}\n\ntype ProjectionEventHandlers<Events extends EventTemplate> = EventHandlers<\n  Events,\n  {\n    replaying: boolean\n    replayUntil: (\n      position: number,\n      filterEvents?: (event: OutputEvent<Events>) => boolean,\n    ) => Promise<void>\n  }\n>\n\ntype ReplayProjection<Events extends EventTemplate> = {\n  replayOne: (streamId: string) => Promise<void>\n  replayUntil: (\n    streamId: string,\n    position: number,\n    filterEvents?: (event: OutputEvent<Events>) => boolean,\n  ) => Promise<void>\n  replay: () => Promise<void>\n}\n\nexport type InternalProjection = {\n  apply: (event: BaseOutputEvent) => Promise<void>\n  setRelatedStreamEvents: (\n    generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<EventTemplate>,\n    ) => StreamEvents[],\n  ) => void\n  isReady(): Promise<void>\n  canReplay(): boolean\n  beginReplay(): Promise<void>\n  progressReplay(index: number, event: BaseOutputEvent): Promise<void>\n  endReplay(): void\n  init(catchUp: boolean): Promise<void>\n}\n\nexport type ProjectionApi<\n  Events extends EventTemplate = never,\n  RConfig extends ReplayConfig = never,\n  Flags extends {\n    withEventHandlers: boolean\n    withGlobalEventHandler: boolean\n    concurrent: boolean\n    withReplay: boolean\n    withSnapshots: boolean\n  } = {\n    withEventHandlers: false\n    withGlobalEventHandler: false\n    concurrent: false\n    withReplay: false\n    withSnapshots: true\n  },\n> = {\n  withEventHandlers: (\n    handlers: ProjectionEventHandlers<Events>,\n  ) => Omit<\n    ProjectionApi<Events, RConfig, Merge<Flags, { withEventHandlers: true }>>,\n    Keys<Merge<Flags, { withEventHandlers: true }>>\n  >\n  withGlobalEventHandler: (\n    handler: (\n      event: AllEvents<Events>,\n      methods: ReplayProjection<Events>,\n    ) => MaybePromise<void>,\n  ) => Omit<\n    ProjectionApi<\n      Events,\n      RConfig,\n      Merge<Flags, { withGlobalEventHandler: true }>\n    >,\n    Keys<Merge<Flags, { withGlobalEventHandler: true }>>\n  >\n  concurrent: () => Omit<\n    ProjectionApi<Events, RConfig, Merge<Flags, { concurrent: true }>>,\n    Keys<Merge<Flags, { concurrent: true }>>\n  >\n  withReplay: <Config extends ReplayConfig>(\n    config: Config,\n  ) => Omit<\n    ProjectionApi<Events, Config, Merge<Flags, { withReplay: true }>>,\n    Keys<Merge<Flags, { withReplay: true }>>\n  >\n  withSnapshots: (\n    handler: (\n      generator: SnapshotGenerator<Omit<Snapshot, 'schemaVersion' | 'state'>>,\n    ) => CompleteSnapshotGenerator,\n  ) => Omit<\n    ProjectionApi<Events, RConfig, Merge<Flags, { withSnapshots: true }>>,\n    Keys<Merge<Flags, { withSnapshots: true }>>\n  >\n  isReady(): Promise<void>\n} & ('deleteOne' extends keyof RConfig\n  ? Pick<ReplayProjection<Events>, 'replayOne' | 'replayUntil'>\n  : {}) &\n  ('deleteAll' extends keyof RConfig\n    ? Pick<ReplayProjection<Events>, 'replay'>\n    : {})\n\nexport type ProjectionApiWithSnapshots<\n  Events extends EventTemplate = never,\n  RConfig extends ReplayConfig = never,\n  Flags extends {\n    withEventHandlers: boolean\n    withGlobalEventHandler: boolean\n    concurrent: boolean\n    withReplay: boolean\n    withSnapshots: boolean\n  } = {\n    withEventHandlers: false\n    withGlobalEventHandler: false\n    concurrent: false\n    withReplay: false\n    withSnapshots: false\n  },\n> = ProjectionApi<Events, RConfig, Flags>\n\nconst snapshotSchema = z.object({\n  projectionId: z.string(),\n  projectionType: z.string(),\n  lastEventPosition: z.int(),\n  state: z.unknown(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  schemaVersion: z.int(),\n  createdAt: z.date(),\n})\n\nexport type Snapshot = z.output<typeof snapshotSchema>\n\nexport type ProjectionSnapshotMethods = {\n  get: (select: {\n    projection: string\n    id: string\n  }) => MaybePromise<Snapshot | null | undefined>\n  put: (snapshot: Snapshot) => MaybePromise<void>\n  delete: (\n    target: { id?: string; projection: string },\n    fromPosition?: number,\n  ) => MaybePromise<void>\n  incrementAppliedCount: (target: {\n    projection: string\n    id: string\n  }) => MaybePromise<number>\n}\n\nexport function buildProjectionCreator(params: {\n  loadEvents: LoadEvents\n  checkpoint: CheckpointMethods\n  onReplay?: OnProgress\n  snapshot?: ProjectionSnapshotMethods\n}): (name: string) => ProjectionApi {\n  return (name) => {\n    let idle = true\n    let replaying = false\n    let handlers: ProjectionEventHandlers<any> = {}\n    let globalEventHandler:\n      | ((event: BaseOutputEvent) => MaybePromise<void>)\n      | null = null\n    let generateRelatedStreamEvents: (\n      eventHandlers: EventHandlers<any>,\n    ) => StreamEvents[]\n    let relatedStreamEvents: StreamEvents[] | null = null\n    let exclusive = true\n    let checkpointApi: CheckpointApi\n    let lastEventPosition = -1\n\n    let replayConfig: ReplayConfig | null = null\n\n    let snapshotting:\n      | (CompleteSnapshotGenerator & InternalSnapshotGenerator)\n      | null = null\n\n    const { promise: hydrated, resolve: resolveHydrated } =\n      Promise.withResolvers<void>()\n\n    const locks = new Map<string, Promise<void>>()\n    const apply = async (event: BaseOutputEvent) => {\n      const handler = handlers[`on${event.type}`]\n      if (!handler && !globalEventHandler) {\n        return Promise.resolve()\n      }\n\n      if (isHydrating()) {\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\n      const unlocked = !exclusive\n        ? Promise.resolve()\n        : (locks.get(event.streamId)?.catch(() => {}) ?? Promise.resolve())\n\n      const runner = (async () => {\n        await unlocked\n        await withProjectionInfo({ name, event }, async () => {\n          try {\n            await handler?.(event, {\n              replaying,\n              async replayUntil(position, filterEvents) {\n                if (position >= event.position) {\n                  throw new ProjectionReplayLoopError(\n                    `Event handler on${event.type} of projection ${name} tried to replay to the future`,\n                    { name, eventHandler: `on${event.type}` },\n                    event,\n                  )\n                }\n\n                locks.delete(event.streamId)\n                return api.replayUntil(event.streamId, position, filterEvents)\n              },\n            })\n          } catch (error) {\n            if (error instanceof ReplaySkipError) {\n              if (isReplaying()) {\n                return\n              }\n\n              throw new Error(\n                'ReplaySkipError should never be thrown outside replay',\n              )\n            }\n\n            if (\n              !(error instanceof Error) ||\n              error instanceof ProjectionReplayLoopError\n            ) {\n              throw error\n            }\n            throw new ProjectionEventHandlerExecutionError(\n              name,\n              `on${event.type}`,\n              event,\n              error,\n            )\n          }\n          try {\n            await globalEventHandler?.(event)\n          } catch (error) {\n            if (!(error instanceof Error)) {\n              throw error\n            }\n\n            throw new ProjectionEventHandlerExecutionError(\n              name,\n              'GLOBAL',\n              event,\n              error,\n            )\n          }\n        })\n\n        if (params.snapshot && snapshotting) {\n          const appliedEvents = await params.snapshot.incrementAppliedCount({\n            projection: name,\n            id: event.streamId,\n          })\n          const snapshot = await snapshotting.internalCapture(\n            event,\n            appliedEvents,\n          )\n\n          if (snapshot) {\n            await params.snapshot.put({\n              projectionType: name,\n              projectionId: event.streamId,\n              lastEventPosition: event.position,\n              state: snapshot.state,\n              schemaVersion: snapshot.version,\n              createdAt: new Date(),\n            })\n          }\n        }\n\n        await checkpointApi.upsert(event)\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 resolveReplay: null | (() => void) = null\n    let resolveReplayOne: null | (() => void) = null\n    let replayOneStreamId: null | string = null\n\n    const api = {\n      name: 'projection ' + name,\n      async isReady() {\n        await hydrated\n      },\n      withEventHandlers(h) {\n        handlers = h\n        return api\n      },\n      withGlobalEventHandler(handler) {\n        globalEventHandler = handler as any\n        return api\n      },\n      concurrent() {\n        exclusive = false\n        return api\n      },\n      setRelatedStreamEvents(generate) {\n        generateRelatedStreamEvents = generate\n      },\n      withReplay(config) {\n        replayConfig = config\n        return api as any\n      },\n\n      withSnapshots(handler) {\n        snapshotting = handler(createSnapshotGenerator() as any) as any\n        return api\n      },\n\n      async apply(event) {\n        await apply(event)\n      },\n\n      async replayOne(streamId: string) {\n        if (!idle) {\n          await replayOne(streamId)\n          return\n        }\n\n        const { promise, resolve } = Promise.withResolvers<void>()\n        resolveReplayOne = resolve\n        replayOneStreamId = streamId\n        return promise\n      },\n\n      async replay() {\n        if (!idle) {\n          await replay()\n          return\n        }\n        const { promise, resolve } = Promise.withResolvers<void>()\n        resolveReplay = resolve\n        return promise\n      },\n\n      canReplay() {\n        return Boolean(replayConfig)\n      },\n\n      async beginReplay() {\n        if (!replayConfig?.deleteAll) {\n          throw new Error(\n            'this projection does not support replay all. withReplay({ deleteAll }) not implemented.',\n          )\n        }\n\n        lastEventPosition = -1\n        params.onReplay?.begin?.(name)\n        await params.snapshot?.delete({ projection: name })\n        await replayConfig.deleteAll()\n      },\n\n      async progressReplay(index, event) {\n        await withReplaying(() => withHydrating(() => apply(event)))\n        if (\n          !checkpointApi.relatedStreamEvents ||\n          checkpointApi.relatedStreamEvents.some((streamEvent) =>\n            streamEvent.events.includes(event.type),\n          )\n        ) {\n          params.onReplay?.progress?.(name, index, event)\n        }\n      },\n\n      endReplay() {\n        params.onReplay?.end?.(name)\n        resolveHydrated()\n      },\n\n      async replayUntil(id, position, filterEvents = () => true) {\n        let startPosition = 0\n        if (snapshotting) {\n          await params.snapshot?.delete({ id, projection: name }, position)\n          const snapshot = await params.snapshot?.get({ id, projection: name })\n          if (snapshot) {\n            const result = snapshotSchema.safeParse(snapshot)\n\n            if (!result.success) {\n              throw new ValidationError(\n                'loaded projection snapshot does not comply with schema',\n                result.error,\n              )\n            }\n            snapshotting.internalApply(result.data)\n            startPosition = result.data.lastEventPosition + 1\n          }\n        }\n\n        const events = params.loadEvents(\n          relatedStreamEvents?.map((relatedStreamEvent) => ({\n            ...relatedStreamEvent,\n            id,\n          })) ?? null,\n          {\n            from: startPosition,\n            to: position,\n          },\n        )\n\n        replaying = true\n        await withReplaying(async () => {\n          for await (const event of events) {\n            if ((filterEvents as (event: BaseOutputEvent) => boolean)(event)) {\n              await apply(event)\n            }\n          }\n        })\n        replaying = false\n      },\n      async init(catchUp) {\n        idle = false\n        relatedStreamEvents = globalEventHandler\n          ? null\n          : generateRelatedStreamEvents(handlers as EventHandlers<any>)\n        checkpointApi = createCheckpointApi({\n          ...params.checkpoint,\n          name,\n          relatedStreamEvents,\n          type: 'projection',\n          loadEvents: params.loadEvents,\n          apply: (event) => withHydrating(() => apply(event)),\n        })\n\n        if (resolveReplay) {\n          await replay()\n          resolveReplay()\n          return\n        }\n\n        if (resolveReplayOne && replayOneStreamId) {\n          await replayOne(replayOneStreamId)\n        }\n\n        if (!catchUp) {\n          return\n        }\n\n        await checkpointApi.rehydrated()\n        resolveHydrated()\n        resolveReplayOne?.()\n      },\n    } as ProjectionApi & InternalProjection & ReplayProjection<any>\n\n    async function replayOne(id: string) {\n      if (!replayConfig?.deleteOne) {\n        throw new Error(\n          'this projection does not support replay one. withReplay({ deleteOne }) not implemented.',\n        )\n      }\n      await params.snapshot?.delete({ id, projection: name })\n      await replayConfig.deleteOne(id)\n      const streamIds = relatedStreamEvents\n        ? relatedStreamEvents.map((relatedStreamEvent) => ({\n            ...relatedStreamEvent,\n            id,\n          }))\n        : null\n      const events = params.loadEvents(streamIds)\n\n      replaying = true\n      await withReplaying(async () => {\n        for await (const event of events) {\n          await withHydrating(() => apply(event))\n        }\n      })\n      replaying = false\n    }\n\n    async function replay() {\n      await api.beginReplay()\n      const events = params.loadEvents(relatedStreamEvents)\n      let index = 0\n      replaying = true\n      await withReplaying(async () => {\n        for await (const event of events) {\n          await api.progressReplay(index, event)\n          index++\n        }\n      })\n      replaying = false\n      api.endReplay()\n    }\n\n    return api\n  }\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "059753BED2CE852D64756E2164756E21",
-  "names": []
-}