@l-etabli/events 0.1.0

package/dist/createEventCrawler.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createEventCrawler_exports = {};
+__export(createEventCrawler_exports, {
+  createEventCrawler: () => createEventCrawler
+});
+module.exports = __toCommonJS(createEventCrawler_exports);
+const splitIntoChunks = (array, chunkSize) => {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+  return chunks;
+};
+const createEventCrawler = ({
+  withUow,
+  eventQueries,
+  eventBus,
+  options = {}
+}) => {
+  const batchSize = options.batchSize ?? 100;
+  const maxParallelProcessing = options.maxParallelProcessing ?? 1;
+  const newEventsIntervalMs = options.newEventsIntervalMs ?? 1e4;
+  const failedEventsIntervalMs = options.failedEventsIntervalMs ?? 6e4;
+  const publishEventsInParallel = async (events) => {
+    const eventChunks = splitIntoChunks(events, maxParallelProcessing);
+    for (const chunk of eventChunks) {
+      await Promise.all(chunk.map((event) => eventBus.publish(event)));
+    }
+  };
+  const processNewEvents = async () => {
+    const events = await eventQueries.getEvents({
+      filters: { statuses: ["never-published"] },
+      limit: batchSize
+    });
+    if (events.length === 0) return;
+    await withUow(async (uow) => {
+      await uow.eventRepository.markEventsAsInProcess(events);
+    });
+    await publishEventsInParallel(events);
+  };
+  const retryFailedEvents = async () => {
+    const events = await eventQueries.getEvents({
+      filters: { statuses: ["to-republish", "failed-but-will-retry"] },
+      limit: batchSize
+    });
+    if (events.length === 0) return;
+    await publishEventsInParallel(events);
+  };
+  const start = () => {
+    const scheduleProcessNewEvents = () => {
+      setTimeout(async () => {
+        try {
+          await processNewEvents();
+        } catch (error) {
+          console.error("Error processing new events:", error);
+        } finally {
+          scheduleProcessNewEvents();
+        }
+      }, newEventsIntervalMs);
+    };
+    const scheduleRetryFailedEvents = () => {
+      setTimeout(async () => {
+        try {
+          await retryFailedEvents();
+        } catch (error) {
+          console.error("Error retrying failed events:", error);
+        } finally {
+          scheduleRetryFailedEvents();
+        }
+      }, failedEventsIntervalMs);
+    };
+    scheduleProcessNewEvents();
+    scheduleRetryFailedEvents();
+  };
+  return {
+    processNewEvents,
+    retryFailedEvents,
+    start
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEventCrawler
+});
+//# sourceMappingURL=createEventCrawler.cjs.map

package/dist/createEventCrawler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createEventCrawler.ts"],"sourcesContent":["import type { EventBus } from \"./ports/EventBus.ts\";\nimport type { EventQueries } from \"./ports/EventQueries.ts\";\nimport type { WithEventsUow } from \"./ports/EventRepository.ts\";\nimport type { DefaultContext, GenericEvent } from \"./types.ts\";\n\n/** Configuration options for the event crawler. */\ntype CreateEventCrawlerOptions = {\n  /** Max events to fetch per batch (default: 100). */\n  batchSize?: number;\n  /** Max events to publish in parallel (default: 1). */\n  maxParallelProcessing?: number;\n  /** Interval for processing new events in ms (default: 10000). */\n  newEventsIntervalMs?: number;\n  /** Interval for retrying failed events in ms (default: 60000). */\n  failedEventsIntervalMs?: number;\n};\n\nconst splitIntoChunks = <T>(array: T[], chunkSize: number): T[][] => {\n  const chunks: T[][] = [];\n  for (let i = 0; i < array.length; i += chunkSize) {\n    chunks.push(array.slice(i, i + chunkSize));\n  }\n  return chunks;\n};\n\n/**\n * Creates a background event crawler that processes and publishes events.\n *\n * The crawler runs two loops:\n * 1. Process new events: polls for \"never-published\" events and publishes them\n * 2. Retry failed events: polls for failed events and retries them\n *\n * @returns Object with:\n * - `start()`: Start the background polling loops\n * - `processNewEvents()`: Manually trigger new event processing\n * - `retryFailedEvents()`: Manually trigger failed event retry\n *\n * @example\n * ```typescript\n * const crawler = createEventCrawler({\n *   withUow,\n *   eventQueries,\n *   eventBus,\n *   options: { batchSize: 50, newEventsIntervalMs: 5000 },\n * });\n *\n * // Start background processing\n * crawler.start();\n *\n * // Or trigger manually (useful for testing)\n * await crawler.processNewEvents();\n * ```\n */\nexport const createEventCrawler = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>({\n  withUow,\n  eventQueries,\n  eventBus,\n  options = {},\n}: {\n  withUow: WithEventsUow<Event>;\n  eventQueries: EventQueries<Event>;\n  eventBus: EventBus<Event>;\n  options?: CreateEventCrawlerOptions;\n}) => {\n  const batchSize = options.batchSize ?? 100;\n  const maxParallelProcessing = options.maxParallelProcessing ?? 1;\n  const newEventsIntervalMs = options.newEventsIntervalMs ?? 10_000;\n  const failedEventsIntervalMs = options.failedEventsIntervalMs ?? 60_000;\n\n  const publishEventsInParallel = async (events: Event[]) => {\n    const eventChunks = splitIntoChunks(events, maxParallelProcessing);\n    for (const chunk of eventChunks) {\n      await Promise.all(chunk.map((event) => eventBus.publish(event)));\n    }\n  };\n\n  const processNewEvents = async (): Promise<void> => {\n    const events = await eventQueries.getEvents({\n      filters: { statuses: [\"never-published\"] },\n      limit: batchSize,\n    });\n\n    if (events.length === 0) return;\n\n    await withUow(async (uow) => {\n      await uow.eventRepository.markEventsAsInProcess(events);\n    });\n\n    await publishEventsInParallel(events);\n  };\n\n  const retryFailedEvents = async (): Promise<void> => {\n    const events = await eventQueries.getEvents({\n      filters: { statuses: [\"to-republish\", \"failed-but-will-retry\"] },\n      limit: batchSize,\n    });\n\n    if (events.length === 0) return;\n\n    await publishEventsInParallel(events);\n  };\n\n  const start = () => {\n    const scheduleProcessNewEvents = () => {\n      setTimeout(async () => {\n        try {\n          await processNewEvents();\n        } catch (error) {\n          console.error(\"Error processing new events:\", error);\n        } finally {\n          scheduleProcessNewEvents();\n        }\n      }, newEventsIntervalMs);\n    };\n\n    const scheduleRetryFailedEvents = () => {\n      setTimeout(async () => {\n        try {\n          await retryFailedEvents();\n        } catch (error) {\n          console.error(\"Error retrying failed events:\", error);\n        } finally {\n          scheduleRetryFailedEvents();\n        }\n      }, failedEventsIntervalMs);\n    };\n\n    scheduleProcessNewEvents();\n    scheduleRetryFailedEvents();\n  };\n\n  return {\n    processNewEvents,\n    retryFailedEvents,\n    start,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,MAAM,kBAAkB,CAAI,OAAY,cAA6B;AACnE,QAAM,SAAgB,CAAC;AACvB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;AAChD,WAAO,KAAK,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;AAAA,EAC3C;AACA,SAAO;AACT;AA8BO,MAAM,qBAAqB,CAEhC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,UAAU,CAAC;AACb,MAKM;AACJ,QAAM,YAAY,QAAQ,aAAa;AACvC,QAAM,wBAAwB,QAAQ,yBAAyB;AAC/D,QAAM,sBAAsB,QAAQ,uBAAuB;AAC3D,QAAM,yBAAyB,QAAQ,0BAA0B;AAEjE,QAAM,0BAA0B,OAAO,WAAoB;AACzD,UAAM,cAAc,gBAAgB,QAAQ,qBAAqB;AACjE,eAAW,SAAS,aAAa;AAC/B,YAAM,QAAQ,IAAI,MAAM,IAAI,CAAC,UAAU,SAAS,QAAQ,KAAK,CAAC,CAAC;AAAA,IACjE;AAAA,EACF;AAEA,QAAM,mBAAmB,YAA2B;AAClD,UAAM,SAAS,MAAM,aAAa,UAAU;AAAA,MAC1C,SAAS,EAAE,UAAU,CAAC,iBAAiB,EAAE;AAAA,MACzC,OAAO;AAAA,IACT,CAAC;AAED,QAAI,OAAO,WAAW,EAAG;AAEzB,UAAM,QAAQ,OAAO,QAAQ;AAC3B,YAAM,IAAI,gBAAgB,sBAAsB,MAAM;AAAA,IACxD,CAAC;AAED,UAAM,wBAAwB,MAAM;AAAA,EACtC;AAEA,QAAM,oBAAoB,YAA2B;AACnD,UAAM,SAAS,MAAM,aAAa,UAAU;AAAA,MAC1C,SAAS,EAAE,UAAU,CAAC,gBAAgB,uBAAuB,EAAE;AAAA,MAC/D,OAAO;AAAA,IACT,CAAC;AAED,QAAI,OAAO,WAAW,EAAG;AAEzB,UAAM,wBAAwB,MAAM;AAAA,EACtC;AAEA,QAAM,QAAQ,MAAM;AAClB,UAAM,2BAA2B,MAAM;AACrC,iBAAW,YAAY;AACrB,YAAI;AACF,gBAAM,iBAAiB;AAAA,QACzB,SAAS,OAAO;AACd,kBAAQ,MAAM,gCAAgC,KAAK;AAAA,QACrD,UAAE;AACA,mCAAyB;AAAA,QAC3B;AAAA,MACF,GAAG,mBAAmB;AAAA,IACxB;AAEA,UAAM,4BAA4B,MAAM;AACtC,iBAAW,YAAY;AACrB,YAAI;AACF,gBAAM,kBAAkB;AAAA,QAC1B,SAAS,OAAO;AACd,kBAAQ,MAAM,iCAAiC,KAAK;AAAA,QACtD,UAAE;AACA,oCAA0B;AAAA,QAC5B;AAAA,MACF,GAAG,sBAAsB;AAAA,IAC3B;AAEA,6BAAyB;AACzB,8BAA0B;AAAA,EAC5B;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/createEventCrawler.d.cts

@@ -0,0 +1,56 @@
+import { EventBus } from './ports/EventBus.cjs';
+import { EventQueries } from './ports/EventQueries.cjs';
+import { WithEventsUow } from './ports/EventRepository.cjs';
+import { GenericEvent, DefaultContext } from './types.cjs';
+
+/** Configuration options for the event crawler. */
+type CreateEventCrawlerOptions = {
+    /** Max events to fetch per batch (default: 100). */
+    batchSize?: number;
+    /** Max events to publish in parallel (default: 1). */
+    maxParallelProcessing?: number;
+    /** Interval for processing new events in ms (default: 10000). */
+    newEventsIntervalMs?: number;
+    /** Interval for retrying failed events in ms (default: 60000). */
+    failedEventsIntervalMs?: number;
+};
+/**
+ * Creates a background event crawler that processes and publishes events.
+ *
+ * The crawler runs two loops:
+ * 1. Process new events: polls for "never-published" events and publishes them
+ * 2. Retry failed events: polls for failed events and retries them
+ *
+ * @returns Object with:
+ * - `start()`: Start the background polling loops
+ * - `processNewEvents()`: Manually trigger new event processing
+ * - `retryFailedEvents()`: Manually trigger failed event retry
+ *
+ * @example
+ * ```typescript
+ * const crawler = createEventCrawler({
+ *   withUow,
+ *   eventQueries,
+ *   eventBus,
+ *   options: { batchSize: 50, newEventsIntervalMs: 5000 },
+ * });
+ *
+ * // Start background processing
+ * crawler.start();
+ *
+ * // Or trigger manually (useful for testing)
+ * await crawler.processNewEvents();
+ * ```
+ */
+declare const createEventCrawler: <Event extends GenericEvent<string, unknown, DefaultContext>>({ withUow, eventQueries, eventBus, options, }: {
+    withUow: WithEventsUow<Event>;
+    eventQueries: EventQueries<Event>;
+    eventBus: EventBus<Event>;
+    options?: CreateEventCrawlerOptions;
+}) => {
+    processNewEvents: () => Promise<void>;
+    retryFailedEvents: () => Promise<void>;
+    start: () => void;
+};
+
+export { createEventCrawler };

package/dist/createEventCrawler.d.ts

@@ -0,0 +1,56 @@
+import { EventBus } from './ports/EventBus.js';
+import { EventQueries } from './ports/EventQueries.js';
+import { WithEventsUow } from './ports/EventRepository.js';
+import { GenericEvent, DefaultContext } from './types.js';
+
+/** Configuration options for the event crawler. */
+type CreateEventCrawlerOptions = {
+    /** Max events to fetch per batch (default: 100). */
+    batchSize?: number;
+    /** Max events to publish in parallel (default: 1). */
+    maxParallelProcessing?: number;
+    /** Interval for processing new events in ms (default: 10000). */
+    newEventsIntervalMs?: number;
+    /** Interval for retrying failed events in ms (default: 60000). */
+    failedEventsIntervalMs?: number;
+};
+/**
+ * Creates a background event crawler that processes and publishes events.
+ *
+ * The crawler runs two loops:
+ * 1. Process new events: polls for "never-published" events and publishes them
+ * 2. Retry failed events: polls for failed events and retries them
+ *
+ * @returns Object with:
+ * - `start()`: Start the background polling loops
+ * - `processNewEvents()`: Manually trigger new event processing
+ * - `retryFailedEvents()`: Manually trigger failed event retry
+ *
+ * @example
+ * ```typescript
+ * const crawler = createEventCrawler({
+ *   withUow,
+ *   eventQueries,
+ *   eventBus,
+ *   options: { batchSize: 50, newEventsIntervalMs: 5000 },
+ * });
+ *
+ * // Start background processing
+ * crawler.start();
+ *
+ * // Or trigger manually (useful for testing)
+ * await crawler.processNewEvents();
+ * ```
+ */
+declare const createEventCrawler: <Event extends GenericEvent<string, unknown, DefaultContext>>({ withUow, eventQueries, eventBus, options, }: {
+    withUow: WithEventsUow<Event>;
+    eventQueries: EventQueries<Event>;
+    eventBus: EventBus<Event>;
+    options?: CreateEventCrawlerOptions;
+}) => {
+    processNewEvents: () => Promise<void>;
+    retryFailedEvents: () => Promise<void>;
+    start: () => void;
+};
+
+export { createEventCrawler };

package/dist/createEventCrawler.mjs

@@ -0,0 +1,78 @@
+const splitIntoChunks = (array, chunkSize) => {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+  return chunks;
+};
+const createEventCrawler = ({
+  withUow,
+  eventQueries,
+  eventBus,
+  options = {}
+}) => {
+  const batchSize = options.batchSize ?? 100;
+  const maxParallelProcessing = options.maxParallelProcessing ?? 1;
+  const newEventsIntervalMs = options.newEventsIntervalMs ?? 1e4;
+  const failedEventsIntervalMs = options.failedEventsIntervalMs ?? 6e4;
+  const publishEventsInParallel = async (events) => {
+    const eventChunks = splitIntoChunks(events, maxParallelProcessing);
+    for (const chunk of eventChunks) {
+      await Promise.all(chunk.map((event) => eventBus.publish(event)));
+    }
+  };
+  const processNewEvents = async () => {
+    const events = await eventQueries.getEvents({
+      filters: { statuses: ["never-published"] },
+      limit: batchSize
+    });
+    if (events.length === 0) return;
+    await withUow(async (uow) => {
+      await uow.eventRepository.markEventsAsInProcess(events);
+    });
+    await publishEventsInParallel(events);
+  };
+  const retryFailedEvents = async () => {
+    const events = await eventQueries.getEvents({
+      filters: { statuses: ["to-republish", "failed-but-will-retry"] },
+      limit: batchSize
+    });
+    if (events.length === 0) return;
+    await publishEventsInParallel(events);
+  };
+  const start = () => {
+    const scheduleProcessNewEvents = () => {
+      setTimeout(async () => {
+        try {
+          await processNewEvents();
+        } catch (error) {
+          console.error("Error processing new events:", error);
+        } finally {
+          scheduleProcessNewEvents();
+        }
+      }, newEventsIntervalMs);
+    };
+    const scheduleRetryFailedEvents = () => {
+      setTimeout(async () => {
+        try {
+          await retryFailedEvents();
+        } catch (error) {
+          console.error("Error retrying failed events:", error);
+        } finally {
+          scheduleRetryFailedEvents();
+        }
+      }, failedEventsIntervalMs);
+    };
+    scheduleProcessNewEvents();
+    scheduleRetryFailedEvents();
+  };
+  return {
+    processNewEvents,
+    retryFailedEvents,
+    start
+  };
+};
+export {
+  createEventCrawler
+};
+//# sourceMappingURL=createEventCrawler.mjs.map

package/dist/createEventCrawler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createEventCrawler.ts"],"sourcesContent":["import type { EventBus } from './ports/EventBus.ts.mjs';\nimport type { EventQueries } from './ports/EventQueries.ts.mjs';\nimport type { WithEventsUow } from './ports/EventRepository.ts.mjs';\nimport type { DefaultContext, GenericEvent } from './types.ts.mjs';\n\n/** Configuration options for the event crawler. */\ntype CreateEventCrawlerOptions = {\n  /** Max events to fetch per batch (default: 100). */\n  batchSize?: number;\n  /** Max events to publish in parallel (default: 1). */\n  maxParallelProcessing?: number;\n  /** Interval for processing new events in ms (default: 10000). */\n  newEventsIntervalMs?: number;\n  /** Interval for retrying failed events in ms (default: 60000). */\n  failedEventsIntervalMs?: number;\n};\n\nconst splitIntoChunks = <T>(array: T[], chunkSize: number): T[][] => {\n  const chunks: T[][] = [];\n  for (let i = 0; i < array.length; i += chunkSize) {\n    chunks.push(array.slice(i, i + chunkSize));\n  }\n  return chunks;\n};\n\n/**\n * Creates a background event crawler that processes and publishes events.\n *\n * The crawler runs two loops:\n * 1. Process new events: polls for \"never-published\" events and publishes them\n * 2. Retry failed events: polls for failed events and retries them\n *\n * @returns Object with:\n * - `start()`: Start the background polling loops\n * - `processNewEvents()`: Manually trigger new event processing\n * - `retryFailedEvents()`: Manually trigger failed event retry\n *\n * @example\n * ```typescript\n * const crawler = createEventCrawler({\n *   withUow,\n *   eventQueries,\n *   eventBus,\n *   options: { batchSize: 50, newEventsIntervalMs: 5000 },\n * });\n *\n * // Start background processing\n * crawler.start();\n *\n * // Or trigger manually (useful for testing)\n * await crawler.processNewEvents();\n * ```\n */\nexport const createEventCrawler = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>({\n  withUow,\n  eventQueries,\n  eventBus,\n  options = {},\n}: {\n  withUow: WithEventsUow<Event>;\n  eventQueries: EventQueries<Event>;\n  eventBus: EventBus<Event>;\n  options?: CreateEventCrawlerOptions;\n}) => {\n  const batchSize = options.batchSize ?? 100;\n  const maxParallelProcessing = options.maxParallelProcessing ?? 1;\n  const newEventsIntervalMs = options.newEventsIntervalMs ?? 10_000;\n  const failedEventsIntervalMs = options.failedEventsIntervalMs ?? 60_000;\n\n  const publishEventsInParallel = async (events: Event[]) => {\n    const eventChunks = splitIntoChunks(events, maxParallelProcessing);\n    for (const chunk of eventChunks) {\n      await Promise.all(chunk.map((event) => eventBus.publish(event)));\n    }\n  };\n\n  const processNewEvents = async (): Promise<void> => {\n    const events = await eventQueries.getEvents({\n      filters: { statuses: [\"never-published\"] },\n      limit: batchSize,\n    });\n\n    if (events.length === 0) return;\n\n    await withUow(async (uow) => {\n      await uow.eventRepository.markEventsAsInProcess(events);\n    });\n\n    await publishEventsInParallel(events);\n  };\n\n  const retryFailedEvents = async (): Promise<void> => {\n    const events = await eventQueries.getEvents({\n      filters: { statuses: [\"to-republish\", \"failed-but-will-retry\"] },\n      limit: batchSize,\n    });\n\n    if (events.length === 0) return;\n\n    await publishEventsInParallel(events);\n  };\n\n  const start = () => {\n    const scheduleProcessNewEvents = () => {\n      setTimeout(async () => {\n        try {\n          await processNewEvents();\n        } catch (error) {\n          console.error(\"Error processing new events:\", error);\n        } finally {\n          scheduleProcessNewEvents();\n        }\n      }, newEventsIntervalMs);\n    };\n\n    const scheduleRetryFailedEvents = () => {\n      setTimeout(async () => {\n        try {\n          await retryFailedEvents();\n        } catch (error) {\n          console.error(\"Error retrying failed events:\", error);\n        } finally {\n          scheduleRetryFailedEvents();\n        }\n      }, failedEventsIntervalMs);\n    };\n\n    scheduleProcessNewEvents();\n    scheduleRetryFailedEvents();\n  };\n\n  return {\n    processNewEvents,\n    retryFailedEvents,\n    start,\n  };\n};\n"],"mappings":"AAiBA,MAAM,kBAAkB,CAAI,OAAY,cAA6B;AACnE,QAAM,SAAgB,CAAC;AACvB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;AAChD,WAAO,KAAK,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;AAAA,EAC3C;AACA,SAAO;AACT;AA8BO,MAAM,qBAAqB,CAEhC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,UAAU,CAAC;AACb,MAKM;AACJ,QAAM,YAAY,QAAQ,aAAa;AACvC,QAAM,wBAAwB,QAAQ,yBAAyB;AAC/D,QAAM,sBAAsB,QAAQ,uBAAuB;AAC3D,QAAM,yBAAyB,QAAQ,0BAA0B;AAEjE,QAAM,0BAA0B,OAAO,WAAoB;AACzD,UAAM,cAAc,gBAAgB,QAAQ,qBAAqB;AACjE,eAAW,SAAS,aAAa;AAC/B,YAAM,QAAQ,IAAI,MAAM,IAAI,CAAC,UAAU,SAAS,QAAQ,KAAK,CAAC,CAAC;AAAA,IACjE;AAAA,EACF;AAEA,QAAM,mBAAmB,YAA2B;AAClD,UAAM,SAAS,MAAM,aAAa,UAAU;AAAA,MAC1C,SAAS,EAAE,UAAU,CAAC,iBAAiB,EAAE;AAAA,MACzC,OAAO;AAAA,IACT,CAAC;AAED,QAAI,OAAO,WAAW,EAAG;AAEzB,UAAM,QAAQ,OAAO,QAAQ;AAC3B,YAAM,IAAI,gBAAgB,sBAAsB,MAAM;AAAA,IACxD,CAAC;AAED,UAAM,wBAAwB,MAAM;AAAA,EACtC;AAEA,QAAM,oBAAoB,YAA2B;AACnD,UAAM,SAAS,MAAM,aAAa,UAAU;AAAA,MAC1C,SAAS,EAAE,UAAU,CAAC,gBAAgB,uBAAuB,EAAE;AAAA,MAC/D,OAAO;AAAA,IACT,CAAC;AAED,QAAI,OAAO,WAAW,EAAG;AAEzB,UAAM,wBAAwB,MAAM;AAAA,EACtC;AAEA,QAAM,QAAQ,MAAM;AAClB,UAAM,2BAA2B,MAAM;AACrC,iBAAW,YAAY;AACrB,YAAI;AACF,gBAAM,iBAAiB;AAAA,QACzB,SAAS,OAAO;AACd,kBAAQ,MAAM,gCAAgC,KAAK;AAAA,QACrD,UAAE;AACA,mCAAyB;AAAA,QAC3B;AAAA,MACF,GAAG,mBAAmB;AAAA,IACxB;AAEA,UAAM,4BAA4B,MAAM;AACtC,iBAAW,YAAY;AACrB,YAAI;AACF,gBAAM,kBAAkB;AAAA,QAC1B,SAAS,OAAO;AACd,kBAAQ,MAAM,iCAAiC,KAAK;AAAA,QACtD,UAAE;AACA,oCAA0B;AAAA,QAC5B;AAAA,MACF,GAAG,sBAAsB;AAAA,IAC3B;AAEA,6BAAyB;AACzB,8BAA0B;AAAA,EAC5B;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/createNewEvent.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createNewEvent_exports = {};
+__export(createNewEvent_exports, {
+  makeCreateNewEvent: () => makeCreateNewEvent
+});
+module.exports = __toCommonJS(createNewEvent_exports);
+const makeCreateNewEvent = (options = {}) => {
+  const getNow = options.getNow ?? (() => /* @__PURE__ */ new Date());
+  const generateId = options.generateId ?? (() => crypto.randomUUID());
+  return (params) => ({
+    id: params.id ?? generateId(),
+    topic: params.topic,
+    payload: params.payload,
+    triggeredByUserId: params.triggeredByUserId,
+    occurredAt: params.occurredAt ?? getNow(),
+    status: "never-published",
+    publications: [],
+    priority: params.priority,
+    context: params.context
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeCreateNewEvent
+});
+//# sourceMappingURL=createNewEvent.cjs.map

package/dist/createNewEvent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createNewEvent.ts"],"sourcesContent":["import type { DefaultContext, EventId, GenericEvent, UserId } from \"./types.ts\";\n\ntype MakeCreateNewEventOptions = {\n  getNow?: () => Date;\n  generateId?: () => EventId;\n};\n\ntype ContextParam<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n  Topic extends Event[\"topic\"],\n> = Extract<Event, { topic: Topic }>[\"context\"] extends undefined\n  ? { context?: undefined }\n  : { context: Extract<Event, { topic: Topic }>[\"context\"] };\n\ntype CreateNewEventParams<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n  Topic extends Event[\"topic\"],\n> = {\n  topic: Topic;\n  payload: Extract<Event, { topic: Topic }>[\"payload\"];\n  triggeredByUserId: UserId;\n  id?: EventId;\n  occurredAt?: Date;\n  priority?: number;\n} & ContextParam<Event, Topic>;\n\n/**\n * Creates a typed event creator factory for your event union.\n * Provides type-safe event creation where topic constrains payload type.\n *\n * @param options.getNow - Function to get current time (default: `() => new Date()`)\n * @param options.generateId - Function to generate event IDs (default: `() => crypto.randomUUID()`)\n *\n * @example\n * ```typescript\n * type MyEvents =\n *   | GenericEvent<\"UserCreated\", { email: string }>\n *   | GenericEvent<\"OrderPlaced\", { orderId: string }>;\n *\n * // Standalone usage:\n * const createEvent = makeCreateNewEvent<MyEvents>();\n *\n * // Or get it from createInMemoryEventBus (recommended):\n * const { eventBus, createEvent } = createInMemoryEventBus<MyEvents>(withUow);\n *\n * // Type-safe: payload must match topic\n * createEvent({ topic: \"UserCreated\", payload: { email: \"a@b.com\" }, triggeredByUserId: \"u1\" }); // OK\n * createEvent({ topic: \"UserCreated\", payload: { orderId: \"123\" }, triggeredByUserId: \"u1\" }); // Error!\n *\n * // For testing, inject deterministic functions:\n * const createEvent = makeCreateNewEvent<MyEvents>({\n *   getNow: () => new Date(\"2024-01-01\"),\n *   generateId: () => \"test-id\",\n * });\n * ```\n */\n\nexport type CreateNewEvent<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = <Topic extends Event[\"topic\"]>(\n  params: CreateNewEventParams<Event, Topic>,\n) => Extract<Event, { topic: Topic }>;\n\nexport const makeCreateNewEvent = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  options: MakeCreateNewEventOptions = {},\n): CreateNewEvent<Event> => {\n  const getNow = options.getNow ?? (() => new Date());\n  const generateId =\n    options.generateId ?? (() => crypto.randomUUID() as EventId);\n\n  return <Topic extends Event[\"topic\"]>(\n    params: CreateNewEventParams<Event, Topic>,\n  ): Extract<Event, { topic: Topic }> =>\n    ({\n      id: params.id ?? generateId(),\n      topic: params.topic,\n      payload: params.payload,\n      triggeredByUserId: params.triggeredByUserId,\n      occurredAt: params.occurredAt ?? getNow(),\n      status: \"never-published\",\n      publications: [],\n      priority: params.priority,\n      context: params.context,\n    }) as unknown as Extract<Event, { topic: Topic }>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+DO,MAAM,qBAAqB,CAGhC,UAAqC,CAAC,MACZ;AAC1B,QAAM,SAAS,QAAQ,WAAW,MAAM,oBAAI,KAAK;AACjD,QAAM,aACJ,QAAQ,eAAe,MAAM,OAAO,WAAW;AAEjD,SAAO,CACL,YAEC;AAAA,IACC,IAAI,OAAO,MAAM,WAAW;AAAA,IAC5B,OAAO,OAAO;AAAA,IACd,SAAS,OAAO;AAAA,IAChB,mBAAmB,OAAO;AAAA,IAC1B,YAAY,OAAO,cAAc,OAAO;AAAA,IACxC,QAAQ;AAAA,IACR,cAAc,CAAC;AAAA,IACf,UAAU,OAAO;AAAA,IACjB,SAAS,OAAO;AAAA,EAClB;AACJ;","names":[]}

package/dist/createNewEvent.d.cts

@@ -0,0 +1,61 @@
+import { GenericEvent, DefaultContext, UserId, EventId } from './types.cjs';
+
+type MakeCreateNewEventOptions = {
+    getNow?: () => Date;
+    generateId?: () => EventId;
+};
+type ContextParam<Event extends GenericEvent<string, unknown, DefaultContext>, Topic extends Event["topic"]> = Extract<Event, {
+    topic: Topic;
+}>["context"] extends undefined ? {
+    context?: undefined;
+} : {
+    context: Extract<Event, {
+        topic: Topic;
+    }>["context"];
+};
+type CreateNewEventParams<Event extends GenericEvent<string, unknown, DefaultContext>, Topic extends Event["topic"]> = {
+    topic: Topic;
+    payload: Extract<Event, {
+        topic: Topic;
+    }>["payload"];
+    triggeredByUserId: UserId;
+    id?: EventId;
+    occurredAt?: Date;
+    priority?: number;
+} & ContextParam<Event, Topic>;
+/**
+ * Creates a typed event creator factory for your event union.
+ * Provides type-safe event creation where topic constrains payload type.
+ *
+ * @param options.getNow - Function to get current time (default: `() => new Date()`)
+ * @param options.generateId - Function to generate event IDs (default: `() => crypto.randomUUID()`)
+ *
+ * @example
+ * ```typescript
+ * type MyEvents =
+ *   | GenericEvent<"UserCreated", { email: string }>
+ *   | GenericEvent<"OrderPlaced", { orderId: string }>;
+ *
+ * // Standalone usage:
+ * const createEvent = makeCreateNewEvent<MyEvents>();
+ *
+ * // Or get it from createInMemoryEventBus (recommended):
+ * const { eventBus, createEvent } = createInMemoryEventBus<MyEvents>(withUow);
+ *
+ * // Type-safe: payload must match topic
+ * createEvent({ topic: "UserCreated", payload: { email: "a@b.com" }, triggeredByUserId: "u1" }); // OK
+ * createEvent({ topic: "UserCreated", payload: { orderId: "123" }, triggeredByUserId: "u1" }); // Error!
+ *
+ * // For testing, inject deterministic functions:
+ * const createEvent = makeCreateNewEvent<MyEvents>({
+ *   getNow: () => new Date("2024-01-01"),
+ *   generateId: () => "test-id",
+ * });
+ * ```
+ */
+type CreateNewEvent<Event extends GenericEvent<string, unknown, DefaultContext>> = <Topic extends Event["topic"]>(params: CreateNewEventParams<Event, Topic>) => Extract<Event, {
+    topic: Topic;
+}>;
+declare const makeCreateNewEvent: <Event extends GenericEvent<string, unknown, DefaultContext>>(options?: MakeCreateNewEventOptions) => CreateNewEvent<Event>;
+
+export { type CreateNewEvent, makeCreateNewEvent };

package/dist/createNewEvent.d.ts

@@ -0,0 +1,61 @@
+import { GenericEvent, DefaultContext, UserId, EventId } from './types.js';
+
+type MakeCreateNewEventOptions = {
+    getNow?: () => Date;
+    generateId?: () => EventId;
+};
+type ContextParam<Event extends GenericEvent<string, unknown, DefaultContext>, Topic extends Event["topic"]> = Extract<Event, {
+    topic: Topic;
+}>["context"] extends undefined ? {
+    context?: undefined;
+} : {
+    context: Extract<Event, {
+        topic: Topic;
+    }>["context"];
+};
+type CreateNewEventParams<Event extends GenericEvent<string, unknown, DefaultContext>, Topic extends Event["topic"]> = {
+    topic: Topic;
+    payload: Extract<Event, {
+        topic: Topic;
+    }>["payload"];
+    triggeredByUserId: UserId;
+    id?: EventId;
+    occurredAt?: Date;
+    priority?: number;
+} & ContextParam<Event, Topic>;
+/**
+ * Creates a typed event creator factory for your event union.
+ * Provides type-safe event creation where topic constrains payload type.
+ *
+ * @param options.getNow - Function to get current time (default: `() => new Date()`)
+ * @param options.generateId - Function to generate event IDs (default: `() => crypto.randomUUID()`)
+ *
+ * @example
+ * ```typescript
+ * type MyEvents =
+ *   | GenericEvent<"UserCreated", { email: string }>
+ *   | GenericEvent<"OrderPlaced", { orderId: string }>;
+ *
+ * // Standalone usage:
+ * const createEvent = makeCreateNewEvent<MyEvents>();
+ *
+ * // Or get it from createInMemoryEventBus (recommended):
+ * const { eventBus, createEvent } = createInMemoryEventBus<MyEvents>(withUow);
+ *
+ * // Type-safe: payload must match topic
+ * createEvent({ topic: "UserCreated", payload: { email: "a@b.com" }, triggeredByUserId: "u1" }); // OK
+ * createEvent({ topic: "UserCreated", payload: { orderId: "123" }, triggeredByUserId: "u1" }); // Error!
+ *
+ * // For testing, inject deterministic functions:
+ * const createEvent = makeCreateNewEvent<MyEvents>({
+ *   getNow: () => new Date("2024-01-01"),
+ *   generateId: () => "test-id",
+ * });
+ * ```
+ */
+type CreateNewEvent<Event extends GenericEvent<string, unknown, DefaultContext>> = <Topic extends Event["topic"]>(params: CreateNewEventParams<Event, Topic>) => Extract<Event, {
+    topic: Topic;
+}>;
+declare const makeCreateNewEvent: <Event extends GenericEvent<string, unknown, DefaultContext>>(options?: MakeCreateNewEventOptions) => CreateNewEvent<Event>;
+
+export { type CreateNewEvent, makeCreateNewEvent };

package/dist/createNewEvent.mjs

@@ -0,0 +1,19 @@
+const makeCreateNewEvent = (options = {}) => {
+  const getNow = options.getNow ?? (() => /* @__PURE__ */ new Date());
+  const generateId = options.generateId ?? (() => crypto.randomUUID());
+  return (params) => ({
+    id: params.id ?? generateId(),
+    topic: params.topic,
+    payload: params.payload,
+    triggeredByUserId: params.triggeredByUserId,
+    occurredAt: params.occurredAt ?? getNow(),
+    status: "never-published",
+    publications: [],
+    priority: params.priority,
+    context: params.context
+  });
+};
+export {
+  makeCreateNewEvent
+};
+//# sourceMappingURL=createNewEvent.mjs.map

package/dist/createNewEvent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createNewEvent.ts"],"sourcesContent":["import type { DefaultContext, EventId, GenericEvent, UserId } from './types.ts.mjs';\n\ntype MakeCreateNewEventOptions = {\n  getNow?: () => Date;\n  generateId?: () => EventId;\n};\n\ntype ContextParam<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n  Topic extends Event[\"topic\"],\n> = Extract<Event, { topic: Topic }>[\"context\"] extends undefined\n  ? { context?: undefined }\n  : { context: Extract<Event, { topic: Topic }>[\"context\"] };\n\ntype CreateNewEventParams<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n  Topic extends Event[\"topic\"],\n> = {\n  topic: Topic;\n  payload: Extract<Event, { topic: Topic }>[\"payload\"];\n  triggeredByUserId: UserId;\n  id?: EventId;\n  occurredAt?: Date;\n  priority?: number;\n} & ContextParam<Event, Topic>;\n\n/**\n * Creates a typed event creator factory for your event union.\n * Provides type-safe event creation where topic constrains payload type.\n *\n * @param options.getNow - Function to get current time (default: `() => new Date()`)\n * @param options.generateId - Function to generate event IDs (default: `() => crypto.randomUUID()`)\n *\n * @example\n * ```typescript\n * type MyEvents =\n *   | GenericEvent<\"UserCreated\", { email: string }>\n *   | GenericEvent<\"OrderPlaced\", { orderId: string }>;\n *\n * // Standalone usage:\n * const createEvent = makeCreateNewEvent<MyEvents>();\n *\n * // Or get it from createInMemoryEventBus (recommended):\n * const { eventBus, createEvent } = createInMemoryEventBus<MyEvents>(withUow);\n *\n * // Type-safe: payload must match topic\n * createEvent({ topic: \"UserCreated\", payload: { email: \"a@b.com\" }, triggeredByUserId: \"u1\" }); // OK\n * createEvent({ topic: \"UserCreated\", payload: { orderId: \"123\" }, triggeredByUserId: \"u1\" }); // Error!\n *\n * // For testing, inject deterministic functions:\n * const createEvent = makeCreateNewEvent<MyEvents>({\n *   getNow: () => new Date(\"2024-01-01\"),\n *   generateId: () => \"test-id\",\n * });\n * ```\n */\n\nexport type CreateNewEvent<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = <Topic extends Event[\"topic\"]>(\n  params: CreateNewEventParams<Event, Topic>,\n) => Extract<Event, { topic: Topic }>;\n\nexport const makeCreateNewEvent = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  options: MakeCreateNewEventOptions = {},\n): CreateNewEvent<Event> => {\n  const getNow = options.getNow ?? (() => new Date());\n  const generateId =\n    options.generateId ?? (() => crypto.randomUUID() as EventId);\n\n  return <Topic extends Event[\"topic\"]>(\n    params: CreateNewEventParams<Event, Topic>,\n  ): Extract<Event, { topic: Topic }> =>\n    ({\n      id: params.id ?? generateId(),\n      topic: params.topic,\n      payload: params.payload,\n      triggeredByUserId: params.triggeredByUserId,\n      occurredAt: params.occurredAt ?? getNow(),\n      status: \"never-published\",\n      publications: [],\n      priority: params.priority,\n      context: params.context,\n    }) as unknown as Extract<Event, { topic: Topic }>;\n};\n"],"mappings":"AA+DO,MAAM,qBAAqB,CAGhC,UAAqC,CAAC,MACZ;AAC1B,QAAM,SAAS,QAAQ,WAAW,MAAM,oBAAI,KAAK;AACjD,QAAM,aACJ,QAAQ,eAAe,MAAM,OAAO,WAAW;AAEjD,SAAO,CACL,YAEC;AAAA,IACC,IAAI,OAAO,MAAM,WAAW;AAAA,IAC5B,OAAO,OAAO;AAAA,IACd,SAAS,OAAO;AAAA,IAChB,mBAAmB,OAAO;AAAA,IAC1B,YAAY,OAAO,cAAc,OAAO;AAAA,IACxC,QAAQ;AAAA,IACR,cAAc,CAAC;AAAA,IACf,UAAU,OAAO;AAAA,IACjB,SAAS,OAAO;AAAA,EAClB;AACJ;","names":[]}

package/dist/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./adapters/in-memory/index.ts"), module.exports);
+__reExport(index_exports, require("./createEventCrawler.ts"), module.exports);
+__reExport(index_exports, require("./createNewEvent.ts"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./adapters/in-memory/index.ts"),
+  ...require("./createEventCrawler.ts"),
+  ...require("./createNewEvent.ts")
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from \"./adapters/in-memory/index.ts\";\nexport * from \"./createEventCrawler.ts\";\nexport * from \"./createNewEvent.ts\";\nexport type * from \"./ports/EventBus.ts\";\nexport type * from \"./ports/EventQueries.ts\";\nexport type * from \"./ports/EventRepository.ts\";\nexport type * from \"./types.ts\";\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,0CAAd;AACA,0BAAc,oCADd;AAEA,0BAAc,gCAFd;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+export { createInMemoryEventRepositoryAndQueries } from './adapters/in-memory/index.cjs';
+export { createEventCrawler } from './createEventCrawler.cjs';
+export { CreateNewEvent, makeCreateNewEvent } from './createNewEvent.cjs';
+export { EventBus } from './ports/EventBus.cjs';
+export { EventQueries } from './ports/EventQueries.cjs';
+export { EventRepository, EventsUnitOfWork, WithEventsUow } from './ports/EventRepository.cjs';
+export { DefaultContext, EventFailure, EventId, EventPublication, EventStatus, Flavor, GenericEvent, SubscriptionId, UserId } from './types.cjs';
+export { createInMemoryEventBus } from './adapters/in-memory/InMemoryEventBus.cjs';
+export { createInMemoryEventQueries } from './adapters/in-memory/InMemoryEventQueries.cjs';
+export { InMemoryEventRepositoryHelpers, createInMemoryEventRepository, createInMemoryWithUow } from './adapters/in-memory/InMemoryEventRepository.cjs';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createInMemoryEventRepositoryAndQueries } from './adapters/in-memory/index.js';
+export { createEventCrawler } from './createEventCrawler.js';
+export { CreateNewEvent, makeCreateNewEvent } from './createNewEvent.js';
+export { EventBus } from './ports/EventBus.js';
+export { EventQueries } from './ports/EventQueries.js';
+export { EventRepository, EventsUnitOfWork, WithEventsUow } from './ports/EventRepository.js';
+export { DefaultContext, EventFailure, EventId, EventPublication, EventStatus, Flavor, GenericEvent, SubscriptionId, UserId } from './types.js';
+export { createInMemoryEventBus } from './adapters/in-memory/InMemoryEventBus.js';
+export { createInMemoryEventQueries } from './adapters/in-memory/InMemoryEventQueries.js';
+export { InMemoryEventRepositoryHelpers, createInMemoryEventRepository, createInMemoryWithUow } from './adapters/in-memory/InMemoryEventRepository.js';

package/dist/index.mjs

@@ -0,0 +1,4 @@
+export * from "./adapters/in-memory/index.ts.mjs";
+export * from "./createEventCrawler.ts.mjs";
+export * from "./createNewEvent.ts.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './adapters/in-memory/index.ts.mjs';\nexport * from './createEventCrawler.ts.mjs';\nexport * from './createNewEvent.ts.mjs';\nexport type * from './ports/EventBus.ts.mjs';\nexport type * from './ports/EventQueries.ts.mjs';\nexport type * from './ports/EventRepository.ts.mjs';\nexport type * from './types.ts.mjs';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/ports/EventBus.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EventBus_exports = {};
+module.exports = __toCommonJS(EventBus_exports);
+//# sourceMappingURL=EventBus.cjs.map

package/dist/ports/EventBus.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ports/EventBus.ts"],"sourcesContent":["import type { DefaultContext, GenericEvent, SubscriptionId } from \"../types.ts\";\n\n/**\n * Event bus for publishing events to subscribers.\n * Handles delivery, failure tracking, and retry logic.\n *\n * @example\n * ```typescript\n * eventBus.subscribe({\n *   topic: \"OrderPlaced\",\n *   subscriptionId: \"send-confirmation-email\",\n *   callBack: async (event) => {\n *     await emailService.sendOrderConfirmation(event.payload);\n *   },\n * });\n * ```\n */\nexport type EventBus<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  /**\n   * Publish an event to all subscribers of its topic.\n   * Updates event status and records publication results.\n   */\n  publish: (event: Event) => Promise<void>;\n  /**\n   * Register a subscriber for a specific topic.\n   * The subscriptionId must be unique per topic and is used for retry tracking.\n   */\n  subscribe: <\n    Event extends GenericEvent<string, unknown, DefaultContext>,\n  >(params: {\n    topic: Event[\"topic\"];\n    subscriptionId: SubscriptionId;\n    callBack: (e: Event) => Promise<void>;\n  }) => void;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}