@requence/event-sourcing 0.0.1 → 1.0.0

package/dist/drizzle/postgres.js.map

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

package/dist/errors.d.ts

@@ -0,0 +1,53 @@
+import z from 'zod/v4';
+import type { BaseOutputEvent, OutputEvent } from './utilityTypes.js';
+export declare class ConcurrencyError extends Error {
+    constructor(streamId: {
+        stream: string;
+        id: string;
+    }, expectedVersion: number, actualVersion: number);
+}
+export declare class ValidationError extends Error {
+    readonly zodError: z.ZodError;
+    constructor(message: string, zodError: z.ZodError);
+}
+export declare class EventValidationError extends ValidationError {
+}
+export declare class InfiniteLoopError extends Error {
+}
+export declare class CommandError<T extends Error> extends Error {
+    readonly aggregateRootType: string;
+    readonly commandName: string;
+    readonly streamId: string;
+    readonly originalError: T;
+    constructor(aggregateRootType: string, commandName: string, streamId: string, originalError: T);
+}
+export declare class ProjectionReplayLoopError extends Error {
+    readonly projection: {
+        name: string;
+        eventHandler: string;
+    };
+    readonly event: OutputEvent<any>;
+    constructor(message: string, projection: {
+        name: string;
+        eventHandler: string;
+    }, event: OutputEvent<any>);
+}
+export declare class RefreshingSkipError extends Error {
+}
+export declare class ReplaySkipError extends Error {
+}
+export declare class ProjectionEventHandlerExecutionError<T extends Error> extends Error {
+    readonly projection: string;
+    readonly eventHandler: string;
+    readonly event: BaseOutputEvent;
+    readonly originalError: T;
+    constructor(projection: string, eventHandler: string, event: BaseOutputEvent, originalError: T);
+}
+export declare class ProcessManagerEventHandlerExecutionError<T extends Error> extends Error {
+    readonly processManager: string;
+    readonly eventHandler: string;
+    readonly event: BaseOutputEvent;
+    readonly originalError: T;
+    constructor(processManager: string, eventHandler: string, event: BaseOutputEvent, originalError: T);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAA;AAEtB,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAErE,qBAAa,gBAAiB,SAAQ,KAAK;gBAEvC,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EACxC,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM;CAMxB;AAED,qBAAa,eAAgB,SAAQ,KAAK;aAGtB,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBADpC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,CAAC,CAAC,QAAQ;CAIvC;AAED,qBAAa,oBAAqB,SAAQ,eAAe;CAAG;AAE5D,qBAAa,iBAAkB,SAAQ,KAAK;CAAG;AAE/C,qBAAa,YAAY,CAAC,CAAC,SAAS,KAAK,CAAE,SAAQ,KAAK;aAEpC,iBAAiB,EAAE,MAAM;aACzB,WAAW,EAAE,MAAM;aACnB,QAAQ,EAAE,MAAM;aAChB,aAAa,EAAE,CAAC;gBAHhB,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,CAAC;CAMnC;AAED,qBAAa,yBAA0B,SAAQ,KAAK;aAGhC,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;aAClD,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC;gBAFvC,OAAO,EAAE,MAAM,EACC,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAClD,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC;CAI1C;AAED,qBAAa,mBAAoB,SAAQ,KAAK;CAAG;AAEjD,qBAAa,eAAgB,SAAQ,KAAK;CAAG;AAE7C,qBAAa,oCAAoC,CAC/C,CAAC,SAAS,KAAK,CACf,SAAQ,KAAK;aAEK,UAAU,EAAE,MAAM;aAClB,YAAY,EAAE,MAAM;aACpB,KAAK,EAAE,eAAe;aACtB,aAAa,EAAE,CAAC;gBAHhB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,CAAC;CAMnC;AAED,qBAAa,wCAAwC,CACnD,CAAC,SAAS,KAAK,CACf,SAAQ,KAAK;aAEK,cAAc,EAAE,MAAM;aACtB,YAAY,EAAE,MAAM;aACpB,KAAK,EAAE,eAAe;aACtB,aAAa,EAAE,CAAC;gBAHhB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,CAAC;CAMnC"}

package/dist/errors.js

@@ -0,0 +1,26 @@
+import {
+  CommandError,
+  ConcurrencyError,
+  EventValidationError,
+  InfiniteLoopError,
+  ProcessManagerEventHandlerExecutionError,
+  ProjectionEventHandlerExecutionError,
+  ProjectionReplayLoopError,
+  RefreshingSkipError,
+  ReplaySkipError,
+  ValidationError
+} from "./chunk-qdczt68t.js";
+export {
+  ValidationError,
+  ReplaySkipError,
+  RefreshingSkipError,
+  ProjectionReplayLoopError,
+  ProjectionEventHandlerExecutionError,
+  ProcessManagerEventHandlerExecutionError,
+  InfiniteLoopError,
+  EventValidationError,
+  ConcurrencyError,
+  CommandError
+};
+
+//# debugId=42D38D47B374FF0964756E2164756E21

package/dist/errors.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Stream, StreamEvents, StreamId, StreamIdEvents } from './utilityTypes.d.ts';
+export { createEventStore } from './createEventStore.ts';
+export type { BaseOutputEvent as Event } from './utilityTypes.d.ts';
+export { type Snapshot as ProjectionSnapshot, isInsideProjection, getProjectionInfo, } from './createProjection.ts';
+export type { Checkpoint } from './createCheckpointApi.ts';
+export { isInsideProcessManager, getProcessManagerInfo, } from './createProcessManager.ts';
+export { isInsideEventListener, getEventListenerInfo, } from './createEventListener.ts';
+export * from './errors.ts';
+export { type Snapshot as AggregateRootSnapshot, type AnyAggregateRoot, type AnyStream, createAggregateRoot, } from './createAggregateRoot.ts';
+export { skipRefreshing } from './refresh.ts';
+export { skipReplay } from './replay.ts';
+export declare function isStreamId(stream: Stream): stream is StreamId | StreamIdEvents;
+export declare function isStreamEvents(stream: Stream): stream is StreamEvents | StreamIdEvents;
+export type { WrappedEvent } from './wrappedEventBuilder.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,YAAY,EACZ,QAAQ,EACR,cAAc,EACf,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,YAAY,EAAE,eAAe,IAAI,KAAK,EAAE,MAAM,qBAAqB,CAAA;AACnE,OAAO,EACL,KAAK,QAAQ,IAAI,kBAAkB,EACnC,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,0BAA0B,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,OAAO,EACL,KAAK,QAAQ,IAAI,qBAAqB,EACtC,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,mBAAmB,GACpB,MAAM,0BAA0B,CAAA;AAEjC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GACb,MAAM,IAAI,QAAQ,GAAG,cAAc,CAErC;AACD,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GACb,MAAM,IAAI,YAAY,GAAG,cAAc,CAEzC;AACD,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/index.js

@@ -0,0 +1,73 @@
+import {
+  isStreamEvents,
+  isStreamId
+} from "./chunk-jd4q8fcf.js";
+import {
+  createEventStore
+} from "./chunk-wmz6a1jk.js";
+import {
+  getEventListenerInfo,
+  isInsideEventListener
+} from "./chunk-24xjphpk.js";
+import"./chunk-ty9bhdvx.js";
+import"./chunk-gq80tgvf.js";
+import {
+  createAggregateRoot
+} from "./chunk-tkvj6x8k.js";
+import"./chunk-z388cd25.js";
+import {
+  getProjectionInfo,
+  isInsideProjection
+} from "./chunk-ncpk70p4.js";
+import {
+  getProcessManagerInfo,
+  isInsideProcessManager
+} from "./chunk-m07vf8q9.js";
+import"./chunk-6q8mr1sg.js";
+import {
+  skipReplay
+} from "./chunk-x90g388y.js";
+import"./chunk-zf3x573k.js";
+import {
+  skipRefreshing
+} from "./chunk-9psg50cb.js";
+import"./chunk-tfy01fah.js";
+import"./chunk-pmfzjavb.js";
+import {
+  CommandError,
+  ConcurrencyError,
+  EventValidationError,
+  InfiniteLoopError,
+  ProcessManagerEventHandlerExecutionError,
+  ProjectionEventHandlerExecutionError,
+  ProjectionReplayLoopError,
+  RefreshingSkipError,
+  ReplaySkipError,
+  ValidationError
+} from "./chunk-qdczt68t.js";
+export {
+  skipReplay,
+  skipRefreshing,
+  isStreamId,
+  isStreamEvents,
+  isInsideProjection,
+  isInsideProcessManager,
+  isInsideEventListener,
+  getProjectionInfo,
+  getProcessManagerInfo,
+  getEventListenerInfo,
+  createEventStore,
+  createAggregateRoot,
+  ValidationError,
+  ReplaySkipError,
+  RefreshingSkipError,
+  ProjectionReplayLoopError,
+  ProjectionEventHandlerExecutionError,
+  ProcessManagerEventHandlerExecutionError,
+  InfiniteLoopError,
+  EventValidationError,
+  ConcurrencyError,
+  CommandError
+};
+
+//# debugId=0753D4FEC188EF0164756E2164756E21

package/dist/index.js.map

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

package/dist/lock.d.ts

@@ -0,0 +1,6 @@
+export default function lock(defaultTtl?: number): (key: string | string[]) => Promise<{
+    extend(ttl?: number): Promise<boolean>;
+    release(): Promise<void>;
+}>;
+export type LockCreator = ReturnType<typeof lock>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../src/lock.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,IAAI,CAAC,UAAU,SAAO,IAE9B,KAAK,MAAM,GAAG,MAAM,EAAE;iBA4Bb,MAAM;;GAuB9B;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,IAAI,CAAC,CAAA"}

package/dist/lock.js

@@ -0,0 +1,8 @@
+import {
+  lock
+} from "./chunk-ty9bhdvx.js";
+export {
+  lock as default
+};
+
+//# debugId=36DB8B5837ED61E464756E2164756E21

package/dist/lock.js.map

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

package/dist/memory/index.d.ts

@@ -0,0 +1,15 @@
+import type { AnyAggregateRoot } from '../createAggregateRoot.ts';
+import type { EventStore, EventStoreParamsWithAggregateRootSnapshots, EventsFromRoot, OnProgress } from '../createEventStore.ts';
+import type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js';
+export { createAggregateRoot } from '../index.ts';
+export type OnEventsAppended = (events: BaseOutputEvent[]) => MaybePromise<void>;
+interface MemoryEventStoreParams<Root extends AnyAggregateRoot> {
+    aggregateRoots: Root[];
+    autoInit?: boolean;
+    postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent'];
+    onProjectionReplay?: OnProgress;
+    onProcessManagerRefresh?: OnProgress;
+    onEventsAppended?: OnEventsAppended;
+}
+export declare function createEventStore<const Root extends AnyAggregateRoot>({ aggregateRoots, postProcessEvent, onProjectionReplay, onProcessManagerRefresh, onEventsAppended, autoInit, }: MemoryEventStoreParams<Root>): EventStore<EventsFromRoot<Root>, Root, true>;
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAWjE,OAAO,KAAK,EACV,UAAU,EACV,0CAA0C,EAC1C,cAAc,EACd,UAAU,EACX,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEjD,MAAM,MAAM,gBAAgB,GAAG,CAC7B,MAAM,EAAE,eAAe,EAAE,KACtB,YAAY,CAAC,IAAI,CAAC,CAAA;AAEvB,UAAU,sBAAsB,CAAC,IAAI,SAAS,gBAAgB;IAC5D,cAAc,EAAE,IAAI,EAAE,CAAA;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,CAAC,EAAE,0CAA0C,CAAC,IAAI,CAAC,CAAC,kBAAkB,CAAC,CAAA;IACvF,kBAAkB,CAAC,EAAE,UAAU,CAAA;IAC/B,uBAAuB,CAAC,EAAE,UAAU,CAAA;IACpC,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;CACpC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,IAAI,SAAS,gBAAgB,EAAE,EACpE,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,gBAAgB,EAChB,QAAQ,GACT,EAAE,sBAAsB,CAAC,IAAI,CAAC,GAAG,UAAU,CAC1C,cAAc,CAAC,IAAI,CAAC,EACpB,IAAI,EACJ,IAAI,CACL,CAkLA"}

package/dist/memory/index.js

@@ -0,0 +1,178 @@
+import {
+  isStreamEvents,
+  isStreamId
+} from "../chunk-jd4q8fcf.js";
+import {
+  createEventStore
+} from "../chunk-wmz6a1jk.js";
+import"../chunk-24xjphpk.js";
+import"../chunk-ty9bhdvx.js";
+import"../chunk-gq80tgvf.js";
+import {
+  createAggregateRoot
+} from "../chunk-tkvj6x8k.js";
+import"../chunk-z388cd25.js";
+import"../chunk-ncpk70p4.js";
+import"../chunk-m07vf8q9.js";
+import"../chunk-6q8mr1sg.js";
+import"../chunk-x90g388y.js";
+import"../chunk-zf3x573k.js";
+import"../chunk-9psg50cb.js";
+import"../chunk-tfy01fah.js";
+import"../chunk-pmfzjavb.js";
+import {
+  ConcurrencyError
+} from "../chunk-qdczt68t.js";
+
+// src/memory/index.ts
+function createEventStore2({
+  aggregateRoots,
+  postProcessEvent,
+  onProjectionReplay,
+  onProcessManagerRefresh,
+  onEventsAppended,
+  autoInit
+}) {
+  const events = [];
+  const checkpoints = new Set;
+  const aggregateRootSnapshots = new Map;
+  const projectionSnapshots = new Set;
+  const projectionAppliedCount = new Map;
+  return createEventStore({
+    aggregateRoots,
+    postProcessEvent,
+    onProjectionReplay,
+    onProcessManagerRefresh,
+    autoInit,
+    async* loadEvents(select, range) {
+      let streamTypes = null;
+      let streamIds = null;
+      let eventTypes = null;
+      if (select) {
+        const selects = Array.isArray(select) ? select : [select];
+        streamTypes = selects.map((select2) => select2.stream);
+        streamIds = selects.map((select2) => isStreamId(select2) ? select2.id : null).filter(Boolean);
+        eventTypes = selects.flatMap((select2) => isStreamEvents(select2) ? select2.events : []);
+      }
+      const filteredEvents = events.filter((event) => {
+        if (streamTypes?.length && !streamTypes.includes(event.streamType)) {
+          return false;
+        }
+        if (streamIds?.length && !streamIds.includes(event.streamId)) {
+          return false;
+        }
+        if (eventTypes?.length && !eventTypes.includes(event.type)) {
+          return false;
+        }
+        if (range?.from && event.position < range.from) {
+          return false;
+        }
+        if (range?.to && event.position > range.to) {
+          return false;
+        }
+        return true;
+      });
+      for (const event of filteredEvents) {
+        yield event;
+      }
+    },
+    appendEvents({ id, stream }, newEvents, expectedVersion) {
+      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 = newEvents.map((event, index) => ({
+        ...event,
+        createdAt: new Date,
+        position: events.length + index,
+        streamId: id,
+        streamType: stream,
+        streamVersion: expectedVersion + index + 1
+      }));
+      events.push(...extendedEvents);
+      onEventsAppended?.(extendedEvents);
+      return extendedEvents;
+    },
+    checkpoint: {
+      get(type, name) {
+        for (const checkpoint of checkpoints) {
+          if (checkpoint.type === type && checkpoint.name === name) {
+            return checkpoint;
+          }
+        }
+      },
+      upsert(checkpoint) {
+        let persisted;
+        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, name) {
+        for (const checkpoint of checkpoints) {
+          if (checkpoint.type === type && checkpoint.name === name) {
+            checkpoints.delete(checkpoint);
+          }
+        }
+      }
+    },
+    projectionSnapshot: {
+      put(snapshot) {
+        projectionSnapshots.add(snapshot);
+      },
+      get(select) {
+        return Array.from(projectionSnapshots).toReversed().find((snapshot) => snapshot.projectionId === select.id && snapshot.projectionType === select.projection);
+      },
+      delete(target, fromPosition) {
+        for (const snapshot of projectionSnapshots) {
+          if (target.id && snapshot.projectionId !== target.id) {
+            continue;
+          }
+          if (snapshot.projectionType !== target.projection) {
+            continue;
+          }
+          if (fromPosition && snapshot.lastEventPosition < fromPosition) {
+            continue;
+          }
+          projectionSnapshots.delete(snapshot);
+        }
+      },
+      incrementAppliedCount(select) {
+        const key = `${select.projection}-${select.id}`;
+        const nextCount = (projectionAppliedCount.get(key) ?? 0) + 1;
+        projectionAppliedCount.set(key, nextCount);
+        return nextCount;
+      }
+    },
+    aggregateRootSnapshot: {
+      put(snapshot) {
+        aggregateRootSnapshots.set(`${snapshot.streamType}:${snapshot.streamId}`, snapshot);
+      },
+      get(select) {
+        return aggregateRootSnapshots.get(`${select.stream}:${select.id}`);
+      },
+      delete(target, fromStreamVersion) {
+        const key = `${target.stream}:${target.id}`;
+        const snapshot = aggregateRootSnapshots.get(key);
+        if (snapshot && snapshot.streamVersion > fromStreamVersion) {
+          aggregateRootSnapshots.delete(key);
+        }
+      }
+    }
+  });
+}
+export {
+  createEventStore2 as createEventStore,
+  createAggregateRoot
+};
+
+//# debugId=D1D2F8225B86D9D864756E2164756E21

package/dist/memory/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/memory/index.ts"],
+  "sourcesContent": [
+    "import type { AnyAggregateRoot } from '../createAggregateRoot.ts'\nimport type { Checkpoint } from '../createCheckpointApi.ts'\nimport {\n  type AggregateRootSnapshot,\n  ConcurrencyError,\n  type Event,\n  type ProjectionSnapshot,\n  createEventStore as createBaseEventStore,\n  isStreamEvents,\n  isStreamId,\n} from '../index.ts'\nimport type {\n  EventStore,\n  EventStoreParamsWithAggregateRootSnapshots,\n  EventsFromRoot,\n  OnProgress,\n} from '../createEventStore.ts'\nimport type { BaseOutputEvent, MaybePromise } from '../utilityTypes.js'\n\nexport { createAggregateRoot } from '../index.ts'\n\nexport type OnEventsAppended = (\n  events: BaseOutputEvent[],\n) => MaybePromise<void>\n\ninterface MemoryEventStoreParams<Root extends AnyAggregateRoot> {\n  aggregateRoots: Root[]\n  autoInit?: boolean\n  postProcessEvent?: EventStoreParamsWithAggregateRootSnapshots<Root>['postProcessEvent']\n  onProjectionReplay?: OnProgress\n  onProcessManagerRefresh?: OnProgress\n  onEventsAppended?: OnEventsAppended\n}\n\nexport function createEventStore<const Root extends AnyAggregateRoot>({\n  aggregateRoots,\n  postProcessEvent,\n  onProjectionReplay,\n  onProcessManagerRefresh,\n  onEventsAppended,\n  autoInit,\n}: MemoryEventStoreParams<Root>): EventStore<\n  EventsFromRoot<Root>,\n  Root,\n  true\n> {\n  const events: Event[] = []\n  const checkpoints = new Set<Checkpoint>()\n  const aggregateRootSnapshots = new Map<string, AggregateRootSnapshot>()\n  const projectionSnapshots = new Set<ProjectionSnapshot>()\n  const projectionAppliedCount = new Map<string, number>()\n\n  return createBaseEventStore({\n    aggregateRoots,\n    postProcessEvent,\n    onProjectionReplay,\n    onProcessManagerRefresh,\n    autoInit,\n\n    async *loadEvents(select, range) {\n      let streamTypes: string[] | null = null\n      let streamIds: string[] | null = null\n      let eventTypes: string[] | null = null\n\n      if (select) {\n        const selects = Array.isArray(select) ? select : [select]\n        streamTypes = selects.map((select) => select.stream)\n        streamIds = selects\n          .map((select) => (isStreamId(select) ? select.id : null))\n          .filter(Boolean) as string[]\n        eventTypes = selects.flatMap((select) =>\n          isStreamEvents(select) ? select.events : [],\n        )\n      }\n\n      const filteredEvents = events.filter((event) => {\n        if (streamTypes?.length && !streamTypes.includes(event.streamType)) {\n          return false\n        }\n\n        if (streamIds?.length && !streamIds.includes(event.streamId)) {\n          return false\n        }\n\n        if (eventTypes?.length && !eventTypes.includes(event.type)) {\n          return false\n        }\n\n        if (range?.from && event.position < range.from) {\n          return false\n        }\n\n        if (range?.to && event.position > range.to) {\n          return false\n        }\n\n        return true\n      })\n\n      for (const event of filteredEvents) {\n        yield event\n      }\n    },\n\n    appendEvents({ id, stream }, newEvents, expectedVersion) {\n      const lastEvent = events.findLast(\n        (e) => e.streamId === id && e.streamType === stream,\n      )\n\n      const currentVersion = lastEvent?.streamVersion ?? 0\n\n      if (currentVersion !== expectedVersion) {\n        throw new ConcurrencyError(\n          { id, stream },\n          expectedVersion,\n          currentVersion,\n        )\n      }\n\n      const extendedEvents: Event[] = newEvents.map((event, index) => ({\n        ...event,\n        createdAt: new Date(),\n        position: events.length + index,\n        streamId: id,\n        streamType: stream,\n        streamVersion: expectedVersion + index + 1,\n      }))\n\n      events.push(...extendedEvents)\n      onEventsAppended?.(extendedEvents)\n      return extendedEvents\n    },\n\n    checkpoint: {\n      get(type, name) {\n        for (const checkpoint of checkpoints) {\n          if (checkpoint.type === type && checkpoint.name === name) {\n            return checkpoint\n          }\n        }\n      },\n      upsert(checkpoint) {\n        let persisted: Checkpoint | undefined\n        for (const c of checkpoints) {\n          if (c.type === checkpoint.type && c.name === checkpoint.name) {\n            persisted = c\n            break\n          }\n        }\n\n        if (persisted) {\n          persisted.lastEventPosition = checkpoint.lastEventPosition\n          persisted.metadata = checkpoint.metadata\n        } else {\n          checkpoints.add(checkpoint)\n        }\n      },\n      delete(type, name) {\n        for (const checkpoint of checkpoints) {\n          if (checkpoint.type === type && checkpoint.name === name) {\n            checkpoints.delete(checkpoint)\n          }\n        }\n      },\n    },\n\n    projectionSnapshot: {\n      put(snapshot) {\n        projectionSnapshots.add(snapshot)\n      },\n      get(select) {\n        return Array.from(projectionSnapshots)\n          .toReversed()\n          .find(\n            (snapshot) =>\n              snapshot.projectionId === select.id &&\n              snapshot.projectionType === select.projection,\n          )\n      },\n      delete(target, fromPosition) {\n        for (const snapshot of projectionSnapshots) {\n          if (target.id && snapshot.projectionId !== target.id) {\n            continue\n          }\n\n          if (snapshot.projectionType !== target.projection) {\n            continue\n          }\n\n          if (fromPosition && snapshot.lastEventPosition < fromPosition) {\n            continue\n          }\n\n          projectionSnapshots.delete(snapshot)\n        }\n      },\n      incrementAppliedCount(select) {\n        const key = `${select.projection}-${select.id}`\n        const nextCount = (projectionAppliedCount.get(key) ?? 0) + 1\n        projectionAppliedCount.set(key, nextCount)\n        return nextCount\n      },\n    },\n\n    aggregateRootSnapshot: {\n      put(snapshot) {\n        aggregateRootSnapshots.set(\n          `${snapshot.streamType}:${snapshot.streamId}`,\n          snapshot,\n        )\n      },\n      get(select) {\n        return aggregateRootSnapshots.get(`${select.stream}:${select.id}`)\n      },\n      delete(target, fromStreamVersion) {\n        const key = `${target.stream}:${target.id}`\n        const snapshot = aggregateRootSnapshots.get(key)\n        if (snapshot && snapshot.streamVersion > fromStreamVersion) {\n          aggregateRootSnapshots.delete(key)\n        }\n      },\n    },\n  }) as any\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "D1D2F8225B86D9D864756E2164756E21",
+  "names": []
+}

package/dist/redis/index.d.ts

@@ -0,0 +1,2 @@
+export * from './redisLock.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/redis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/redis/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA"}

package/dist/redis/index.js

@@ -0,0 +1,8 @@
+import {
+  redisLock
+} from "../chunk-dgzw1nj9.js";
+export {
+  redisLock
+};
+
+//# debugId=CA5CF311636766FE64756E2164756E21

package/dist/redis/index.js.map

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

package/dist/redis/redisLock.d.ts

@@ -0,0 +1,4 @@
+import type { Redis } from 'ioredis';
+import type { LockCreator } from '../lock.ts';
+export declare function redisLock(client: Redis, defaultTtl?: number): LockCreator;
+//# sourceMappingURL=redisLock.d.ts.map

package/dist/redis/redisLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisLock.d.ts","sourceRoot":"","sources":["../../src/redis/redisLock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAkB7C,wBAAgB,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,SAAO,GAAG,WAAW,CAwCvE"}

package/dist/redis/redisLock.js

@@ -0,0 +1,8 @@
+import {
+  redisLock
+} from "../chunk-dgzw1nj9.js";
+export {
+  redisLock
+};
+
+//# debugId=DC95B1ADD03DBC5B64756E2164756E21

package/dist/redis/redisLock.js.map

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

package/dist/refresh.d.ts

@@ -0,0 +1,4 @@
+export declare function isRefreshing(): boolean;
+export declare function withRefreshing<T extends () => any>(handler: T): any;
+export declare function skipRefreshing(): void;
+//# sourceMappingURL=refresh.d.ts.map

package/dist/refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../src/refresh.ts"],"names":[],"mappings":"AAMA,wBAAgB,YAAY,YAE3B;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,EAAE,OAAO,EAAE,CAAC,OAE7D;AAED,wBAAgB,cAAc,SAI7B"}

package/dist/refresh.js

@@ -0,0 +1,13 @@
+import {
+  isRefreshing,
+  skipRefreshing,
+  withRefreshing
+} from "./chunk-9psg50cb.js";
+import"./chunk-qdczt68t.js";
+export {
+  withRefreshing,
+  skipRefreshing,
+  isRefreshing
+};
+
+//# debugId=48951B7393C2336164756E2164756E21

package/dist/refresh.js.map

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

package/dist/replay.d.ts

@@ -0,0 +1,4 @@
+export declare function isReplaying(): boolean;
+export declare function withReplaying<T extends () => any>(handler: T): any;
+export declare function skipReplay(): void;
+//# sourceMappingURL=replay.d.ts.map

package/dist/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../src/replay.ts"],"names":[],"mappings":"AAMA,wBAAgB,WAAW,YAE1B;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,EAAE,OAAO,EAAE,CAAC,OAE5D;AAED,wBAAgB,UAAU,SAIzB"}

package/dist/replay.js

@@ -0,0 +1,13 @@
+import {
+  isReplaying,
+  skipReplay,
+  withReplaying
+} from "./chunk-x90g388y.js";
+import"./chunk-qdczt68t.js";
+export {
+  withReplaying,
+  skipReplay,
+  isReplaying
+};
+
+//# debugId=AE0452BBFD37506A64756E2164756E21

package/dist/replay.js.map

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