@requence/event-sourcing 1.4.1 → 1.5.0

package/dist/surreal/index.js

@@ -0,0 +1,415 @@
+import {
+  SCHEMA_STATEMENTS,
+  TABLES,
+  initSchema
+} from "../chunk-ak901ckt.js";
+import {
+  isStreamEvents,
+  isStreamId
+} from "../chunk-jd4q8fcf.js";
+import {
+  createAggregateRoot
+} from "../chunk-7akf01zj.js";
+import {
+  createEventStore
+} from "../chunk-8edc30gz.js";
+import"../chunk-ty9bhdvx.js";
+import"../chunk-z388cd25.js";
+import"../chunk-24xjphpk.js";
+import"../chunk-tfy01fah.js";
+import"../chunk-zznvzvnv.js";
+import"../chunk-8qn1nqnh.js";
+import"../chunk-kqh3q3fj.js";
+import"../chunk-6yrb30rx.js";
+import {
+  extendTypes,
+  superjson
+} from "../chunk-6q8mr1sg.js";
+import"../chunk-2fe8jjdc.js";
+import"../chunk-3251p253.js";
+import"../chunk-pc1q4se9.js";
+import {
+  ConcurrencyError
+} from "../chunk-391m4mfp.js";
+
+// src/surreal/index.ts
+import { RecordId } from "surrealdb";
+var CONFLICT_RETRIES = 10;
+var CONCURRENCY_MARKER = "es_concurrency:";
+var CHECKPOINT_CONFLICT_MARKER = "es_checkpoint_conflict";
+function isThrownError(error) {
+  return typeof error === "object" && error !== null && error.kind === "Thrown";
+}
+function isAlreadyExistsError(error) {
+  return typeof error === "object" && error !== null && error.kind === "AlreadyExists";
+}
+function isUniqueIndexViolation(error) {
+  return error instanceof Error && /index .* already contains/i.test(error.message);
+}
+function isTransactionConflict(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const serverError = error;
+  if (serverError.isTransactionConflict) {
+    return true;
+  }
+  return /read or write conflict|transaction can be retried/i.test(serverError.message ?? "");
+}
+function primaryError(errors) {
+  return errors.find((error) => !/was not executed/i.test(error.message)) ?? errors[0];
+}
+function toDate(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  const dateTime = value;
+  if (typeof dateTime?.toDate === "function") {
+    return dateTime.toDate();
+  }
+  return new Date(String(value));
+}
+function toOutputEvent(row) {
+  const { id: _id, ...event } = row;
+  return {
+    ...event,
+    position: Number(event.position),
+    streamVersion: Number(event.streamVersion),
+    createdAt: toDate(event.createdAt),
+    payload: superjson.parse(event.payload),
+    metadata: superjson.deserialize(event.metadata)
+  };
+}
+function conflictBackoff(attempt) {
+  const ms = Math.min(200, 5 * 2 ** attempt) * (0.5 + Math.random());
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var APPEND_QUERY = `
+BEGIN;
+LET $head = array::max(SELECT VALUE streamVersion FROM ${TABLES.events} WHERE streamId = $streamId AND streamType = $streamType) ?? 0;
+IF $head != $expectedVersion { THROW "${CONCURRENCY_MARKER}" + <string>$head; };
+LET $next = (UPSERT ONLY ${TABLES.counters}:${TABLES.events} SET value += $count RETURN VALUE value);
+LET $base = $next - $count;
+INSERT INTO ${TABLES.events} $events.map(|$event, $index| $event + { position: $base + $index + 1 });
+COMMIT;
+`;
+var CHECKPOINT_UPSERT_QUERY = `
+BEGIN;
+LET $current = (SELECT VALUE version FROM ONLY $rid);
+IF $current = NONE {
+  CREATE $rid CONTENT $content;
+} ELSE IF $insertOnly = false AND $current = $expectedVersion {
+  UPDATE $rid MERGE $changes;
+} ELSE {
+  THROW "${CHECKPOINT_CONFLICT_MARKER}";
+};
+COMMIT;
+`;
+function createSurrealStorage(params) {
+  const db = () => typeof params.database === "function" ? params.database() : params.database;
+  let schemaReady;
+  const ready = () => {
+    if (params.initSchema === false) {
+      return Promise.resolve();
+    }
+    schemaReady ??= initSchema(db());
+    return schemaReady;
+  };
+  async function runWithResponses(query, bindings) {
+    try {
+      const responses = await db().query(query, bindings).responses();
+      const errors = responses.filter((response) => !response.success).map((response) => response.error);
+      return { responses, errors };
+    } catch (error) {
+      if (isTransactionConflict(error)) {
+        return { responses: [], errors: [error] };
+      }
+      throw error;
+    }
+  }
+  return {
+    async* loadEvents(select, range) {
+      await ready();
+      const conditions = ["position > $lastPosition"];
+      const bindings = {};
+      if (select) {
+        const selects = Array.isArray(select) ? select : [select];
+        const streamTypes = selects.map((select2) => select2.stream);
+        const streamIds = selects.map((select2) => isStreamId(select2) ? select2.id : null).filter(Boolean);
+        const eventTypes = selects.flatMap((select2) => isStreamEvents(select2) ? select2.events : []);
+        conditions.push("streamType IN $streamTypes");
+        bindings.streamTypes = streamTypes;
+        if (streamIds.length > 0) {
+          conditions.push("streamId IN $streamIds");
+          bindings.streamIds = streamIds;
+        }
+        if (eventTypes.length > 0) {
+          conditions.push("type IN $eventTypes");
+          bindings.eventTypes = eventTypes;
+        }
+      }
+      let lastPosition = 0;
+      if (range?.from) {
+        lastPosition = range.from - 1;
+      }
+      const chunkSize = 50;
+      const query = `SELECT * FROM ${TABLES.events} WHERE ${conditions.join(" AND ")} ORDER BY position ASC LIMIT ${chunkSize};`;
+      while (true) {
+        const [resolvedEvents] = await db().query(query, { ...bindings, lastPosition }).collect();
+        if (resolvedEvents.length === 0) {
+          break;
+        }
+        for (const resolvedEvent of resolvedEvents) {
+          const position = Number(resolvedEvent.position);
+          if (range?.to && position > range.to) {
+            return;
+          }
+          yield toOutputEvent(resolvedEvent);
+          lastPosition = position;
+        }
+      }
+    },
+    async appendEvents(streamId, newEvents, expectedVersion) {
+      await ready();
+      const mappedEvents = newEvents.map((event, index) => ({
+        streamId: streamId.id,
+        streamType: streamId.stream,
+        streamVersion: expectedVersion + 1 + index,
+        type: event.type,
+        payload: superjson.stringify(event.payload),
+        metadata: superjson.serialize(event.metadata),
+        causationId: event.causationId ?? undefined,
+        actorId: event.actorId ?? undefined,
+        correlationId: event.correlationId ?? undefined,
+        schemaVersion: event.schemaVersion
+      }));
+      for (let attempt = 0;; attempt++) {
+        const { responses, errors } = await runWithResponses(APPEND_QUERY, {
+          streamId: streamId.id,
+          streamType: streamId.stream,
+          expectedVersion,
+          count: mappedEvents.length,
+          events: mappedEvents
+        });
+        if (errors.length === 0) {
+          const persistedEvents = responses.map((response) => response.success ? response.result : undefined).find(Array.isArray);
+          const resolvedEvents = persistedEvents.map(toOutputEvent).toSorted((eventA, eventB) => eventA.position - eventB.position);
+          params.onEventsAppended?.(resolvedEvents);
+          return resolvedEvents;
+        }
+        const concurrency = errors.find((error) => isThrownError(error) && error.message.includes(CONCURRENCY_MARKER));
+        if (concurrency) {
+          const currentVersion = Number(new RegExp(`${CONCURRENCY_MARKER}(\\d+)`).exec(concurrency.message)[1]);
+          throw new ConcurrencyError(streamId, expectedVersion, currentVersion);
+        }
+        if (errors.some(isUniqueIndexViolation)) {
+          const [version] = await db().query(`RETURN array::max(SELECT VALUE streamVersion FROM ${TABLES.events} WHERE streamId = $streamId AND streamType = $streamType) ?? 0;`, { streamId: streamId.id, streamType: streamId.stream }).collect();
+          const currentVersion = Number(version ?? 0);
+          throw new ConcurrencyError(streamId, expectedVersion, currentVersion);
+        }
+        if (errors.some(isTransactionConflict) && attempt < CONFLICT_RETRIES) {
+          await conflictBackoff(attempt);
+          continue;
+        }
+        throw primaryError(errors);
+      }
+    },
+    checkpoint: {
+      async upsert(checkpoint, expectedVersion) {
+        await ready();
+        const rid = new RecordId(TABLES.checkpoints, [
+          checkpoint.type,
+          checkpoint.name
+        ]);
+        const metadata = superjson.stringify(checkpoint.metadata);
+        const changes = {
+          lastEventPosition: checkpoint.lastEventPosition,
+          metadata,
+          version: checkpoint.version
+        };
+        for (let attempt = 0;; attempt++) {
+          const { errors } = await runWithResponses(CHECKPOINT_UPSERT_QUERY, {
+            rid,
+            content: {
+              type: checkpoint.type,
+              name: checkpoint.name,
+              ...changes
+            },
+            changes,
+            insertOnly: expectedVersion === null,
+            expectedVersion: expectedVersion ?? 0
+          });
+          if (errors.length === 0) {
+            return true;
+          }
+          if (errors.some((error) => isAlreadyExistsError(error) || isThrownError(error) && error.message.includes(CHECKPOINT_CONFLICT_MARKER))) {
+            return false;
+          }
+          if (errors.some(isTransactionConflict) && attempt < CONFLICT_RETRIES) {
+            await conflictBackoff(attempt);
+            continue;
+          }
+          throw primaryError(errors);
+        }
+      },
+      async get(type, name) {
+        await ready();
+        const rid = new RecordId(TABLES.checkpoints, [type, name]);
+        const [checkpoint] = await db().query(`SELECT * OMIT id FROM ONLY $rid;`, { rid }).collect();
+        if (!checkpoint) {
+          return null;
+        }
+        return {
+          type: checkpoint.type,
+          name: checkpoint.name,
+          lastEventPosition: Number(checkpoint.lastEventPosition),
+          version: Number(checkpoint.version),
+          metadata: superjson.parse(checkpoint.metadata)
+        };
+      },
+      async delete(type, name) {
+        await ready();
+        const rid = new RecordId(TABLES.checkpoints, [type, name]);
+        await db().query(`DELETE $rid;`, { rid }).collect();
+      }
+    },
+    projectionSnapshot: {
+      async put(snapshot) {
+        await ready();
+        await db().query(`CREATE ${TABLES.projectionSnapshots} CONTENT $content;`, {
+          content: {
+            projectionId: snapshot.projectionId,
+            projectionType: snapshot.projectionType,
+            lastEventPosition: snapshot.lastEventPosition,
+            schemaVersion: snapshot.schemaVersion,
+            state: superjson.stringify(snapshot.state),
+            metadata: superjson.stringify(snapshot.metadata)
+          }
+        }).collect();
+      },
+      async get(select) {
+        await ready();
+        const [[snapshot]] = await db().query(`SELECT * OMIT id FROM ${TABLES.projectionSnapshots} WHERE projectionId = $id AND projectionType = $projection ORDER BY lastEventPosition DESC LIMIT 1;`, { id: select.id, projection: select.projection }).collect();
+        if (!snapshot) {
+          return null;
+        }
+        return {
+          ...snapshot,
+          lastEventPosition: Number(snapshot.lastEventPosition),
+          schemaVersion: Number(snapshot.schemaVersion),
+          createdAt: toDate(snapshot.createdAt),
+          state: superjson.parse(snapshot.state),
+          metadata: superjson.parse(snapshot.metadata)
+        };
+      },
+      async delete(target, fromPosition) {
+        await ready();
+        const conditions = ["projectionType = $projection"];
+        const bindings = {
+          projection: target.projection
+        };
+        if (target.id) {
+          conditions.push("projectionId = $id");
+          bindings.id = target.id;
+        }
+        if (fromPosition) {
+          conditions.push("lastEventPosition > $fromPosition");
+          bindings.fromPosition = fromPosition;
+        }
+        await db().query(`DELETE ${TABLES.projectionSnapshots} WHERE ${conditions.join(" AND ")};`, bindings).collect();
+      },
+      async incrementAppliedCount(select) {
+        await ready();
+        for (let attempt = 0;; attempt++) {
+          try {
+            const [appliedEvents] = await db().query(`UPSERT ONLY ${TABLES.projectionAppliedEvents}:[$projection, $id] SET appliedEvents += 1 RETURN VALUE appliedEvents;`, { projection: select.projection, id: select.id }).collect();
+            return Number(appliedEvents);
+          } catch (error) {
+            if (isTransactionConflict(error) && attempt < CONFLICT_RETRIES) {
+              await conflictBackoff(attempt);
+              continue;
+            }
+            throw error;
+          }
+        }
+      }
+    },
+    aggregateRootSnapshot: {
+      async put(snapshot) {
+        await ready();
+        await db().query(`CREATE ${TABLES.aggregateRootSnapshots} CONTENT $content;`, {
+          content: {
+            streamId: snapshot.streamId,
+            streamType: snapshot.streamType,
+            streamVersion: snapshot.streamVersion,
+            lastEventPosition: snapshot.lastEventPosition,
+            schemaVersion: snapshot.schemaVersion,
+            state: superjson.stringify(snapshot.state),
+            metadata: superjson.stringify(snapshot.metadata)
+          }
+        }).collect();
+      },
+      async get(select) {
+        await ready();
+        const [[snapshot]] = await db().query(`SELECT * OMIT id FROM ${TABLES.aggregateRootSnapshots} WHERE streamId = $id AND streamType = $stream ORDER BY streamVersion DESC LIMIT 1;`, { id: select.id, stream: select.stream }).collect();
+        if (!snapshot) {
+          return null;
+        }
+        return {
+          ...snapshot,
+          streamVersion: Number(snapshot.streamVersion),
+          lastEventPosition: Number(snapshot.lastEventPosition),
+          schemaVersion: Number(snapshot.schemaVersion),
+          createdAt: toDate(snapshot.createdAt),
+          state: superjson.parse(snapshot.state),
+          metadata: superjson.parse(snapshot.metadata)
+        };
+      },
+      async delete(target, fromStreamVersion) {
+        await ready();
+        await db().query(`DELETE ${TABLES.aggregateRootSnapshots} WHERE streamId = $id AND streamType = $stream AND streamVersion > $fromStreamVersion;`, {
+          id: target.id,
+          stream: target.stream,
+          fromStreamVersion
+        }).collect();
+      }
+    }
+  };
+}
+function createEventStore2({
+  database,
+  aggregateRoots,
+  postProcessEvent,
+  onProjectionReplay,
+  onProcessManagerRefresh,
+  onEventsAppended,
+  autoInit,
+  initSchema: initSchema2,
+  lock
+}) {
+  const storage = createSurrealStorage({
+    database,
+    initSchema: initSchema2,
+    onEventsAppended
+  });
+  return createEventStore({
+    aggregateRoots,
+    postProcessEvent,
+    onProjectionReplay,
+    onProcessManagerRefresh,
+    autoInit,
+    lock,
+    ...storage
+  });
+}
+export {
+  initSchema,
+  extendTypes,
+  createSurrealStorage,
+  createEventStore2 as createEventStore,
+  createAggregateRoot,
+  TABLES,
+  SCHEMA_STATEMENTS
+};
+
+//# debugId=F7D6DA35C7597AFE64756E2164756E21

package/dist/surreal/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/surreal/index.ts"],
+  "sourcesContent": [
+    "import { RecordId, type Surreal } from 'surrealdb'\n\nimport type {\n  AggregateRootSnapshotMethods,\n  AnyAggregateRoot,\n} from '../createAggregateRoot.ts'\nimport type { CheckpointMethods } from '../createCheckpointApi.ts'\nimport type { ProjectionSnapshotMethods } from '../createProjection.ts'\nimport {\n  ConcurrencyError,\n  createEventStore as createBaseEventStore,\n  isStreamEvents,\n  isStreamId,\n} from '../index.ts'\nimport type {\n  EventStore,\n  EventStoreParamsWithAggregateRootSnapshots,\n  EventsFromRoot,\n  LoadEvents,\n  OnProgress,\n} from '../createEventStore.ts'\nimport type { LockCreator } from '../lock.ts'\nimport { superjson } from '../superjson.ts'\nimport { TABLES, initSchema as runInitSchema } from './schema.ts'\nimport type {\n  BaseInputEvent,\n  BaseOutputEvent,\n  MaybePromise,\n  StreamId,\n} from '../utilityTypes.js'\n\nexport { createAggregateRoot } from '../index.ts'\nexport { extendTypes } from '../superjson.ts'\nexport { SCHEMA_STATEMENTS, TABLES, initSchema } from './schema.ts'\n\nexport type OnEventsAppended = (events: BaseOutputEvent[]) => MaybePromise<void>\n\ninterface SurrealEventStoreParams<Root extends AnyAggregateRoot> {\n  database: Surreal | (() => Surreal)\n  aggregateRoots: Root[]\n  autoInit?: boolean\n  initSchema?: boolean\n  lock?: LockCreator\n  postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent']\n  onProjectionReplay?: OnProgress\n  onProcessManagerRefresh?: OnProgress\n  onEventsAppended?: OnEventsAppended\n}\n\nconst CONFLICT_RETRIES = 10\nconst CONCURRENCY_MARKER = 'es_concurrency:'\nconst CHECKPOINT_CONFLICT_MARKER = 'es_checkpoint_conflict'\n\ntype QueryResponse =\n  | { success: true; result: unknown }\n  | { success: false; error: Error & { kind?: string } }\n\ntype ServerErrorLike = Error & {\n  kind?: string\n  isTransactionConflict?: boolean\n}\n\nfunction isThrownError(error: unknown): boolean {\n  return (\n    typeof error === 'object' &&\n    error !== null &&\n    (error as ServerErrorLike).kind === 'Thrown'\n  )\n}\n\nfunction isAlreadyExistsError(error: unknown): boolean {\n  return (\n    typeof error === 'object' &&\n    error !== null &&\n    (error as ServerErrorLike).kind === 'AlreadyExists'\n  )\n}\n\nfunction isUniqueIndexViolation(error: unknown): boolean {\n  return (\n    error instanceof Error && /index .* already contains/i.test(error.message)\n  )\n}\n\n// Snapshot-isolation conflicts are safe to retry. SurrealDB >= 3.1 reports\n// them with a structured `TransactionConflict` detail; older servers only\n// expose the human-readable message.\nfunction isTransactionConflict(error: unknown): error is ServerErrorLike {\n  if (typeof error !== 'object' || error === null) {\n    return false\n  }\n  const serverError = error as ServerErrorLike\n  if (serverError.isTransactionConflict) {\n    return true\n  }\n  return /read or write conflict|transaction can be retried/i.test(\n    serverError.message ?? '',\n  )\n}\n\n// Statements after a failed one only report generic \"not executed\" errors —\n// surface the statement error that actually caused the transaction to fail.\nfunction primaryError(errors: ServerErrorLike[]): ServerErrorLike {\n  return (\n    errors.find((error) => !/was not executed/i.test(error.message)) ??\n    errors[0]\n  )\n}\n\nfunction toDate(value: unknown): Date {\n  if (value instanceof Date) {\n    return value\n  }\n  const dateTime = value as { toDate?: () => Date }\n  if (typeof dateTime?.toDate === 'function') {\n    return dateTime.toDate()\n  }\n  return new Date(String(value))\n}\n\nfunction toOutputEvent(row: any): BaseOutputEvent {\n  const { id: _id, ...event } = row\n  return {\n    ...event,\n    position: Number(event.position),\n    streamVersion: Number(event.streamVersion),\n    createdAt: toDate(event.createdAt),\n    payload: superjson.parse(event.payload),\n    metadata: superjson.deserialize(event.metadata),\n  }\n}\n\n// Jittered exponential backoff so concurrent writers racing on the position\n// counter do not retry in lockstep.\nfunction conflictBackoff(attempt: number) {\n  const ms = Math.min(200, 5 * 2 ** attempt) * (0.5 + Math.random())\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\n// The head version is computed with array::max instead of\n// ORDER BY ... DESC LIMIT 1: inside a transaction the index scan serves that\n// query in ascending order with the limit pushed down, returning the lowest\n// version instead of the highest.\nconst APPEND_QUERY = `\nBEGIN;\nLET $head = array::max(SELECT VALUE streamVersion FROM ${TABLES.events} WHERE streamId = $streamId AND streamType = $streamType) ?? 0;\nIF $head != $expectedVersion { THROW \"${CONCURRENCY_MARKER}\" + <string>$head; };\nLET $next = (UPSERT ONLY ${TABLES.counters}:${TABLES.events} SET value += $count RETURN VALUE value);\nLET $base = $next - $count;\nINSERT INTO ${TABLES.events} $events.map(|$event, $index| $event + { position: $base + $index + 1 });\nCOMMIT;\n`\n\nconst CHECKPOINT_UPSERT_QUERY = `\nBEGIN;\nLET $current = (SELECT VALUE version FROM ONLY $rid);\nIF $current = NONE {\n  CREATE $rid CONTENT $content;\n} ELSE IF $insertOnly = false AND $current = $expectedVersion {\n  UPDATE $rid MERGE $changes;\n} ELSE {\n  THROW \"${CHECKPOINT_CONFLICT_MARKER}\";\n};\nCOMMIT;\n`\n\nexport function createSurrealStorage(params: {\n  database: Surreal | (() => Surreal)\n  initSchema?: boolean\n  onEventsAppended?: OnEventsAppended\n}): {\n  loadEvents: LoadEvents\n  appendEvents: (\n    streamId: StreamId,\n    events: BaseInputEvent[],\n    expectedVersion: number,\n  ) => Promise<BaseOutputEvent[]>\n  checkpoint: CheckpointMethods\n  projectionSnapshot: ProjectionSnapshotMethods\n  aggregateRootSnapshot: AggregateRootSnapshotMethods\n} {\n  const db = () =>\n    typeof params.database === 'function' ? params.database() : params.database\n\n  let schemaReady: Promise<void> | undefined\n  const ready = () => {\n    if (params.initSchema === false) {\n      return Promise.resolve()\n    }\n    schemaReady ??= runInitSchema(db())\n    return schemaReady\n  }\n\n  // Statement failures come back as per-statement error responses, but\n  // transaction conflicts reject the query promise itself — normalize both\n  // into the errors array so the retry loops handle them uniformly.\n  async function runWithResponses(\n    query: string,\n    bindings: Record<string, unknown>,\n  ): Promise<{ responses: QueryResponse[]; errors: ServerErrorLike[] }> {\n    try {\n      const responses = (await db()\n        .query(query, bindings)\n        .responses()) as QueryResponse[]\n      const errors = responses\n        .filter((response) => !response.success)\n        .map((response) => (response as { error: ServerErrorLike }).error)\n      return { responses, errors }\n    } catch (error) {\n      if (isTransactionConflict(error)) {\n        return { responses: [], errors: [error] }\n      }\n      throw error\n    }\n  }\n\n  return {\n    async *loadEvents(select, range) {\n      await ready()\n      const conditions = ['position > $lastPosition']\n      const bindings: Record<string, unknown> = {}\n\n      if (select) {\n        const selects = Array.isArray(select) ? select : [select]\n        const streamTypes = selects.map((select) => select.stream)\n        const streamIds = selects\n          .map((select) => (isStreamId(select) ? select.id : null))\n          .filter(Boolean) as string[]\n        const eventTypes = selects.flatMap((select) =>\n          isStreamEvents(select) ? select.events : [],\n        )\n        conditions.push('streamType IN $streamTypes')\n        bindings.streamTypes = streamTypes\n\n        if (streamIds.length > 0) {\n          conditions.push('streamId IN $streamIds')\n          bindings.streamIds = streamIds\n        }\n\n        if (eventTypes.length > 0) {\n          conditions.push('type IN $eventTypes')\n          bindings.eventTypes = eventTypes\n        }\n      }\n      let lastPosition = 0\n\n      if (range?.from) {\n        lastPosition = range.from - 1\n      }\n\n      // range.to is applied client-side: combining both bounds on the\n      // uniquely indexed position field trips a SurrealDB 3.0 planner bug\n      // where the exclusive lower bound is ignored.\n      const chunkSize = 50\n      const query = `SELECT * FROM ${TABLES.events} WHERE ${conditions.join(' AND ')} ORDER BY position ASC LIMIT ${chunkSize};`\n\n      while (true) {\n        const [resolvedEvents] = (await db()\n          .query(query, { ...bindings, lastPosition })\n          .collect()) as [any[]]\n\n        if (resolvedEvents.length === 0) {\n          break\n        }\n\n        for (const resolvedEvent of resolvedEvents) {\n          const position = Number(resolvedEvent.position)\n          if (range?.to && position > range.to) {\n            return\n          }\n          yield toOutputEvent(resolvedEvent)\n          lastPosition = position\n        }\n      }\n    },\n\n    async appendEvents(streamId, newEvents, expectedVersion) {\n      await ready()\n      const mappedEvents = newEvents.map((event, index) => ({\n        streamId: streamId.id,\n        streamType: streamId.stream,\n        streamVersion: expectedVersion + 1 + index,\n        type: event.type,\n        payload: superjson.stringify(event.payload),\n        metadata: superjson.serialize(event.metadata),\n        causationId: event.causationId ?? undefined,\n        actorId: event.actorId ?? undefined,\n        correlationId: event.correlationId ?? undefined,\n        schemaVersion: event.schemaVersion,\n      }))\n\n      for (let attempt = 0; ; attempt++) {\n        const { responses, errors } = await runWithResponses(APPEND_QUERY, {\n          streamId: streamId.id,\n          streamType: streamId.stream,\n          expectedVersion,\n          count: mappedEvents.length,\n          events: mappedEvents,\n        })\n\n        if (errors.length === 0) {\n          const persistedEvents = responses\n            .map((response) => (response.success ? response.result : undefined))\n            .find(Array.isArray) as any[]\n\n          const resolvedEvents = persistedEvents\n            .map(toOutputEvent)\n            .toSorted((eventA, eventB) => eventA.position - eventB.position)\n\n          params.onEventsAppended?.(resolvedEvents)\n\n          return resolvedEvents\n        }\n\n        const concurrency = errors.find(\n          (error) =>\n            isThrownError(error) && error.message.includes(CONCURRENCY_MARKER),\n        )\n        if (concurrency) {\n          const currentVersion = Number(\n            new RegExp(`${CONCURRENCY_MARKER}(\\\\d+)`).exec(\n              concurrency.message,\n            )![1],\n          )\n          throw new ConcurrencyError(streamId, expectedVersion, currentVersion)\n        }\n\n        if (errors.some(isUniqueIndexViolation)) {\n          const [version] = (await db()\n            .query(\n              `RETURN array::max(SELECT VALUE streamVersion FROM ${TABLES.events} WHERE streamId = $streamId AND streamType = $streamType) ?? 0;`,\n              { streamId: streamId.id, streamType: streamId.stream },\n            )\n            .collect()) as [number]\n\n          const currentVersion = Number(version ?? 0)\n          throw new ConcurrencyError(streamId, expectedVersion, currentVersion)\n        }\n\n        if (errors.some(isTransactionConflict) && attempt < CONFLICT_RETRIES) {\n          await conflictBackoff(attempt)\n          continue\n        }\n\n        throw primaryError(errors)\n      }\n    },\n\n    checkpoint: {\n      async upsert(checkpoint, expectedVersion) {\n        await ready()\n        const rid = new RecordId(TABLES.checkpoints, [\n          checkpoint.type,\n          checkpoint.name,\n        ])\n        const metadata = superjson.stringify(checkpoint.metadata)\n        const changes = {\n          lastEventPosition: checkpoint.lastEventPosition,\n          metadata,\n          version: checkpoint.version,\n        }\n\n        // Compare-and-swap: create when no checkpoint exists, otherwise only\n        // apply when the stored version still matches `expectedVersion`. A\n        // `null` expectation means \"insert only\" — an existing record is a\n        // conflict.\n        for (let attempt = 0; ; attempt++) {\n          const { errors } = await runWithResponses(CHECKPOINT_UPSERT_QUERY, {\n            rid,\n            content: {\n              type: checkpoint.type,\n              name: checkpoint.name,\n              ...changes,\n            },\n            changes,\n            insertOnly: expectedVersion === null,\n            expectedVersion: expectedVersion ?? 0,\n          })\n\n          if (errors.length === 0) {\n            return true\n          }\n\n          if (\n            errors.some(\n              (error) =>\n                isAlreadyExistsError(error) ||\n                (isThrownError(error) &&\n                  error.message.includes(CHECKPOINT_CONFLICT_MARKER)),\n            )\n          ) {\n            return false\n          }\n\n          if (\n            errors.some(isTransactionConflict) &&\n            attempt < CONFLICT_RETRIES\n          ) {\n            await conflictBackoff(attempt)\n            continue\n          }\n\n          throw primaryError(errors)\n        }\n      },\n      async get(type, name) {\n        await ready()\n        const rid = new RecordId(TABLES.checkpoints, [type, name])\n        const [checkpoint] = (await db()\n          .query(`SELECT * OMIT id FROM ONLY $rid;`, { rid })\n          .collect()) as [any]\n\n        if (!checkpoint) {\n          return null\n        }\n\n        return {\n          type: checkpoint.type,\n          name: checkpoint.name,\n          lastEventPosition: Number(checkpoint.lastEventPosition),\n          version: Number(checkpoint.version),\n          metadata: superjson.parse(checkpoint.metadata),\n        }\n      },\n      async delete(type, name) {\n        await ready()\n        const rid = new RecordId(TABLES.checkpoints, [type, name])\n        await db().query(`DELETE $rid;`, { rid }).collect()\n      },\n    },\n\n    projectionSnapshot: {\n      async put(snapshot) {\n        await ready()\n        await db()\n          .query(`CREATE ${TABLES.projectionSnapshots} CONTENT $content;`, {\n            content: {\n              projectionId: snapshot.projectionId,\n              projectionType: snapshot.projectionType,\n              lastEventPosition: snapshot.lastEventPosition,\n              schemaVersion: snapshot.schemaVersion,\n              state: superjson.stringify(snapshot.state),\n              metadata: superjson.stringify(snapshot.metadata),\n            },\n          })\n          .collect()\n      },\n      async get(select) {\n        await ready()\n        const [[snapshot]] = (await db()\n          .query(\n            `SELECT * OMIT id FROM ${TABLES.projectionSnapshots} WHERE projectionId = $id AND projectionType = $projection ORDER BY lastEventPosition DESC LIMIT 1;`,\n            { id: select.id, projection: select.projection },\n          )\n          .collect()) as [any[]]\n\n        if (!snapshot) {\n          return null\n        }\n\n        return {\n          ...snapshot,\n          lastEventPosition: Number(snapshot.lastEventPosition),\n          schemaVersion: Number(snapshot.schemaVersion),\n          createdAt: toDate(snapshot.createdAt),\n          state: superjson.parse(snapshot.state),\n          metadata: superjson.parse(snapshot.metadata),\n        }\n      },\n      async delete(target, fromPosition) {\n        await ready()\n        const conditions = ['projectionType = $projection']\n        const bindings: Record<string, unknown> = {\n          projection: target.projection,\n        }\n\n        if (target.id) {\n          conditions.push('projectionId = $id')\n          bindings.id = target.id\n        }\n\n        if (fromPosition) {\n          conditions.push('lastEventPosition > $fromPosition')\n          bindings.fromPosition = fromPosition\n        }\n\n        await db()\n          .query(\n            `DELETE ${TABLES.projectionSnapshots} WHERE ${conditions.join(' AND ')};`,\n            bindings,\n          )\n          .collect()\n      },\n      async incrementAppliedCount(select) {\n        await ready()\n        for (let attempt = 0; ; attempt++) {\n          try {\n            const [appliedEvents] = (await db()\n              .query(\n                `UPSERT ONLY ${TABLES.projectionAppliedEvents}:[$projection, $id] SET appliedEvents += 1 RETURN VALUE appliedEvents;`,\n                { projection: select.projection, id: select.id },\n              )\n              .collect()) as [number]\n\n            return Number(appliedEvents)\n          } catch (error) {\n            if (isTransactionConflict(error) && attempt < CONFLICT_RETRIES) {\n              await conflictBackoff(attempt)\n              continue\n            }\n            throw error\n          }\n        }\n      },\n    },\n\n    aggregateRootSnapshot: {\n      async put(snapshot) {\n        await ready()\n        await db()\n          .query(`CREATE ${TABLES.aggregateRootSnapshots} CONTENT $content;`, {\n            content: {\n              streamId: snapshot.streamId,\n              streamType: snapshot.streamType,\n              streamVersion: snapshot.streamVersion,\n              lastEventPosition: snapshot.lastEventPosition,\n              schemaVersion: snapshot.schemaVersion,\n              state: superjson.stringify(snapshot.state),\n              metadata: superjson.stringify(snapshot.metadata),\n            },\n          })\n          .collect()\n      },\n      async get(select) {\n        await ready()\n        const [[snapshot]] = (await db()\n          .query(\n            `SELECT * OMIT id FROM ${TABLES.aggregateRootSnapshots} WHERE streamId = $id AND streamType = $stream ORDER BY streamVersion DESC LIMIT 1;`,\n            { id: select.id, stream: select.stream },\n          )\n          .collect()) as [any[]]\n\n        if (!snapshot) {\n          return null\n        }\n\n        return {\n          ...snapshot,\n          streamVersion: Number(snapshot.streamVersion),\n          lastEventPosition: Number(snapshot.lastEventPosition),\n          schemaVersion: Number(snapshot.schemaVersion),\n          createdAt: toDate(snapshot.createdAt),\n          state: superjson.parse(snapshot.state),\n          metadata: superjson.parse(snapshot.metadata),\n        }\n      },\n      async delete(target, fromStreamVersion) {\n        await ready()\n        await db()\n          .query(\n            `DELETE ${TABLES.aggregateRootSnapshots} WHERE streamId = $id AND streamType = $stream AND streamVersion > $fromStreamVersion;`,\n            {\n              id: target.id,\n              stream: target.stream,\n              fromStreamVersion,\n            },\n          )\n          .collect()\n      },\n    },\n  }\n}\n\nexport function createEventStore<const Root extends AnyAggregateRoot>({\n  database,\n  aggregateRoots,\n  postProcessEvent,\n  onProjectionReplay,\n  onProcessManagerRefresh,\n  onEventsAppended,\n  autoInit,\n  initSchema,\n  lock,\n}: SurrealEventStoreParams<Root>): EventStore<\n  EventsFromRoot<Root>,\n  Root,\n  true\n> {\n  const storage = createSurrealStorage({\n    database,\n    initSchema,\n    onEventsAppended,\n  })\n\n  return createBaseEventStore({\n    aggregateRoots,\n    postProcessEvent,\n    onProjectionReplay,\n    onProcessManagerRefresh,\n    autoInit,\n    lock,\n    ...storage,\n  }) as any\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "F7D6DA35C7597AFE64756E2164756E21",
+  "names": []
+}

package/dist/surreal/index.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.spec.d.ts.map

package/dist/surreal/index.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.spec.d.ts","sourceRoot":"","sources":["../../src/surreal/index.spec.ts"],"names":[],"mappings":""}

package/dist/surreal/schema.d.ts

@@ -0,0 +1,12 @@
+import type { Surreal } from 'surrealdb';
+export declare const TABLES: {
+    readonly events: "events";
+    readonly counters: "event_sourcing_counters";
+    readonly checkpoints: "checkpoints";
+    readonly aggregateRootSnapshots: "aggregate_root_snapshots";
+    readonly projectionSnapshots: "projection_snapshots";
+    readonly projectionAppliedEvents: "projection_applied_events";
+};
+export declare const SCHEMA_STATEMENTS: string;
+export declare function initSchema(database: Surreal): Promise<void>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/surreal/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/surreal/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAExC,eAAO,MAAM,MAAM;;;;;;;CAOT,CAAA;AAIV,eAAO,MAAM,iBAAiB,QAkD7B,CAAA;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE"}

package/dist/surreal/schema.js

@@ -0,0 +1,12 @@
+import {
+  SCHEMA_STATEMENTS,
+  TABLES,
+  initSchema
+} from "../chunk-ak901ckt.js";
+export {
+  initSchema,
+  TABLES,
+  SCHEMA_STATEMENTS
+};
+
+//# debugId=CB35243CA3B02CFF64756E2164756E21

package/dist/surreal/schema.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "CB35243CA3B02CFF64756E2164756E21",
+  "names": []
+}

package/dist/tests/projectionMultiInstance.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=projectionMultiInstance.spec.d.ts.map

package/dist/tests/projectionMultiInstance.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionMultiInstance.spec.d.ts","sourceRoot":"","sources":["../../src/tests/projectionMultiInstance.spec.ts"],"names":[],"mappings":""}

package/dist/tests/storageDriverContract.d.ts

@@ -0,0 +1,19 @@
+import type { AggregateRootSnapshotMethods } from '../createAggregateRoot.ts';
+import type { CheckpointMethods } from '../createCheckpointApi.ts';
+import type { LoadEvents } from '../createEventStore.ts';
+import type { ProjectionSnapshotMethods } from '../createProjection.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;
+};
+/**
+ * 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 declare function runStorageDriverContract(name: string, makeStorage: () => MaybePromise<StorageDriver>): void;
+//# sourceMappingURL=storageDriverContract.d.ts.map

package/dist/tests/storageDriverContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageDriverContract.d.ts","sourceRoot":"","sources":["../../src/tests/storageDriverContract.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,4BAA4B,EAC7B,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAc,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAEV,yBAAyB,EAC1B,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,QAAQ,EACT,MAAM,oBAAoB,CAAA;AAE3B,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,CACZ,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,cAAc,EAAE,EACxB,eAAe,EAAE,MAAM,KACpB,YAAY,CAAC,eAAe,EAAE,CAAC,CAAA;IACpC,UAAU,EAAE,iBAAiB,CAAA;IAC7B,kBAAkB,EAAE,yBAAyB,CAAA;IAC7C,qBAAqB,EAAE,4BAA4B,CAAA;CACpD,CAAA;AA8CD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,YAAY,CAAC,aAAa,CAAC,QAghB/C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@requence/event-sourcing",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Event sourcing primitives — aggregate roots, projections, process managers, and event listeners",
   "type": "module",
   "sideEffects": false,
@@ -37,6 +37,12 @@
       "types": "./dist/redis/index.d.ts",
       "import": "./dist/redis/index.js",
       "default": "./dist/redis/index.js"
+    },
+    "./surreal": {
+      "bun": "./src/surreal/index.ts",
+      "types": "./dist/surreal/index.d.ts",
+      "import": "./dist/surreal/index.js",
+      "default": "./dist/surreal/index.js"
     }
   },
   "files": [
@@ -49,6 +55,9 @@
     "build": "bun run build.ts",
     "test": "bun test",
     "check-types": "tsc --noEmit",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
     "cs": "changeset",
     "version": "changeset version",
     "release": "bun run build && changeset publish",
@@ -62,7 +71,8 @@
   "peerDependencies": {
     "zod": "^4.3.6",
     "drizzle-orm": "^0.45.1",
-    "ioredis": "^5.9.3"
+    "ioredis": "^5.9.3",
+    "surrealdb": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "drizzle-orm": {
@@ -70,24 +80,23 @@
     },
     "ioredis": {
       "optional": true
+    },
+    "surrealdb": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.31.0",
-    "@eslint/js": "^10.0.1",
-    "@stylistic/eslint-plugin": "^5.10.0",
+    "@surrealdb/node": "^3.0.3",
     "@types/bun": "^1.3.13",
     "@types/node": "^25.6.0",
     "drizzle-orm": "^0.45.1",
-    "eslint": "^10.2.1",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-no-only-tests": "^3.3.0",
-    "globals": "^17.5.0",
     "ioredis": "^5.10.1",
-    "prettier": "^3.8.3",
+    "oxfmt": "^0.59.0",
+    "oxlint": "^1.74.0",
+    "surrealdb": "^2.0.7",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.1",
     "zod": "^4.3.6"
   },
   "license": "MIT",

package/src/createAggregateRoot.ts

@@ -616,9 +616,8 @@ export function createAggregateRoot<Name extends string>(type: Name) {
                 return previousEvents
               }
               const events = (
-                await normalizeArray(
-                  commandFn.apply(rawCommands, args),
-                  () => extendLock(),
+                await normalizeArray(commandFn.apply(rawCommands, args), () =>
+                  extendLock(),
                 )
               ).filter((event) => Boolean(event))