@requence/event-sourcing 0.0.1 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 requence
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-24xjphpk.js

@@ -0,0 +1,51 @@
+// src/createEventListener.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var eventListenerInfoStore = new AsyncLocalStorage;
+function withEventListenerInfo(info, handler) {
+  return eventListenerInfoStore.run(info, handler);
+}
+function getEventListenerInfo() {
+  return eventListenerInfoStore.getStore();
+}
+function isInsideEventListener() {
+  return Boolean(getEventListenerInfo());
+}
+function createEventListener(name = null) {
+  let eventHandlers = {};
+  let afterEffectHandlers = {};
+  let globalEventHandler;
+  let globalAfterEffect;
+  const api = {
+    async apply(event) {
+      withEventListenerInfo({ name, event }, async () => {
+        await eventHandlers[`on${event.type}`]?.(event);
+        await globalEventHandler?.(event);
+      });
+    },
+    async applyAfter(event) {
+      await afterEffectHandlers[`after${event.type}`]?.(event);
+      await globalAfterEffect?.(event);
+    },
+    withEventHandlers(handlers) {
+      eventHandlers = handlers;
+      return api;
+    },
+    withGlobalEventHandler(handler) {
+      globalEventHandler = handler;
+      return api;
+    },
+    withAfterEffects(handlers) {
+      afterEffectHandlers = handlers;
+      return api;
+    },
+    withGlobalAfterEffect(handler) {
+      globalAfterEffect = handler;
+      return api;
+    }
+  };
+  return api;
+}
+
+export { getEventListenerInfo, isInsideEventListener, createEventListener };
+
+//# debugId=BA79940C1474466C64756E2164756E21

package/dist/chunk-24xjphpk.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/createEventListener.ts"],
+  "sourcesContent": [
+    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport type {\n  AfterEffectHandlers,\n  AllEvents,\n  BaseOutputEvent,\n  EventHandlers,\n  EventTemplate,\n  Keys,\n  MaybePromise,\n  Merge,\n} from './utilityTypes.js'\n\nexport type InternalEventListener = {\n  apply: (event: BaseOutputEvent) => Promise<void>\n  applyAfter: (event: BaseOutputEvent) => Promise<void>\n}\n\ntype EventListenerInfo = {\n  name: string | null\n  event: BaseOutputEvent\n}\nconst eventListenerInfoStore = new AsyncLocalStorage<EventListenerInfo>()\n\nfunction withEventListenerInfo(\n  info: EventListenerInfo,\n  handler: () => Promise<void>,\n) {\n  return eventListenerInfoStore.run(info, handler)\n}\n\nexport function getEventListenerInfo() {\n  return eventListenerInfoStore.getStore()\n}\n\nexport function isInsideEventListener() {\n  return Boolean(getEventListenerInfo())\n}\n\nexport type EventListenerApi<\n  Events extends EventTemplate = never,\n  Flags extends {\n    withEventHandlers: boolean\n    withGlobalEventHandler: boolean\n    withAfterEffects: boolean\n    withGlobalAfterEffect: boolean\n  } = {\n    withEventHandlers: false\n    withGlobalEventHandler: false\n    withAfterEffects: false\n    withGlobalAfterEffect: false\n  },\n> = {\n  withEventHandlers: (\n    handlers: EventHandlers<Events>,\n  ) => Omit<\n    EventListenerApi<Events, Merge<Flags, { withEventHandlers: true }>>,\n    Keys<Merge<Flags, { withEventHandlers: true }>>\n  >\n  withGlobalEventHandler: (\n    handler: (event: AllEvents<Events>) => MaybePromise<void>,\n  ) => Omit<\n    EventListenerApi<Events, Merge<Flags, { withGlobalEventHandler: true }>>,\n    Keys<Merge<Flags, { withGlobalEventHandler: true }>>\n  >\n  withAfterEffects: (\n    handlers: AfterEffectHandlers<Events>,\n  ) => Omit<\n    EventListenerApi<Events, Merge<Flags, { withAfterEffects: true }>>,\n    Keys<Merge<Flags, { withAfterEffects: true }>>\n  >\n  withGlobalAfterEffect: (\n    handler: (event: AllEvents<Events>) => MaybePromise<void>,\n  ) => Omit<\n    EventListenerApi<Events, Merge<Flags, { withGlobalAfterEffect: true }>>,\n    Keys<Merge<Flags, { withGlobalAfterEffect: true }>>\n  >\n}\n\nexport function createEventListener(\n  name: string | null = null,\n): EventListenerApi {\n  let eventHandlers: EventHandlers<any> = {}\n  let afterEffectHandlers: AfterEffectHandlers<any> = {}\n  let globalEventHandler: (event: BaseOutputEvent) => MaybePromise<void>\n  let globalAfterEffect: (event: BaseOutputEvent) => MaybePromise<void>\n  const api = {\n    async apply(event) {\n      withEventListenerInfo({ name, event }, async () => {\n        await eventHandlers[`on${event.type}`]?.(event)\n        await globalEventHandler?.(event)\n      })\n    },\n\n    async applyAfter(event) {\n      await afterEffectHandlers[`after${event.type}`]?.(event)\n      await globalAfterEffect?.(event)\n    },\n    withEventHandlers(handlers) {\n      eventHandlers = handlers\n      return api\n    },\n    withGlobalEventHandler(handler) {\n      globalEventHandler = handler as any\n      return api\n    },\n    withAfterEffects(handlers) {\n      afterEffectHandlers = handlers\n      return api\n    },\n    withGlobalAfterEffect(handler) {\n      globalAfterEffect = handler as any\n      return api\n    },\n  } as EventListenerApi & InternalEventListener\n\n  return api\n}\n"
+  ],
+  "mappings": ";AAAA;AAsBA,IAAM,yBAAyB,IAAI;AAEnC,SAAS,qBAAqB,CAC5B,MACA,SACA;AAAA,EACA,OAAO,uBAAuB,IAAI,MAAM,OAAO;AAAA;AAG1C,SAAS,oBAAoB,GAAG;AAAA,EACrC,OAAO,uBAAuB,SAAS;AAAA;AAGlC,SAAS,qBAAqB,GAAG;AAAA,EACtC,OAAO,QAAQ,qBAAqB,CAAC;AAAA;AA2ChC,SAAS,mBAAmB,CACjC,OAAsB,MACJ;AAAA,EAClB,IAAI,gBAAoC,CAAC;AAAA,EACzC,IAAI,sBAAgD,CAAC;AAAA,EACrD,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,MAAM,MAAM;AAAA,SACJ,MAAK,CAAC,OAAO;AAAA,MACjB,sBAAsB,EAAE,MAAM,MAAM,GAAG,YAAY;AAAA,QACjD,MAAM,cAAc,KAAK,MAAM,UAAU,KAAK;AAAA,QAC9C,MAAM,qBAAqB,KAAK;AAAA,OACjC;AAAA;AAAA,SAGG,WAAU,CAAC,OAAO;AAAA,MACtB,MAAM,oBAAoB,QAAQ,MAAM,UAAU,KAAK;AAAA,MACvD,MAAM,oBAAoB,KAAK;AAAA;AAAA,IAEjC,iBAAiB,CAAC,UAAU;AAAA,MAC1B,gBAAgB;AAAA,MAChB,OAAO;AAAA;AAAA,IAET,sBAAsB,CAAC,SAAS;AAAA,MAC9B,qBAAqB;AAAA,MACrB,OAAO;AAAA;AAAA,IAET,gBAAgB,CAAC,UAAU;AAAA,MACzB,sBAAsB;AAAA,MACtB,OAAO;AAAA;AAAA,IAET,qBAAqB,CAAC,SAAS;AAAA,MAC7B,oBAAoB;AAAA,MACpB,OAAO;AAAA;AAAA,EAEX;AAAA,EAEA,OAAO;AAAA;",
+  "debugId": "BA79940C1474466C64756E2164756E21",
+  "names": []
+}

package/dist/chunk-3t1vzbab.js

@@ -0,0 +1,88 @@
+// src/drizzle/postgres.ts
+import { sql } from "drizzle-orm";
+import {
+  bigint,
+  index,
+  integer,
+  jsonb,
+  pgPolicy,
+  pgSchema,
+  text,
+  timestamp,
+  unique,
+  uuid
+} from "drizzle-orm/pg-core";
+var eventSourcing = pgSchema("event_sourcing");
+var events = eventSourcing.table("events", {
+  position: bigint({ mode: "number" }).generatedByDefaultAsIdentity().primaryKey(),
+  id: uuid().unique().notNull().defaultRandom(),
+  streamId: text().notNull(),
+  streamType: text().notNull(),
+  streamVersion: bigint({ mode: "number" }).notNull(),
+  type: text().notNull(),
+  createdAt: timestamp().defaultNow().notNull(),
+  payload: text().notNull(),
+  metadata: jsonb().$type().notNull(),
+  causationId: uuid(),
+  correlationId: uuid(),
+  actorId: text(),
+  schemaVersion: integer().notNull()
+}, (table) => [
+  unique().on(table.streamId, table.streamVersion, table.streamType),
+  index().on(table.streamId, table.streamVersion.desc()),
+  index("metadata").using("gin", sql`${table.metadata} jsonb_path_ops`),
+  pgPolicy("insert only", {
+    for: "insert",
+    to: "public",
+    withCheck: sql`true`
+  })
+]);
+var aggregateRootSnapshots = eventSourcing.table("aggregate_root_snapshots", {
+  id: uuid().primaryKey().defaultRandom(),
+  streamId: text().notNull(),
+  streamType: text().notNull(),
+  streamVersion: bigint({ mode: "number" }).notNull(),
+  state: text().notNull(),
+  metadata: text().notNull(),
+  createdAt: timestamp().defaultNow().notNull(),
+  lastEventPosition: bigint({ mode: "number" }).notNull(),
+  schemaVersion: integer().notNull()
+}, (table) => [
+  unique().on(table.streamType, table.streamId, table.streamVersion),
+  index().on(table.streamType, table.streamId, table.streamVersion.desc())
+]);
+var projectionSnapshots = eventSourcing.table("projection_snapshots", {
+  id: uuid().primaryKey().defaultRandom(),
+  projectionId: text().notNull(),
+  projectionType: text().notNull(),
+  state: text().notNull(),
+  metadata: text().notNull(),
+  createdAt: timestamp().defaultNow().notNull(),
+  lastEventPosition: bigint({ mode: "number" }).notNull(),
+  schemaVersion: integer().notNull()
+}, (table) => [
+  unique().on(table.projectionId, table.projectionType, table.lastEventPosition),
+  index().on(table.projectionId, table.projectionType, table.lastEventPosition.desc())
+]);
+var checkpoints = eventSourcing.table("checkpoints", {
+  id: uuid().defaultRandom().primaryKey(),
+  type: text({ enum: ["projection", "processManager"] }).notNull(),
+  name: text().notNull(),
+  lastEventPosition: bigint({ mode: "number" }).notNull(),
+  metadata: text().notNull()
+}, (table) => [
+  unique().on(table.type, table.name),
+  index().on(table.type, table.name)
+]);
+var projectionAppliedEvents = eventSourcing.table("projection_applied_events", {
+  projectionId: uuid().notNull(),
+  projectionType: text().notNull(),
+  appliedEvents: integer().notNull()
+}, (table) => [
+  unique().on(table.projectionId, table.projectionType),
+  index().on(table.projectionId, table.projectionType)
+]);
+
+export { eventSourcing, events, aggregateRootSnapshots, projectionSnapshots, checkpoints, projectionAppliedEvents };
+
+//# debugId=336C30BF93DC04EF64756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/drizzle/postgres.ts"],
+  "sourcesContent": [
+    "import { sql } from 'drizzle-orm'\nimport {\n  bigint,\n  index,\n  integer,\n  jsonb,\n  pgPolicy,\n  pgSchema,\n  text,\n  timestamp,\n  unique,\n  uuid,\n} from 'drizzle-orm/pg-core'\nimport type { SuperJSONResult } from 'superjson'\n\nexport const eventSourcing = pgSchema('event_sourcing')\n\nexport const events = eventSourcing.table(\n  'events',\n  {\n    position: bigint({ mode: 'number' })\n      .generatedByDefaultAsIdentity()\n      .primaryKey(),\n    id: uuid().unique().notNull().defaultRandom(),\n    streamId: text().notNull(),\n    streamType: text().notNull(),\n    streamVersion: bigint({ mode: 'number' }).notNull(),\n    type: text().notNull(),\n    createdAt: timestamp().defaultNow().notNull(),\n    payload: text().notNull(),\n    metadata: jsonb().$type<SuperJSONResult>().notNull(),\n    causationId: uuid(),\n    correlationId: uuid(),\n    actorId: text(),\n    schemaVersion: integer().notNull(),\n  },\n  (table) => [\n    unique().on(table.streamId, table.streamVersion, table.streamType),\n    index().on(table.streamId, table.streamVersion.desc()),\n    index('metadata').using('gin', sql`${table.metadata} jsonb_path_ops`),\n    pgPolicy('insert only', {\n      for: 'insert',\n      to: 'public',\n      withCheck: sql`true`,\n    }),\n  ],\n)\n\nexport const aggregateRootSnapshots = eventSourcing.table(\n  'aggregate_root_snapshots',\n  {\n    id: uuid().primaryKey().defaultRandom(),\n    streamId: text().notNull(),\n    streamType: text().notNull(),\n    streamVersion: bigint({ mode: 'number' }).notNull(),\n    state: text().notNull(),\n    metadata: text().notNull(),\n    createdAt: timestamp().defaultNow().notNull(),\n    lastEventPosition: bigint({ mode: 'number' }).notNull(),\n    schemaVersion: integer().notNull(),\n  },\n  (table) => [\n    unique().on(table.streamType, table.streamId, table.streamVersion),\n    index().on(table.streamType, table.streamId, table.streamVersion.desc()),\n  ],\n)\n\nexport const projectionSnapshots = eventSourcing.table(\n  'projection_snapshots',\n  {\n    id: uuid().primaryKey().defaultRandom(),\n    projectionId: text().notNull(),\n    projectionType: text().notNull(),\n    state: text().notNull(),\n    metadata: text().notNull(),\n    createdAt: timestamp().defaultNow().notNull(),\n    lastEventPosition: bigint({ mode: 'number' }).notNull(),\n    schemaVersion: integer().notNull(),\n  },\n  (table) => [\n    unique().on(\n      table.projectionId,\n      table.projectionType,\n      table.lastEventPosition,\n    ),\n    index().on(\n      table.projectionId,\n      table.projectionType,\n      table.lastEventPosition.desc(),\n    ),\n  ],\n)\n\nexport const checkpoints = eventSourcing.table(\n  'checkpoints',\n  {\n    id: uuid().defaultRandom().primaryKey(),\n    type: text({ enum: ['projection', 'processManager'] }).notNull(),\n    name: text().notNull(),\n    lastEventPosition: bigint({ mode: 'number' }).notNull(),\n    metadata: text().notNull(),\n  },\n  (table) => [\n    unique().on(table.type, table.name),\n    index().on(table.type, table.name),\n  ],\n)\n\nexport const projectionAppliedEvents = eventSourcing.table(\n  'projection_applied_events',\n  {\n    projectionId: uuid().notNull(),\n    projectionType: text().notNull(),\n    appliedEvents: integer().notNull(),\n  },\n  (table) => [\n    unique().on(table.projectionId, table.projectionType),\n    index().on(table.projectionId, table.projectionType),\n  ],\n)\n"
+  ],
+  "mappings": "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",
+  "debugId": "336C30BF93DC04EF64756E2164756E21",
+  "names": []
+}

package/dist/chunk-6q8mr1sg.js

@@ -0,0 +1,13 @@
+// src/superjson.ts
+import SuperJSON from "superjson";
+var superjson = new SuperJSON;
+function extendTypes(handler) {
+  handler(superjson);
+}
+function clone(obj) {
+  return superjson.deserialize(superjson.serialize(obj));
+}
+
+export { superjson, extendTypes, clone };
+
+//# debugId=97ED416FCC5782E564756E2164756E21

package/dist/chunk-6q8mr1sg.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/superjson.ts"],
+  "sourcesContent": [
+    "import SuperJSON from 'superjson'\n\nexport const superjson = new SuperJSON()\n\nexport function extendTypes(handler: (superjson: SuperJSON) => void) {\n  handler(superjson)\n}\n\nexport function clone<T>(obj: T): T {\n  return superjson.deserialize(superjson.serialize(obj))\n}\n"
+  ],
+  "mappings": ";AAAA;AAEO,IAAM,YAAY,IAAI;AAEtB,SAAS,WAAW,CAAC,SAAyC;AAAA,EACnE,QAAQ,SAAS;AAAA;AAGZ,SAAS,KAAQ,CAAC,KAAW;AAAA,EAClC,OAAO,UAAU,YAAY,UAAU,UAAU,GAAG,CAAC;AAAA;",
+  "debugId": "97ED416FCC5782E564756E2164756E21",
+  "names": []
+}

package/dist/chunk-9psg50cb.js

@@ -0,0 +1,22 @@
+import {
+  RefreshingSkipError
+} from "./chunk-qdczt68t.js";
+
+// src/refresh.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var refreshStore = new AsyncLocalStorage;
+function isRefreshing() {
+  return refreshStore.getStore() ?? false;
+}
+function withRefreshing(handler) {
+  return refreshStore.run(true, handler);
+}
+function skipRefreshing() {
+  if (isRefreshing()) {
+    throw new RefreshingSkipError;
+  }
+}
+
+export { isRefreshing, withRefreshing, skipRefreshing };
+
+//# debugId=662B9CB5FCF319E264756E2164756E21

package/dist/chunk-9psg50cb.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/refresh.ts"],
+  "sourcesContent": [
+    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport { RefreshingSkipError } from './errors.ts'\n\nconst refreshStore = new AsyncLocalStorage<boolean>()\n\nexport function isRefreshing() {\n  return refreshStore.getStore() ?? false\n}\n\nexport function withRefreshing<T extends () => any>(handler: T) {\n  return refreshStore.run(true, handler)\n}\n\nexport function skipRefreshing() {\n  if (isRefreshing()) {\n    throw new RefreshingSkipError()\n  }\n}\n"
+  ],
+  "mappings": ";;;;;AAAA;AAIA,IAAM,eAAe,IAAI;AAElB,SAAS,YAAY,GAAG;AAAA,EAC7B,OAAO,aAAa,SAAS,KAAK;AAAA;AAG7B,SAAS,cAAmC,CAAC,SAAY;AAAA,EAC9D,OAAO,aAAa,IAAI,MAAM,OAAO;AAAA;AAGhC,SAAS,cAAc,GAAG;AAAA,EAC/B,IAAI,aAAa,GAAG;AAAA,IAClB,MAAM,IAAI;AAAA,EACZ;AAAA;",
+  "debugId": "662B9CB5FCF319E264756E2164756E21",
+  "names": []
+}

package/dist/chunk-dgzw1nj9.js

@@ -0,0 +1,50 @@
+// src/redis/redisLock.ts
+var extendScript = `
+  if redis.call("get", KEYS[1]) == ARGV[1] then
+      return redis.call("pexpire", KEYS[1], ARGV[2])
+  else
+      return 0
+  end
+`;
+var deleteScript = `
+    if redis.call("get", KEYS[1]) == ARGV[1] then
+        return redis.call("del", KEYS[1])
+    else
+        return 0
+    end
+`;
+function redisLock(client, defaultTtl = 5000) {
+  return async (rawKey) => {
+    const key = Array.isArray(rawKey) ? rawKey.join(":") : rawKey;
+    const token = crypto.randomUUID();
+    while (true) {
+      const acquired = await client.set(key, token, "PX", defaultTtl, "NX");
+      if (acquired !== "OK") {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        continue;
+      }
+      let isReleased = false;
+      return {
+        async extend(ttl) {
+          const extended = await client.eval(extendScript, 1, key, token, ttl ?? defaultTtl / 2);
+          if (extended === 0) {
+            isReleased = true;
+            return false;
+          }
+          return true;
+        },
+        async release() {
+          if (isReleased) {
+            return;
+          }
+          isReleased = true;
+          await client.eval(deleteScript, 1, key, token);
+        }
+      };
+    }
+  };
+}
+
+export { redisLock };
+
+//# debugId=09C372830E540B2B64756E2164756E21

package/dist/chunk-dgzw1nj9.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/redis/redisLock.ts"],
+  "sourcesContent": [
+    "import type { Redis } from 'ioredis'\n\nimport type { LockCreator } from '../lock.ts'\n\nconst extendScript = `\n  if redis.call(\"get\", KEYS[1]) == ARGV[1] then\n      return redis.call(\"pexpire\", KEYS[1], ARGV[2])\n  else\n      return 0\n  end\n`\n\nconst deleteScript = `\n    if redis.call(\"get\", KEYS[1]) == ARGV[1] then\n        return redis.call(\"del\", KEYS[1])\n    else\n        return 0\n    end\n`\n\nexport function redisLock(client: Redis, defaultTtl = 5000): LockCreator {\n  return async (rawKey) => {\n    const key = Array.isArray(rawKey) ? rawKey.join(':') : rawKey\n    const token = crypto.randomUUID()\n\n    while (true) {\n      const acquired = await client.set(key, token, 'PX', defaultTtl, 'NX')\n\n      if (acquired !== 'OK') {\n        await new Promise((resolve) => setTimeout(resolve, 100))\n        continue\n      }\n\n      let isReleased = false\n      return {\n        async extend(ttl) {\n          const extended = await client.eval(\n            extendScript,\n            1,\n            key,\n            token,\n            ttl ?? defaultTtl / 2,\n          )\n          if (extended === 0) {\n            isReleased = true\n            return false\n          }\n          return true\n        },\n        async release() {\n          if (isReleased) {\n            return\n          }\n\n          isReleased = true\n          await client.eval(deleteScript, 1, key, token)\n        },\n      }\n    }\n  }\n}\n"
+  ],
+  "mappings": ";AAIA,IAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQrB,IAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQd,SAAS,SAAS,CAAC,QAAe,aAAa,MAAmB;AAAA,EACvE,OAAO,OAAO,WAAW;AAAA,IACvB,MAAM,MAAM,MAAM,QAAQ,MAAM,IAAI,OAAO,KAAK,GAAG,IAAI;AAAA,IACvD,MAAM,QAAQ,OAAO,WAAW;AAAA,IAEhC,OAAO,MAAM;AAAA,MACX,MAAM,WAAW,MAAM,OAAO,IAAI,KAAK,OAAO,MAAM,YAAY,IAAI;AAAA,MAEpE,IAAI,aAAa,MAAM;AAAA,QACrB,MAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG,CAAC;AAAA,QACvD;AAAA,MACF;AAAA,MAEA,IAAI,aAAa;AAAA,MACjB,OAAO;AAAA,aACC,OAAM,CAAC,KAAK;AAAA,UAChB,MAAM,WAAW,MAAM,OAAO,KAC5B,cACA,GACA,KACA,OACA,OAAO,aAAa,CACtB;AAAA,UACA,IAAI,aAAa,GAAG;AAAA,YAClB,aAAa;AAAA,YACb,OAAO;AAAA,UACT;AAAA,UACA,OAAO;AAAA;AAAA,aAEH,QAAO,GAAG;AAAA,UACd,IAAI,YAAY;AAAA,YACd;AAAA,UACF;AAAA,UAEA,aAAa;AAAA,UACb,MAAM,OAAO,KAAK,cAAc,GAAG,KAAK,KAAK;AAAA;AAAA,MAEjD;AAAA,IACF;AAAA;AAAA;",
+  "debugId": "09C372830E540B2B64756E2164756E21",
+  "names": []
+}

package/dist/chunk-gq80tgvf.js

@@ -0,0 +1,70 @@
+// src/transaction.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+async function awaitAll(getPromises) {
+  let promises = getPromises();
+  while (true) {
+    await Promise.all(promises);
+    const nextPromises = getPromises();
+    if (nextPromises.length > promises.length) {
+      promises = nextPromises;
+    } else {
+      break;
+    }
+  }
+}
+function createTransaction() {
+  const transactionStore = new AsyncLocalStorage;
+  return {
+    get active() {
+      return Boolean(transactionStore.getStore());
+    },
+    delay() {
+      const store = transactionStore.getStore();
+      if (!store) {
+        return {
+          resolve: () => {},
+          reject: () => {},
+          commit: () => Promise.resolve()
+        };
+      }
+      const idx = store.commitPromises.length;
+      const { resolve, reject, promise } = Promise.withResolvers();
+      store.delayPromises.push(promise);
+      const { promise: commitPromise, resolve: resolveCommitPromise } = Promise.withResolvers();
+      store.commitPromises.push(commitPromise);
+      return {
+        resolve,
+        reject,
+        async commit() {
+          if (idx > 0) {
+            await store.commitPromises.at(idx - 1);
+          }
+          resolveCommitPromise();
+          await awaitAll(() => store.delayPromises);
+        }
+      };
+    },
+    after(onAfter) {
+      transactionStore.getStore()?.afterHandlers.push(onAfter);
+    },
+    async run(handler) {
+      const { resolve, reject, promise } = Promise.withResolvers();
+      const delayPromises = [promise];
+      const afterHandlers = [];
+      let result;
+      try {
+        result = await transactionStore.run({ delayPromises, afterHandlers, commitPromises: [] }, handler);
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+      await awaitAll(() => delayPromises);
+      await Promise.all(afterHandlers.map((handler2) => handler2()));
+      return result;
+    }
+  };
+}
+
+export { createTransaction };
+
+//# debugId=75143A00A85F441C64756E2164756E21

package/dist/chunk-gq80tgvf.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/transaction.ts"],
+  "sourcesContent": [
+    "import { AsyncLocalStorage } from 'node:async_hooks'\n\nasync function awaitAll(getPromises: () => Promise<any>[]) {\n  let promises = getPromises()\n\n  while (true) {\n    await Promise.all(promises)\n    const nextPromises = getPromises()\n    if (nextPromises.length > promises.length) {\n      promises = nextPromises\n    } else {\n      break\n    }\n  }\n}\n\nexport type TransactionDelay = {\n  resolve: () => void\n  reject: (error: Error) => void\n  commit: () => Promise<void>\n}\n\nexport default function createTransaction() {\n  const transactionStore = new AsyncLocalStorage<{\n    delayPromises: Promise<void>[]\n    commitPromises: Promise<void>[]\n    afterHandlers: Array<() => Promise<any>>\n  }>()\n\n  return {\n    get active() {\n      return Boolean(transactionStore.getStore())\n    },\n\n    delay(): TransactionDelay {\n      const store = transactionStore.getStore()\n      if (!store) {\n        return {\n          resolve: () => {},\n          reject: () => {},\n          commit: () => Promise.resolve(),\n        }\n      }\n\n      const idx = store.commitPromises.length\n      const { resolve, reject, promise } = Promise.withResolvers<void>()\n      store.delayPromises.push(promise)\n\n      const { promise: commitPromise, resolve: resolveCommitPromise } =\n        Promise.withResolvers<void>()\n      store.commitPromises.push(commitPromise)\n\n      return {\n        resolve,\n        reject,\n        async commit() {\n          if (idx > 0) {\n            await store.commitPromises.at(idx - 1)\n          }\n\n          resolveCommitPromise()\n          await awaitAll(() => store.delayPromises)\n        },\n      }\n    },\n\n    after(onAfter: () => Promise<any>) {\n      transactionStore.getStore()?.afterHandlers.push(onAfter)\n    },\n\n    async run<T extends () => any>(handler: T) {\n      const { resolve, reject, promise } = Promise.withResolvers<void>()\n      const delayPromises = [promise]\n      const afterHandlers: Array<() => Promise<any>> = []\n      let result\n      try {\n        result = await transactionStore.run(\n          { delayPromises, afterHandlers, commitPromises: [] },\n          handler,\n        )\n        resolve()\n      } catch (error) {\n        reject(error)\n      }\n      await awaitAll(() => delayPromises)\n      await Promise.all(afterHandlers.map((handler) => handler()))\n\n      return result\n    },\n  }\n}\n\nexport type Transaction = ReturnType<typeof createTransaction>\n"
+  ],
+  "mappings": ";AAAA;AAEA,eAAe,QAAQ,CAAC,aAAmC;AAAA,EACzD,IAAI,WAAW,YAAY;AAAA,EAE3B,OAAO,MAAM;AAAA,IACX,MAAM,QAAQ,IAAI,QAAQ;AAAA,IAC1B,MAAM,eAAe,YAAY;AAAA,IACjC,IAAI,aAAa,SAAS,SAAS,QAAQ;AAAA,MACzC,WAAW;AAAA,IACb,EAAO;AAAA,MACL;AAAA;AAAA,EAEJ;AAAA;AASF,SAAwB,iBAAiB,GAAG;AAAA,EAC1C,MAAM,mBAAmB,IAAI;AAAA,EAM7B,OAAO;AAAA,QACD,MAAM,GAAG;AAAA,MACX,OAAO,QAAQ,iBAAiB,SAAS,CAAC;AAAA;AAAA,IAG5C,KAAK,GAAqB;AAAA,MACxB,MAAM,QAAQ,iBAAiB,SAAS;AAAA,MACxC,IAAI,CAAC,OAAO;AAAA,QACV,OAAO;AAAA,UACL,SAAS,MAAM;AAAA,UACf,QAAQ,MAAM;AAAA,UACd,QAAQ,MAAM,QAAQ,QAAQ;AAAA,QAChC;AAAA,MACF;AAAA,MAEA,MAAM,MAAM,MAAM,eAAe;AAAA,MACjC,QAAQ,SAAS,QAAQ,YAAY,QAAQ,cAAoB;AAAA,MACjE,MAAM,cAAc,KAAK,OAAO;AAAA,MAEhC,QAAQ,SAAS,eAAe,SAAS,yBACvC,QAAQ,cAAoB;AAAA,MAC9B,MAAM,eAAe,KAAK,aAAa;AAAA,MAEvC,OAAO;AAAA,QACL;AAAA,QACA;AAAA,aACM,OAAM,GAAG;AAAA,UACb,IAAI,MAAM,GAAG;AAAA,YACX,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAAA,UACvC;AAAA,UAEA,qBAAqB;AAAA,UACrB,MAAM,SAAS,MAAM,MAAM,aAAa;AAAA;AAAA,MAE5C;AAAA;AAAA,IAGF,KAAK,CAAC,SAA6B;AAAA,MACjC,iBAAiB,SAAS,GAAG,cAAc,KAAK,OAAO;AAAA;AAAA,SAGnD,IAAwB,CAAC,SAAY;AAAA,MACzC,QAAQ,SAAS,QAAQ,YAAY,QAAQ,cAAoB;AAAA,MACjE,MAAM,gBAAgB,CAAC,OAAO;AAAA,MAC9B,MAAM,gBAA2C,CAAC;AAAA,MAClD,IAAI;AAAA,MACJ,IAAI;AAAA,QACF,SAAS,MAAM,iBAAiB,IAC9B,EAAE,eAAe,eAAe,gBAAgB,CAAC,EAAE,GACnD,OACF;AAAA,QACA,QAAQ;AAAA,QACR,OAAO,OAAO;AAAA,QACd,OAAO,KAAK;AAAA;AAAA,MAEd,MAAM,SAAS,MAAM,aAAa;AAAA,MAClC,MAAM,QAAQ,IAAI,cAAc,IAAI,CAAC,aAAY,SAAQ,CAAC,CAAC;AAAA,MAE3D,OAAO;AAAA;AAAA,EAEX;AAAA;",
+  "debugId": "75143A00A85F441C64756E2164756E21",
+  "names": []
+}

package/dist/chunk-jd4q8fcf.js

@@ -0,0 +1,11 @@
+// src/index.ts
+function isStreamId(stream) {
+  return "id" in stream;
+}
+function isStreamEvents(stream) {
+  return "events" in stream && Array.isArray(stream.events);
+}
+
+export { isStreamId, isStreamEvents };
+
+//# debugId=EF89CA439C05547264756E2164756E21

package/dist/chunk-jd4q8fcf.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": [
+    "import type {\n  Stream,\n  StreamEvents,\n  StreamId,\n  StreamIdEvents,\n} from './utilityTypes.d.ts'\n\nexport { createEventStore } from './createEventStore.ts'\nexport type { BaseOutputEvent as Event } from './utilityTypes.d.ts'\nexport {\n  type Snapshot as ProjectionSnapshot,\n  isInsideProjection,\n  getProjectionInfo,\n} from './createProjection.ts'\nexport type { Checkpoint } from './createCheckpointApi.ts'\nexport {\n  isInsideProcessManager,\n  getProcessManagerInfo,\n} from './createProcessManager.ts'\nexport {\n  isInsideEventListener,\n  getEventListenerInfo,\n} from './createEventListener.ts'\nexport * from './errors.ts'\nexport {\n  type Snapshot as AggregateRootSnapshot,\n  type AnyAggregateRoot,\n  type AnyStream,\n  createAggregateRoot,\n} from './createAggregateRoot.ts'\n\nexport { skipRefreshing } from './refresh.ts'\nexport { skipReplay } from './replay.ts'\n\nexport function isStreamId(\n  stream: Stream,\n): stream is StreamId | StreamIdEvents {\n  return 'id' in stream\n}\nexport function isStreamEvents(\n  stream: Stream,\n): stream is StreamEvents | StreamIdEvents {\n  return 'events' in stream && Array.isArray(stream.events)\n}\nexport type { WrappedEvent } from './wrappedEventBuilder.ts'\n"
+  ],
+  "mappings": ";AAkCO,SAAS,UAAU,CACxB,QACqC;AAAA,EACrC,OAAO,QAAQ;AAAA;AAEV,SAAS,cAAc,CAC5B,QACyC;AAAA,EACzC,OAAO,YAAY,UAAU,MAAM,QAAQ,OAAO,MAAM;AAAA;",
+  "debugId": "EF89CA439C05547264756E2164756E21",
+  "names": []
+}

package/dist/chunk-m07vf8q9.js

@@ -0,0 +1,210 @@
+import {
+  clone
+} from "./chunk-6q8mr1sg.js";
+import {
+  createCheckpointApi
+} from "./chunk-zf3x573k.js";
+import {
+  isRefreshing,
+  withRefreshing
+} from "./chunk-9psg50cb.js";
+import {
+  ProcessManagerEventHandlerExecutionError,
+  RefreshingSkipError
+} from "./chunk-qdczt68t.js";
+
+// src/createProcessManager.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var processManagerInfoStore = new AsyncLocalStorage;
+function withProcessManagerInfo(info, handler) {
+  return processManagerInfoStore.run(info, handler);
+}
+function getProcessManagerInfo() {
+  return processManagerInfoStore.getStore();
+}
+function isInsideProcessManager() {
+  return Boolean(getProcessManagerInfo());
+}
+function buildProcessManagerCreator(params) {
+  return (name) => {
+    let idle = true;
+    let createEventHandlers = () => ({});
+    let createAfterEffects = () => ({});
+    let hasState = false;
+    let state = null;
+    let initialState = null;
+    let exclusive = true;
+    let generateRelatedStreamEvents;
+    let checkpointApi;
+    let lastEventPosition = -1;
+    const { promise: hydrated, resolve: resolveHydrated } = Promise.withResolvers();
+    const locks = new Map;
+    const apply = async (event, after, hydrating = false) => {
+      const handler = after ? createAfterEffects(state)[`after${event.type}`] : createEventHandlers(state)[`on${event.type}`];
+      if (!handler) {
+        return Promise.resolve();
+      }
+      if (hydrating) {
+        lastEventPosition = event.position;
+      } else {
+        await hydrated;
+        if (event.position <= lastEventPosition) {
+          return;
+        }
+      }
+      const unlocked = !exclusive ? Promise.resolve() : locks.get(event.streamId)?.catch(() => {}) ?? Promise.resolve();
+      const runner = (async () => {
+        await unlocked;
+        const refreshing = isRefreshing();
+        await withProcessManagerInfo({
+          name,
+          event
+        }, async () => {
+          try {
+            await handler(event, { refreshing });
+          } catch (error) {
+            if (error instanceof RefreshingSkipError) {
+              if (refreshing) {
+                return;
+              }
+              throw new Error("RefreshingSkipError should never be thrown outside refresh");
+            }
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            throw new ProcessManagerEventHandlerExecutionError(name, after ? `after${event.type}` : `on${event.type}`, event, error);
+          }
+        });
+        await checkpointApi.upsert(event, { state });
+      })();
+      if (exclusive) {
+        locks.set(event.streamId, runner);
+        runner.finally(() => {
+          if (locks.get(event.streamId) === runner) {
+            locks.delete(event.streamId);
+          }
+        }).catch(() => {});
+        return runner;
+      }
+      return Promise.resolve();
+    };
+    let resolveRefresh = null;
+    const api = {
+      name,
+      hasState() {
+        return hasState;
+      },
+      async isReady() {
+        await hydrated;
+      },
+      async apply(event) {
+        await apply(event, false);
+      },
+      async applyAfter(event) {
+        await apply(event, true);
+      },
+      withState(nextState) {
+        state = clone(nextState);
+        initialState = clone(nextState);
+        hasState = true;
+        return api;
+      },
+      concurrent() {
+        exclusive = false;
+        return api;
+      },
+      withEventHandlers(handlers) {
+        createEventHandlers = typeof handlers === "function" ? handlers : () => handlers;
+        return api;
+      },
+      withAfterEffects(handlers) {
+        createAfterEffects = typeof handlers === "function" ? handlers : () => handlers;
+        return api;
+      },
+      setRelatedStreamEvents(generate) {
+        generateRelatedStreamEvents = generate;
+      },
+      async beginRefresh() {
+        params.onRefresh?.begin?.(name);
+        await checkpointApi.clear();
+        lastEventPosition = -1;
+        state = initialState;
+      },
+      async progressRefresh(index, event, after) {
+        await apply(event, after, true);
+        if (!checkpointApi.relatedStreamEvents || checkpointApi.relatedStreamEvents.some((streamEvent) => streamEvent.events.includes(event.type))) {
+          params.onRefresh?.progress?.(name, index, event);
+        }
+      },
+      endRefresh() {
+        params.onRefresh?.end?.(name);
+        resolveHydrated();
+      },
+      async refreshState() {
+        if (!idle) {
+          await refresh();
+          return;
+        }
+        const { promise, resolve } = Promise.withResolvers();
+        resolveRefresh = resolve;
+        return promise;
+      },
+      async state() {
+        await hydrated;
+        return state;
+      },
+      async init(catchUp) {
+        idle = false;
+        const relatedStreamEvents = generateRelatedStreamEvents({
+          ...createEventHandlers(null),
+          ...createAfterEffects(null)
+        });
+        checkpointApi = createCheckpointApi({
+          ...params.checkpoint,
+          name,
+          relatedStreamEvents,
+          type: "processManager",
+          loadEvents: params.loadEvents,
+          apply: (event) => apply(event, false, true),
+          applyAfter: (event) => apply(event, true, true)
+        });
+        if (resolveRefresh) {
+          await refresh();
+          return;
+        }
+        if (!catchUp) {
+          return;
+        }
+        await checkpointApi.rehydrated({
+          getMetadata() {
+            return { state };
+          },
+          onMetadata(metadata) {
+            state = metadata.state ?? state;
+          }
+        });
+        resolveHydrated();
+      },
+      $inferState: null
+    };
+    async function refresh() {
+      await withRefreshing(async () => {
+        await api.beginRefresh();
+        await checkpointApi.rehydrated({
+          getMetadata() {
+            return { state };
+          },
+          onProgress(index, event) {
+            params.onRefresh?.progress?.(name, index, event);
+          }
+        });
+      });
+      api.endRefresh();
+    }
+    return api;
+  };
+}
+
+export { getProcessManagerInfo, isInsideProcessManager, buildProcessManagerCreator };
+
+//# debugId=F1319F7D0A1BF35E64756E2164756E21