@requence/event-sourcing 1.4.1 → 1.5.1

package/src/memory/index.ts

@@ -1,5 +1,9 @@
-import type { AnyAggregateRoot } from '../createAggregateRoot.ts'
-import type { Checkpoint } from '../createCheckpointApi.ts'
+import type {
+  AggregateRootSnapshotMethods,
+  AnyAggregateRoot,
+} from '../createAggregateRoot.ts'
+import type { Checkpoint, CheckpointMethods } from '../createCheckpointApi.ts'
+import type { ProjectionSnapshotMethods } from '../createProjection.ts'
 import {
   type AggregateRootSnapshot,
   ConcurrencyError,
@@ -13,16 +17,20 @@ import type {
   EventStore,
   EventStoreParamsWithAggregateRootSnapshots,
   EventsFromRoot,
+  LoadEvents,
   OnProgress,
 } from '../createEventStore.ts'
 import type { LockCreator } from '../lock.ts'
-import type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js'
+import type {
+  BaseInputEvent,
+  BaseOutputEvent,
+  MaybePromise,
+  StreamId,
+} from '../utilityTypes.js'
 
 export { createAggregateRoot } from '../index.ts'
 
-export type OnEventsAppended = (
-  events: BaseOutputEvent[],
-) => MaybePromise<void>
+export type OnEventsAppended = (events: BaseOutputEvent[]) => MaybePromise<void>
 
 interface MemoryEventStoreParams<Root extends AnyAggregateRoot> {
   aggregateRoots: Root[]
@@ -34,33 +42,26 @@ interface MemoryEventStoreParams<Root extends AnyAggregateRoot> {
   onEventsAppended?: OnEventsAppended
 }
 
-export function createEventStore<const Root extends AnyAggregateRoot>({
-  aggregateRoots,
-  postProcessEvent,
-  onProjectionReplay,
-  onProcessManagerRefresh,
-  onEventsAppended,
-  autoInit,
-  lock,
-}: MemoryEventStoreParams<Root>): EventStore<
-  EventsFromRoot<Root>,
-  Root,
-  true
-> {
+export function createMemoryStorage(params?: {
+  onEventsAppended?: OnEventsAppended
+}): {
+  loadEvents: LoadEvents
+  appendEvents: (
+    streamId: StreamId,
+    events: BaseInputEvent[],
+    expectedVersion: number,
+  ) => BaseOutputEvent[]
+  checkpoint: CheckpointMethods
+  projectionSnapshot: ProjectionSnapshotMethods
+  aggregateRootSnapshot: AggregateRootSnapshotMethods
+} {
   const events: Event[] = []
   const checkpoints = new Set<Checkpoint>()
   const aggregateRootSnapshots = new Map<string, AggregateRootSnapshot>()
   const projectionSnapshots = new Set<ProjectionSnapshot>()
   const projectionAppliedCount = new Map<string, number>()
 
-  return createBaseEventStore({
-    aggregateRoots,
-    postProcessEvent,
-    onProjectionReplay,
-    onProcessManagerRefresh,
-    autoInit,
-    lock,
-
+  return {
     async *loadEvents(select, range) {
       let streamTypes: string[] | null = null
       let streamIds: string[] | null = null
@@ -131,7 +132,7 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
       }))
 
       events.push(...extendedEvents)
-      onEventsAppended?.(extendedEvents)
+      params?.onEventsAppended?.(extendedEvents)
       return extendedEvents
     },
 
@@ -155,7 +156,10 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
         if (persisted) {
           // Compare-and-swap: reject the write when another writer advanced the
           // checkpoint, or when the caller expected to create a fresh one.
-          if (expectedVersion === null || persisted.version !== expectedVersion) {
+          if (
+            expectedVersion === null ||
+            persisted.version !== expectedVersion
+          ) {
             return false
           }
           persisted.lastEventPosition = checkpoint.lastEventPosition
@@ -232,5 +236,27 @@ export function createEventStore<const Root extends AnyAggregateRoot>({
         }
       },
     },
+  }
+}
+
+export function createEventStore<const Root extends AnyAggregateRoot>({
+  aggregateRoots,
+  postProcessEvent,
+  onProjectionReplay,
+  onProcessManagerRefresh,
+  onEventsAppended,
+  autoInit,
+  lock,
+}: MemoryEventStoreParams<Root>): EventStore<EventsFromRoot<Root>, Root, true> {
+  const storage = createMemoryStorage({ onEventsAppended })
+
+  return createBaseEventStore({
+    aggregateRoots,
+    postProcessEvent,
+    onProjectionReplay,
+    onProcessManagerRefresh,
+    autoInit,
+    lock,
+    ...storage,
   }) as any
 }

package/src/redis/redisLock.ts

@@ -1,6 +1,6 @@
 import type { Redis } from 'ioredis'
 
-import type { LockCreator } from '../lock.ts'
+import { DEFAULT_LOCK_TTL, type LockCreator } from '../lock.ts'
 
 const extendScript = `
   if redis.call("get", KEYS[1]) == ARGV[1] then
@@ -18,7 +18,10 @@ const deleteScript = `
     end
 `
 
-export function redisLock(client: Redis, defaultTtl = 5000): LockCreator {
+export function redisLock(
+  client: Redis,
+  defaultTtl = DEFAULT_LOCK_TTL,
+): LockCreator {
   return async (rawKey) => {
     const key = Array.isArray(rawKey) ? rawKey.join(':') : rawKey
     const token = crypto.randomUUID()
@@ -33,6 +36,7 @@ export function redisLock(client: Redis, defaultTtl = 5000): LockCreator {
 
       let isReleased = false
       return {
+        ttl: defaultTtl,
         async extend(ttl) {
           const extended = await client.eval(
             extendScript,

package/src/surreal/index.spec.ts

@@ -0,0 +1,152 @@
+import { afterAll, describe, expect, it } from 'bun:test'
+import { createNodeEngines } from '@surrealdb/node'
+import { Surreal } from 'surrealdb'
+
+import { ConcurrencyError } from '../errors.ts'
+import { runStorageDriverContract } from '../tests/storageDriverContract.ts'
+import { createSurrealStorage, initSchema } from './index.ts'
+
+// One shared embedded engine for the whole file; isolation comes from a
+// fresh logical database per test (tests run sequentially).
+let connection: Surreal | undefined
+
+async function makeDatabase() {
+  if (!connection) {
+    connection = new Surreal({ engines: { ...createNodeEngines() } })
+    await connection.connect('mem://')
+  }
+  await connection.use({ namespace: 'test', database: crypto.randomUUID() })
+  return connection
+}
+
+afterAll(async () => {
+  await connection?.close()
+})
+
+runStorageDriverContract('surreal', async () => {
+  const database = await makeDatabase()
+  return createSurrealStorage({ database })
+})
+
+describe('surreal driver specifics', () => {
+  it('initializes the schema idempotently', async () => {
+    const database = await makeDatabase()
+    await initSchema(database)
+    await initSchema(database)
+
+    const storage = createSurrealStorage({ database })
+    const persisted = await storage.appendEvents(
+      { stream: 'order', id: 'o1' },
+      [{ type: 'created', payload: {}, metadata: {}, schemaVersion: 1 }],
+      0,
+    )
+    expect(persisted[0].position).toBe(1)
+  })
+
+  it('skips schema creation when initSchema is disabled', async () => {
+    const database = await makeDatabase()
+    const storage = createSurrealStorage({ database, initSchema: false })
+
+    let error: unknown
+    try {
+      await storage.appendEvents(
+        { stream: 'order', id: 'o1' },
+        [{ type: 'created', payload: {}, metadata: {}, schemaVersion: 1 }],
+        0,
+      )
+    } catch (err) {
+      error = err
+    }
+    // Without the SCHEMAFULL tables the counter arithmetic cannot resolve.
+    expect(error).toBeTruthy()
+  })
+
+  it('assigns gapless, monotonically increasing global positions', async () => {
+    const database = await makeDatabase()
+    const storage = createSurrealStorage({ database })
+
+    await storage.appendEvents(
+      { stream: 'order', id: 'o1' },
+      [
+        { type: 'created', payload: {}, metadata: {}, schemaVersion: 1 },
+        { type: 'updated', payload: {}, metadata: {}, schemaVersion: 1 },
+      ],
+      0,
+    )
+    const second = await storage.appendEvents(
+      { stream: 'order', id: 'o2' },
+      [{ type: 'created', payload: {}, metadata: {}, schemaVersion: 1 }],
+      0,
+    )
+
+    expect(second[0].position).toBe(3)
+  })
+
+  it('serializes concurrent appends to different streams without losing positions', async () => {
+    const database = await makeDatabase()
+    const storage = createSurrealStorage({ database })
+
+    const results = await Promise.all(
+      Array.from({ length: 8 }, (_, index) =>
+        storage.appendEvents(
+          { stream: 'order', id: `o${index}` },
+          [{ type: 'created', payload: {}, metadata: {}, schemaVersion: 1 }],
+          0,
+        ),
+      ),
+    )
+
+    const positions = results
+      .map(([event]) => event.position)
+      .toSorted((a, b) => a - b)
+    expect(positions).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
+  })
+
+  it('reports the current version in ConcurrencyError', async () => {
+    const database = await makeDatabase()
+    const storage = createSurrealStorage({ database })
+
+    await storage.appendEvents(
+      { stream: 'order', id: 'o1' },
+      [
+        { type: 'created', payload: {}, metadata: {}, schemaVersion: 1 },
+        { type: 'updated', payload: {}, metadata: {}, schemaVersion: 1 },
+      ],
+      0,
+    )
+
+    let error: unknown
+    try {
+      await storage.appendEvents(
+        { stream: 'order', id: 'o1' },
+        [{ type: 'updated', payload: {}, metadata: {}, schemaVersion: 1 }],
+        1,
+      )
+    } catch (err) {
+      error = err
+    }
+
+    expect(error).toBeInstanceOf(ConcurrencyError)
+    expect((error as Error).message).toContain('expected v1, actual v2')
+  })
+
+  it('notifies onEventsAppended with the persisted events', async () => {
+    const database = await makeDatabase()
+    let appended: unknown[] = []
+    const storage = createSurrealStorage({
+      database,
+      onEventsAppended: (events) => {
+        appended = events
+      },
+    })
+
+    await storage.appendEvents(
+      { stream: 'order', id: 'o1' },
+      [{ type: 'created', payload: { n: 1 }, metadata: {}, schemaVersion: 1 }],
+      0,
+    )
+
+    expect(appended).toHaveLength(1)
+    expect((appended[0] as any).position).toBe(1)
+  })
+})