@l-etabli/events 0.5.0 → 0.6.0

package/README.md

@@ -1,44 +1,80 @@
 # @l-etabli/events
 
-Event-driven architecture library implementing the **outbox pattern** for TypeScript.
+TypeScript library for event-driven architecture with the **outbox pattern**.
 
-Events are persisted in the same transaction as your domain changes, then reliably published asynchronously. No lost events, even on failures.
+Events are persisted in the same transaction as your domain changes, then published asynchronously with retry support.
 
 ## Installation
 
 ```bash
-pnpm add @l-etabli/events
+bun add @l-etabli/events
 ```
 
-For Kysely adapter (PostgreSQL):
+For Kysely/PostgreSQL:
 
 ```bash
-pnpm add @l-etabli/events kysely pg
+bun add @l-etabli/events kysely pg
 ```
 
-## Quick Start
+## Recommended API
 
-### 1. Define Your Events
+The recommended way to model events is now a single canonical definitions object.
 
-```typescript
-import { GenericEvent } from "@l-etabli/events";
+```ts
+import {
+  defineEvent,
+  defineEvents,
+  type InferEventsFromDefinitions,
+} from "@l-etabli/events";
 
-type MyEvents =
-  | GenericEvent<"UserCreated", { userId: string; email: string }>
-  | GenericEvent<"OrderPlaced", { orderId: string; amount: number }>;
+type Project = { id: string; name: string };
+type ProjectContext = { projectId: string };
+type ProjectMemberContext = { projectId: string; memberId: string };
+type ProjectRole = "admin" | "editor";
+
+const eventDefinitions = defineEvents({
+  ProjectCreated: defineEvent<{ project: Project }, ProjectContext>({
+    priority: 1,
+  }),
+  ProjectUpdated: defineEvent<{ project: Project }, ProjectContext>(),
+  UserAddedToProject: defineEvent<
+    { projectId: string; userId: string; role: ProjectRole },
+    ProjectMemberContext
+  >({
+    priority: 20,
+  }),
+  PingSent: defineEvent<{ at: Date }>(),
+});
+
+type AppEvents = InferEventsFromDefinitions<typeof eventDefinitions>;
 ```
 
-### 2. Setup Event Infrastructure
+Benefits:
+
+- one object to maintain
+- topics derived from object keys
+- `priority` lives in the same canonical definition
+- no handwritten `GenericEvent<...> | ...` union in the app
+
+## Quick Start
+
+### 1. Setup infrastructure
 
-```typescript
+```ts
 import {
+  createUserActor,
+  createWorkerActor,
+  createEventCrawler,
   createInMemoryEventBus,
   createInMemoryEventRepositoryAndQueries,
-  createEventCrawler,
 } from "@l-etabli/events";
 
-const { eventQueries, withUow } = createInMemoryEventRepositoryAndQueries<MyEvents>();
-const { eventBus, createNewEvent } = createInMemoryEventBus<MyEvents>(withUow);
+const { eventQueries, withUow } =
+  createInMemoryEventRepositoryAndQueries<AppEvents>();
+
+const { eventBus, createNewEvent } = createInMemoryEventBus(withUow, {
+  eventDefinitions,
+});
 
 const crawler = createEventCrawler({
   withUow,
@@ -47,47 +83,47 @@ const crawler = createEventCrawler({
 });
 ```
 
-### 3. Subscribe to Events
+### 2. Subscribe to events
 
-```typescript
+```ts
 eventBus.subscribe({
-  topic: "OrderPlaced",
-  subscriptionId: "send-confirmation-email",
+  topic: "ProjectCreated",
+  subscriptionId: "send-project-created-email",
   callBack: async (event) => {
-    await emailService.sendOrderConfirmation(event.payload.orderId);
+    await emailService.send(event.payload.project.id);
   },
 });
 ```
 
-### 4. Emit Events (in a use case)
+### 3. Emit events
 
-```typescript
+```ts
 await withUow(async (uow) => {
-  // Save your domain entity
-  await orderRepository.save(order);
+  await projectRepository.save(project);
 
-  // Emit event in the same transaction
   await uow.eventRepository.saveNewEventsBatch([
     createNewEvent({
-      topic: "OrderPlaced",
-      payload: { orderId: order.id, amount: order.total },
-      triggeredByUserId: currentUserId,
+      topic: "ProjectCreated",
+      payload: { project },
+      context: { projectId: project.id },
+      triggeredByActor: createUserActor(currentUserId),
+      flowId: requestId,
     }),
   ]);
 });
 ```
 
-### 5. Process Events
+### 4. Process events
 
-**Traditional server** - start background polling:
+Traditional server:
 
-```typescript
+```ts
 crawler.start();
 ```
 
-**Serverless** - trigger on-demand after commit:
+Serverless:
 
-```typescript
+```ts
 await withUow(
   async (uow) => {
     await uow.eventRepository.saveNewEventsBatch([event]);
@@ -96,117 +132,107 @@ await withUow(
     afterCommit: async () => {
       await crawler.triggerProcessing();
     },
-  }
+  },
 );
-
-### Returning Values from Transactions
-
-The `withUow` function supports returning values from your transaction callback:
-
-```typescript
-const result = await withUow(async (uow) => {
-  const order = await orderRepository.save(newOrder);
-
-  await uow.eventRepository.saveNewEventsBatch([
-    createNewEvent({
-      topic: "OrderPlaced",
-      payload: { orderId: order.id, amount: order.total },
-      triggeredByUserId: currentUserId,
-    }),
-  ]);
-
-  return { orderId: order.id, createdAt: order.createdAt };
-});
-
-console.log(result.orderId); // Access the returned value
 ```
 
-## Event Lifecycle
+## Event shape
 
-```
-never-published → in-process → published
-                           ↘ failed-but-will-retry → published
-                                                  ↘ quarantined (after maxRetries)
-```
-
-- `never-published` - New event, not yet processed
-- `in-process` - Currently being published
-- `published` - Successfully delivered to all subscribers
-- `failed-but-will-retry` - Some subscribers failed, will retry
-- `quarantined` - Exceeded max retries, requires manual intervention
-- `to-republish` - Force republish to all subscribers
-
-## API Reference
-
-### Types
+`GenericEvent` remains the base type.
 
-```typescript
-// Define events with topic, payload, and optional context
-type GenericEvent<Topic, Payload, Context?> = {
+```ts
+type GenericEvent<Topic, Payload, Context = undefined> = {
   id: EventId;
+  occurredAt: Date;
   topic: Topic;
   payload: Payload;
   status: EventStatus;
-  occurredAt: Date;
-  triggeredByUserId: UserId;
   publications: EventPublication[];
-  context?: Context;
+  triggeredByActor: Actor;
+  flowId?: string;
+  causedByEventId?: EventId;
   priority?: number;
+  context?: Context;
 };
+
+type Actor =
+  | UserActor
+  | SystemActor
+  | WorkerActor
+  | ApiKeyActor
+  | AnonymousActor;
+type UserActor<Id extends string = string> = { kind: "user"; id: Id };
+type SystemActor = { kind: "system" };
+type WorkerActor<Id extends string = string> = { kind: "worker"; id?: Id };
+type ApiKeyActor<Id extends string = string> = { kind: "api-key"; id: Id };
+type AnonymousActor = { kind: "anonymous" };
 ```
 
-### `makeCreateNewEvent<Events>(options?)`
+Rules:
 
-Creates a type-safe event factory. Payload is validated against topic at compile time.
+- `payload` is always required
+- `context` is only required at the call site for topics that declare one
+- `priority` is injected automatically from `eventDefinitions` when provided
 
-```typescript
-const createEvent = makeCreateNewEvent<MyEvents>({
-  getNow: () => new Date(),      // optional, for testing
-  generateId: () => crypto.randomUUID(), // optional, for testing
-});
+## Creating events
 
-// Type-safe: payload must match topic
-createEvent({ topic: "UserCreated", payload: { userId: "1", email: "a@b.com" }, triggeredByUserId: "u1" });
-```
+### From event definitions
 
-### `createInMemoryEventBus<Events>(withUow, options?)`
+```ts
+import { createUserActor, makeCreateNewEvent } from "@l-etabli/events";
 
-Creates an in-memory event bus with a typed `createNewEvent` function.
+const createNewEvent = makeCreateNewEvent({
+  eventDefinitions,
+});
 
-```typescript
-const { eventBus, createNewEvent } = createInMemoryEventBus<MyEvents>(withUow, {
-  maxRetries: 3, // default
+createNewEvent({
+  topic: "ProjectCreated",
+  payload: { project },
+  context: { projectId: project.id },
+  triggeredByActor: createUserActor(currentUserId),
+});
+
+createNewEvent({
+  topic: "PingSent",
+  payload: { at: new Date() },
+  triggeredByActor: createWorkerActor("nightly-sync"),
 });
 ```
 
-### `createEventCrawler(config)`
+### From an existing union
 
-Creates a background processor for publishing events.
+The previous union-based approach still works.
 
-```typescript
-const crawler = createEventCrawler({
-  withUow,
-  eventQueries,
-  eventBus,
-  options: {
-    batchSize: 100,              // events per batch (default: 100)
-    maxParallelProcessing: 1,    // parallel publishes (default: 1)
-    newEventsIntervalMs: 10000,  // polling interval (default: 10s)
-    failedEventsIntervalMs: 60000, // retry interval (default: 60s)
-  },
-});
+```ts
+import { type GenericEvent, makeCreateNewEvent } from "@l-etabli/events";
+
+type LegacyEvents =
+  | GenericEvent<"UserCreated", { userId: string; email: string }>
+  | GenericEvent<"OrderPlaced", { orderId: string }, { tenantId: string }>;
+
+const createNewEvent = makeCreateNewEvent<LegacyEvents>();
+```
+
+## Event lifecycle
 
-crawler.start();              // Start background polling
-crawler.processNewEvents();   // Manual: process new events
-crawler.retryFailedEvents();  // Manual: retry failed events
-crawler.triggerProcessing();  // Manual: process new + retry failed
+```text
+never-published -> in-process -> published
+                           \-> failed-but-will-retry -> published
+                                                  \-> quarantined
 ```
 
-## Database Setup (Kysely/PostgreSQL)
+Statuses:
 
-### Migration
+- `never-published`
+- `to-republish`
+- `in-process`
+- `published`
+- `failed-but-will-retry`
+- `quarantined`
 
-```typescript
+## Kysely migration helper
+
+```ts
 import type { Kysely } from "kysely";
 
 export async function up(db: Kysely<unknown>): Promise<void> {
@@ -217,51 +243,16 @@ export async function up(db: Kysely<unknown>): Promise<void> {
     .addColumn("payload", "jsonb", (col) => col.notNull())
     .addColumn("context", "jsonb")
     .addColumn("status", "text", (col) => col.notNull())
-    .addColumn("triggeredByUserId", "text", (col) => col.notNull())
+    .addColumn("triggeredByActor", "jsonb", (col) => col.notNull())
+    .addColumn("flowId", "text")
+    .addColumn("causedByEventId", "text")
     .addColumn("occurredAt", "timestamptz", (col) => col.notNull())
     .addColumn("publications", "jsonb", (col) => col.notNull().defaultTo("[]"))
     .addColumn("priority", "integer")
     .execute();
-
-  await db.schema
-    .createIndex("events_status_idx")
-    .on("events")
-    .column("status")
-    .execute();
-
-  await db.schema
-    .createIndex("events_topic_idx")
-    .on("events")
-    .column("topic")
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable("events").execute();
 }
 ```
 
-### Usage with Kysely
-
-```typescript
-import { createInMemoryEventBus, createEventCrawler } from "@l-etabli/events";
-import {
-  KyselyEventRepository,
-  KyselyEventQueries,
-  createKyselyMigration,
-} from "@l-etabli/events/kysely";
-
-// See examples/kysely/ for complete implementation
-```
-
 ## Examples
 
-See the [`examples/`](./examples/) directory for complete implementations:
-
-- **[kysely-adapter.ts](./examples/kysely/kysely-adapter.ts)** - Kysely adapter with transaction support
-- **[serverless-usage.ts](./examples/kysely/serverless-usage.ts)** - AWS Lambda / serverless deployment
-- **[cascading-events.ts](./examples/kysely/cascading-events.ts)** - Transactional event chains
-
-## License
-
-MIT
+See [`examples/`](./examples/) for Kysely integration, cascading events and serverless usage.

package/dist/adapters/in-memory/InMemoryEventBus.cjs

@@ -23,9 +23,14 @@ __export(InMemoryEventBus_exports, {
 module.exports = __toCommonJS(InMemoryEventBus_exports);
 var import_createNewEvent = require("../../createNewEvent.ts");
 var import_subscriptions = require("../../subscriptions.ts");
-const createInMemoryEventBus = (withUow, options = {}) => {
+function createInMemoryEventBus(withUow, options = {}) {
   const maxRetries = options.maxRetries ?? 3;
-  const createNewEvent = (0, import_createNewEvent.makeCreateNewEvent)({
+  const eventDefinitions = "eventDefinitions" in options ? options.eventDefinitions : void 0;
+  const createNewEvent = eventDefinitions ? (0, import_createNewEvent.makeCreateNewEvent)({
+    getNow: options.getNow,
+    generateId: options.generateId,
+    eventDefinitions
+  }) : (0, import_createNewEvent.makeCreateNewEvent)({
     getNow: options.getNow,
     generateId: options.generateId
   });
@@ -133,7 +138,7 @@ const createInMemoryEventBus = (withUow, options = {}) => {
     subscribeAll,
     subscribeGlobal
   };
-};
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createInMemoryEventBus

package/dist/adapters/in-memory/InMemoryEventBus.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventBus.ts"],"sourcesContent":["import { makeCreateNewEvent } from \"../../createNewEvent.ts\";\nimport type { EventBus } from \"../../ports/EventBus.ts\";\nimport type { WithEventsUow } from \"../../ports/EventRepository.ts\";\nimport {\n  type GlobalSubscriberConfig,\n  subscribeByTopic,\n  subscribeGlobalToTopics,\n  type TopicSubscriptions,\n} from \"../../subscriptions.ts\";\nimport type {\n  DefaultContext,\n  EventId,\n  EventPublication,\n  GenericEvent,\n  SubscriptionId,\n} from \"../../types.ts\";\n\ntype SubscriptionsForTopic = Record<\n  string,\n  (event: GenericEvent<string, unknown, DefaultContext>) => Promise<void>\n>;\n\ntype CreateInMemoryEventBusOptions = {\n  maxRetries?: number;\n  getNow?: () => Date;\n  generateId?: () => EventId;\n};\n\nexport const createInMemoryEventBus = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  withUow: WithEventsUow<Event>,\n  options: CreateInMemoryEventBusOptions = {},\n) => {\n  const maxRetries = options.maxRetries ?? 3;\n  const createNewEvent = makeCreateNewEvent<Event>({\n    getNow: options.getNow,\n    generateId: options.generateId,\n  });\n  const subscriptions: Partial<Record<string, SubscriptionsForTopic>> = {};\n\n  const executeCallback = async (\n    event: Event,\n    subscriptionId: string,\n    callback: (\n      event: GenericEvent<string, unknown, DefaultContext>,\n    ) => Promise<void>,\n  ): Promise<\n    { subscriptionId: string; errorMessage: string; stack?: string } | undefined\n  > => {\n    try {\n      await callback(event);\n    } catch (error) {\n      return {\n        subscriptionId,\n        errorMessage: error instanceof Error ? error.message : String(error),\n        stack: error instanceof Error ? error.stack : undefined,\n      };\n    }\n  };\n\n  const getSubscriptionIdsToPublish = (\n    event: Event,\n    callbacksBySubscriptionId: SubscriptionsForTopic,\n  ): string[] => {\n    const allSubscriptionIds = Object.keys(callbacksBySubscriptionId);\n\n    if (event.publications.length === 0 || event.status === \"to-republish\") {\n      return allSubscriptionIds;\n    }\n\n    const lastPublication = event.publications.reduce((latest, current) =>\n      current.publishedAt > latest.publishedAt ? current : latest,\n    );\n    const failedSubscriptionIds = (lastPublication.failures ?? []).map(\n      (failure) => failure.subscriptionId,\n    );\n\n    return allSubscriptionIds.filter((id) =>\n      failedSubscriptionIds.includes(id),\n    );\n  };\n\n  const eventBus: EventBus<Event> = {\n    publish: async (event) => {\n      const publishedAt = new Date();\n      const topic = event.topic;\n\n      const callbacksBySubscriptionSlug = subscriptions[topic];\n\n      if (!callbacksBySubscriptionSlug) {\n        event.publications.push({\n          publishedAt,\n          publishedSubscribers: [],\n        });\n        event.status = \"published\";\n        await withUow(async (uow) => {\n          await uow.eventRepository.save(event);\n        });\n        return;\n      }\n\n      const subscriptionIdsToPublish = getSubscriptionIdsToPublish(\n        event,\n        callbacksBySubscriptionSlug,\n      );\n\n      const failuresOrUndefined = await Promise.all(\n        subscriptionIdsToPublish.map((subscriptionId) =>\n          executeCallback(\n            event,\n            subscriptionId,\n            callbacksBySubscriptionSlug[subscriptionId],\n          ),\n        ),\n      );\n\n      const failures = failuresOrUndefined.filter(\n        (\n          f,\n        ): f is {\n          subscriptionId: string;\n          errorMessage: string;\n          stack?: string;\n        } => f !== undefined,\n      );\n\n      const publications: EventPublication[] = [\n        ...event.publications,\n        {\n          publishedAt,\n          publishedSubscribers: subscriptionIdsToPublish.map(\n            (id) => id as SubscriptionId,\n          ),\n          ...(failures.length > 0 && { failures }),\n        },\n      ];\n\n      if (failures.length === 0) {\n        event.status = \"published\";\n      } else {\n        const wasMaxNumberOfErrorsReached = publications.length >= maxRetries;\n        event.status = wasMaxNumberOfErrorsReached\n          ? \"quarantined\"\n          : \"failed-but-will-retry\";\n      }\n\n      event.publications = publications;\n\n      await withUow(async (uow) => {\n        await uow.eventRepository.save(event);\n      });\n    },\n\n    subscribe: ({ topic, subscriptionId, callBack }) => {\n      if (!subscriptions[topic]) {\n        subscriptions[topic] = {};\n      }\n\n      const subscriptionsForTopic = subscriptions[topic];\n      if (subscriptionsForTopic) {\n        subscriptionsForTopic[subscriptionId] = callBack as (\n          event: GenericEvent<string, unknown, DefaultContext>,\n        ) => Promise<void>;\n      }\n    },\n  };\n\n  /**\n   * Identity function for type inference when defining subscription maps.\n   * Ensures all topics are covered and handlers have correct payload types.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({\n   *   OrderCreated: [{ subscriptionId: \"notify\", handler: async (e) => {...} }],\n   *   OrderShipped: [], // Required even if empty\n   * });\n   * ```\n   */\n  const defineSubscriptions = (\n    subscriptions: TopicSubscriptions<Event>,\n  ): TopicSubscriptions<Event> => subscriptions;\n\n  /**\n   * Subscribe all handlers from a topic subscription map to this event bus.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({...});\n   * subscribeAll(subscriptions);\n   * ```\n   */\n  const subscribeAll = (subscriptions: TopicSubscriptions<Event>): void => {\n    subscribeByTopic(eventBus, subscriptions);\n  };\n\n  /**\n   * Subscribe a global handler to multiple topics with optional filtering.\n   *\n   * @example\n   * ```typescript\n   * subscribeGlobal(subscriptions, {\n   *   subscriptionId: \"audit-log\",\n   *   handler: async (event) => auditLog.record(event),\n   *   filter: { exclude: [\"NotificationAdded\"] },\n   * });\n   * ```\n   */\n  const subscribeGlobal = (\n    subscriptions: TopicSubscriptions<Event>,\n    config: GlobalSubscriberConfig<Event>,\n  ): void => {\n    subscribeGlobalToTopics(eventBus, subscriptions, config);\n  };\n\n  return {\n    eventBus,\n    createNewEvent,\n    defineSubscriptions,\n    subscribeAll,\n    subscribeGlobal,\n  };\n};\n"],"mappings":"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","names":["subscriptions"]}
+{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventBus.ts"],"sourcesContent":["import {\n  type CreateNewEvent,\n  type CreateNewEventFromDefinitions,\n  makeCreateNewEvent,\n} from \"../../createNewEvent.ts\";\nimport type {\n  EventDefinitions,\n  InferEventsFromDefinitions,\n} from \"../../eventDefinitions.ts\";\nimport type { EventBus } from \"../../ports/EventBus.ts\";\nimport type { WithEventsUow } from \"../../ports/EventRepository.ts\";\nimport {\n  type GlobalSubscriberConfig,\n  subscribeByTopic,\n  subscribeGlobalToTopics,\n  type TopicSubscriptions,\n} from \"../../subscriptions.ts\";\nimport type {\n  DefaultContext,\n  EventId,\n  EventPublication,\n  GenericEvent,\n  SubscriptionId,\n} from \"../../types.ts\";\n\ntype SubscriptionsForTopic = Record<\n  string,\n  (event: GenericEvent<string, unknown, DefaultContext>) => Promise<void>\n>;\n\ntype CreateInMemoryEventBusOptions = {\n  maxRetries?: number;\n  getNow?: () => Date;\n  generateId?: () => EventId;\n};\n\ntype CreateInMemoryEventBusFromDefinitionsOptions<\n  Definitions extends EventDefinitions,\n> = CreateInMemoryEventBusOptions & {\n  eventDefinitions: Definitions;\n};\n\ntype CreateInMemoryEventBusResult<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  eventBus: EventBus<Event>;\n  createNewEvent: CreateNewEvent<Event>;\n  defineSubscriptions: (\n    subscriptions: TopicSubscriptions<Event>,\n  ) => TopicSubscriptions<Event>;\n  subscribeAll: (subscriptions: TopicSubscriptions<Event>) => void;\n  subscribeGlobal: (\n    subscriptions: TopicSubscriptions<Event>,\n    config: GlobalSubscriberConfig<Event>,\n  ) => void;\n};\n\nexport function createInMemoryEventBus<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  withUow: WithEventsUow<Event>,\n  options?: CreateInMemoryEventBusOptions,\n): CreateInMemoryEventBusResult<Event>;\nexport function createInMemoryEventBus<Definitions extends EventDefinitions>(\n  withUow: WithEventsUow<InferEventsFromDefinitions<Definitions>>,\n  options: CreateInMemoryEventBusFromDefinitionsOptions<Definitions>,\n): Omit<\n  CreateInMemoryEventBusResult<InferEventsFromDefinitions<Definitions>>,\n  \"createNewEvent\"\n> & {\n  createNewEvent: CreateNewEventFromDefinitions<Definitions>;\n};\nexport function createInMemoryEventBus<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  withUow: WithEventsUow<Event>,\n  options:\n    | CreateInMemoryEventBusOptions\n    | CreateInMemoryEventBusFromDefinitionsOptions<EventDefinitions> = {},\n) {\n  const maxRetries = options.maxRetries ?? 3;\n  const eventDefinitions =\n    \"eventDefinitions\" in options ? options.eventDefinitions : undefined;\n  const createNewEvent = eventDefinitions\n    ? makeCreateNewEvent({\n        getNow: options.getNow,\n        generateId: options.generateId,\n        eventDefinitions,\n      })\n    : makeCreateNewEvent<Event>({\n        getNow: options.getNow,\n        generateId: options.generateId,\n      });\n  const subscriptions: Partial<Record<string, SubscriptionsForTopic>> = {};\n\n  const executeCallback = async (\n    event: Event,\n    subscriptionId: string,\n    callback: (\n      event: GenericEvent<string, unknown, DefaultContext>,\n    ) => Promise<void>,\n  ): Promise<\n    { subscriptionId: string; errorMessage: string; stack?: string } | undefined\n  > => {\n    try {\n      await callback(event);\n    } catch (error) {\n      return {\n        subscriptionId,\n        errorMessage: error instanceof Error ? error.message : String(error),\n        stack: error instanceof Error ? error.stack : undefined,\n      };\n    }\n  };\n\n  const getSubscriptionIdsToPublish = (\n    event: Event,\n    callbacksBySubscriptionId: SubscriptionsForTopic,\n  ): string[] => {\n    const allSubscriptionIds = Object.keys(callbacksBySubscriptionId);\n\n    if (event.publications.length === 0 || event.status === \"to-republish\") {\n      return allSubscriptionIds;\n    }\n\n    const lastPublication = event.publications.reduce((latest, current) =>\n      current.publishedAt > latest.publishedAt ? current : latest,\n    );\n    const failedSubscriptionIds = (lastPublication.failures ?? []).map(\n      (failure) => failure.subscriptionId,\n    );\n\n    return allSubscriptionIds.filter((id) =>\n      failedSubscriptionIds.includes(id),\n    );\n  };\n\n  const eventBus: EventBus<Event> = {\n    publish: async (event) => {\n      const publishedAt = new Date();\n      const topic = event.topic;\n\n      const callbacksBySubscriptionSlug = subscriptions[topic];\n\n      if (!callbacksBySubscriptionSlug) {\n        event.publications.push({\n          publishedAt,\n          publishedSubscribers: [],\n        });\n        event.status = \"published\";\n        await withUow(async (uow) => {\n          await uow.eventRepository.save(event);\n        });\n        return;\n      }\n\n      const subscriptionIdsToPublish = getSubscriptionIdsToPublish(\n        event,\n        callbacksBySubscriptionSlug,\n      );\n\n      const failuresOrUndefined = await Promise.all(\n        subscriptionIdsToPublish.map((subscriptionId) =>\n          executeCallback(\n            event,\n            subscriptionId,\n            callbacksBySubscriptionSlug[subscriptionId],\n          ),\n        ),\n      );\n\n      const failures = failuresOrUndefined.filter(\n        (\n          f,\n        ): f is {\n          subscriptionId: string;\n          errorMessage: string;\n          stack?: string;\n        } => f !== undefined,\n      );\n\n      const publications: EventPublication[] = [\n        ...event.publications,\n        {\n          publishedAt,\n          publishedSubscribers: subscriptionIdsToPublish.map(\n            (id) => id as SubscriptionId,\n          ),\n          ...(failures.length > 0 && { failures }),\n        },\n      ];\n\n      if (failures.length === 0) {\n        event.status = \"published\";\n      } else {\n        const wasMaxNumberOfErrorsReached = publications.length >= maxRetries;\n        event.status = wasMaxNumberOfErrorsReached\n          ? \"quarantined\"\n          : \"failed-but-will-retry\";\n      }\n\n      event.publications = publications;\n\n      await withUow(async (uow) => {\n        await uow.eventRepository.save(event);\n      });\n    },\n\n    subscribe: ({ topic, subscriptionId, callBack }) => {\n      if (!subscriptions[topic]) {\n        subscriptions[topic] = {};\n      }\n\n      const subscriptionsForTopic = subscriptions[topic];\n      if (subscriptionsForTopic) {\n        subscriptionsForTopic[subscriptionId] = callBack as (\n          event: GenericEvent<string, unknown, DefaultContext>,\n        ) => Promise<void>;\n      }\n    },\n  };\n\n  /**\n   * Identity function for type inference when defining subscription maps.\n   * Ensures all topics are covered and handlers have correct payload types.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({\n   *   OrderCreated: [{ subscriptionId: \"notify\", handler: async (e) => {...} }],\n   *   OrderShipped: [], // Required even if empty\n   * });\n   * ```\n   */\n  const defineSubscriptions = (\n    subscriptions: TopicSubscriptions<Event>,\n  ): TopicSubscriptions<Event> => subscriptions;\n\n  /**\n   * Subscribe all handlers from a topic subscription map to this event bus.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({...});\n   * subscribeAll(subscriptions);\n   * ```\n   */\n  const subscribeAll = (subscriptions: TopicSubscriptions<Event>): void => {\n    subscribeByTopic(eventBus, subscriptions);\n  };\n\n  /**\n   * Subscribe a global handler to multiple topics with optional filtering.\n   *\n   * @example\n   * ```typescript\n   * subscribeGlobal(subscriptions, {\n   *   subscriptionId: \"audit-log\",\n   *   handler: async (event) => auditLog.record(event),\n   *   filter: { exclude: [\"NotificationAdded\"] },\n   * });\n   * ```\n   */\n  const subscribeGlobal = (\n    subscriptions: TopicSubscriptions<Event>,\n    config: GlobalSubscriberConfig<Event>,\n  ): void => {\n    subscribeGlobalToTopics(eventBus, subscriptions, config);\n  };\n\n  return {\n    eventBus,\n    createNewEvent,\n    defineSubscriptions,\n    subscribeAll,\n    subscribeGlobal,\n  };\n}\n"],"mappings":"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","names":["subscriptions"]}

package/dist/adapters/in-memory/InMemoryEventBus.d.cts

@@ -1,4 +1,5 @@
-import { CreateNewEvent } from '../../createNewEvent.cjs';
+import { CreateNewEvent, CreateNewEventFromDefinitions } from '../../createNewEvent.cjs';
+import { EventDefinitions, InferEventsFromDefinitions } from '../../eventDefinitions.cjs';
 import { EventBus } from '../../ports/EventBus.cjs';
 import { WithEventsUow } from '../../ports/EventRepository.cjs';
 import { TopicSubscriptions, GlobalSubscriberConfig } from '../../subscriptions.cjs';
@@ -9,12 +10,19 @@ type CreateInMemoryEventBusOptions = {
     getNow?: () => Date;
     generateId?: () => EventId;
 };
-declare const createInMemoryEventBus: <Event extends GenericEvent<string, unknown, DefaultContext>>(withUow: WithEventsUow<Event>, options?: CreateInMemoryEventBusOptions) => {
+type CreateInMemoryEventBusFromDefinitionsOptions<Definitions extends EventDefinitions> = CreateInMemoryEventBusOptions & {
+    eventDefinitions: Definitions;
+};
+type CreateInMemoryEventBusResult<Event extends GenericEvent<string, unknown, DefaultContext>> = {
     eventBus: EventBus<Event>;
     createNewEvent: CreateNewEvent<Event>;
     defineSubscriptions: (subscriptions: TopicSubscriptions<Event>) => TopicSubscriptions<Event>;
     subscribeAll: (subscriptions: TopicSubscriptions<Event>) => void;
     subscribeGlobal: (subscriptions: TopicSubscriptions<Event>, config: GlobalSubscriberConfig<Event>) => void;
 };
+declare function createInMemoryEventBus<Event extends GenericEvent<string, unknown, DefaultContext>>(withUow: WithEventsUow<Event>, options?: CreateInMemoryEventBusOptions): CreateInMemoryEventBusResult<Event>;
+declare function createInMemoryEventBus<Definitions extends EventDefinitions>(withUow: WithEventsUow<InferEventsFromDefinitions<Definitions>>, options: CreateInMemoryEventBusFromDefinitionsOptions<Definitions>): Omit<CreateInMemoryEventBusResult<InferEventsFromDefinitions<Definitions>>, "createNewEvent"> & {
+    createNewEvent: CreateNewEventFromDefinitions<Definitions>;
+};
 
 export { createInMemoryEventBus };

package/dist/adapters/in-memory/InMemoryEventBus.d.ts

@@ -1,4 +1,5 @@
-import { CreateNewEvent } from '../../createNewEvent.js';
+import { CreateNewEvent, CreateNewEventFromDefinitions } from '../../createNewEvent.js';
+import { EventDefinitions, InferEventsFromDefinitions } from '../../eventDefinitions.js';
 import { EventBus } from '../../ports/EventBus.js';
 import { WithEventsUow } from '../../ports/EventRepository.js';
 import { TopicSubscriptions, GlobalSubscriberConfig } from '../../subscriptions.js';
@@ -9,12 +10,19 @@ type CreateInMemoryEventBusOptions = {
     getNow?: () => Date;
     generateId?: () => EventId;
 };
-declare const createInMemoryEventBus: <Event extends GenericEvent<string, unknown, DefaultContext>>(withUow: WithEventsUow<Event>, options?: CreateInMemoryEventBusOptions) => {
+type CreateInMemoryEventBusFromDefinitionsOptions<Definitions extends EventDefinitions> = CreateInMemoryEventBusOptions & {
+    eventDefinitions: Definitions;
+};
+type CreateInMemoryEventBusResult<Event extends GenericEvent<string, unknown, DefaultContext>> = {
     eventBus: EventBus<Event>;
     createNewEvent: CreateNewEvent<Event>;
     defineSubscriptions: (subscriptions: TopicSubscriptions<Event>) => TopicSubscriptions<Event>;
     subscribeAll: (subscriptions: TopicSubscriptions<Event>) => void;
     subscribeGlobal: (subscriptions: TopicSubscriptions<Event>, config: GlobalSubscriberConfig<Event>) => void;
 };
+declare function createInMemoryEventBus<Event extends GenericEvent<string, unknown, DefaultContext>>(withUow: WithEventsUow<Event>, options?: CreateInMemoryEventBusOptions): CreateInMemoryEventBusResult<Event>;
+declare function createInMemoryEventBus<Definitions extends EventDefinitions>(withUow: WithEventsUow<InferEventsFromDefinitions<Definitions>>, options: CreateInMemoryEventBusFromDefinitionsOptions<Definitions>): Omit<CreateInMemoryEventBusResult<InferEventsFromDefinitions<Definitions>>, "createNewEvent"> & {
+    createNewEvent: CreateNewEventFromDefinitions<Definitions>;
+};
 
 export { createInMemoryEventBus };

package/dist/adapters/in-memory/InMemoryEventBus.mjs

@@ -1,11 +1,18 @@
-import { makeCreateNewEvent } from "../../createNewEvent.mjs";
+import {
+  makeCreateNewEvent
+} from "../../createNewEvent.mjs";
 import {
   subscribeByTopic,
   subscribeGlobalToTopics
 } from "../../subscriptions.mjs";
-const createInMemoryEventBus = (withUow, options = {}) => {
+function createInMemoryEventBus(withUow, options = {}) {
   const maxRetries = options.maxRetries ?? 3;
-  const createNewEvent = makeCreateNewEvent({
+  const eventDefinitions = "eventDefinitions" in options ? options.eventDefinitions : void 0;
+  const createNewEvent = eventDefinitions ? makeCreateNewEvent({
+    getNow: options.getNow,
+    generateId: options.generateId,
+    eventDefinitions
+  }) : makeCreateNewEvent({
     getNow: options.getNow,
     generateId: options.generateId
   });
@@ -113,7 +120,7 @@ const createInMemoryEventBus = (withUow, options = {}) => {
     subscribeAll,
     subscribeGlobal
   };
-};
+}
 export {
   createInMemoryEventBus
 };

package/dist/adapters/in-memory/InMemoryEventBus.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventBus.ts"],"sourcesContent":["import { makeCreateNewEvent } from '../../createNewEvent.mjs';\nimport type { EventBus } from '../../ports/EventBus.mjs';\nimport type { WithEventsUow } from '../../ports/EventRepository.mjs';\nimport {\n  type GlobalSubscriberConfig,\n  subscribeByTopic,\n  subscribeGlobalToTopics,\n  type TopicSubscriptions,\n} from '../../subscriptions.mjs';\nimport type {\n  DefaultContext,\n  EventId,\n  EventPublication,\n  GenericEvent,\n  SubscriptionId,\n} from '../../types.mjs';\n\ntype SubscriptionsForTopic = Record<\n  string,\n  (event: GenericEvent<string, unknown, DefaultContext>) => Promise<void>\n>;\n\ntype CreateInMemoryEventBusOptions = {\n  maxRetries?: number;\n  getNow?: () => Date;\n  generateId?: () => EventId;\n};\n\nexport const createInMemoryEventBus = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  withUow: WithEventsUow<Event>,\n  options: CreateInMemoryEventBusOptions = {},\n) => {\n  const maxRetries = options.maxRetries ?? 3;\n  const createNewEvent = makeCreateNewEvent<Event>({\n    getNow: options.getNow,\n    generateId: options.generateId,\n  });\n  const subscriptions: Partial<Record<string, SubscriptionsForTopic>> = {};\n\n  const executeCallback = async (\n    event: Event,\n    subscriptionId: string,\n    callback: (\n      event: GenericEvent<string, unknown, DefaultContext>,\n    ) => Promise<void>,\n  ): Promise<\n    { subscriptionId: string; errorMessage: string; stack?: string } | undefined\n  > => {\n    try {\n      await callback(event);\n    } catch (error) {\n      return {\n        subscriptionId,\n        errorMessage: error instanceof Error ? error.message : String(error),\n        stack: error instanceof Error ? error.stack : undefined,\n      };\n    }\n  };\n\n  const getSubscriptionIdsToPublish = (\n    event: Event,\n    callbacksBySubscriptionId: SubscriptionsForTopic,\n  ): string[] => {\n    const allSubscriptionIds = Object.keys(callbacksBySubscriptionId);\n\n    if (event.publications.length === 0 || event.status === \"to-republish\") {\n      return allSubscriptionIds;\n    }\n\n    const lastPublication = event.publications.reduce((latest, current) =>\n      current.publishedAt > latest.publishedAt ? current : latest,\n    );\n    const failedSubscriptionIds = (lastPublication.failures ?? []).map(\n      (failure) => failure.subscriptionId,\n    );\n\n    return allSubscriptionIds.filter((id) =>\n      failedSubscriptionIds.includes(id),\n    );\n  };\n\n  const eventBus: EventBus<Event> = {\n    publish: async (event) => {\n      const publishedAt = new Date();\n      const topic = event.topic;\n\n      const callbacksBySubscriptionSlug = subscriptions[topic];\n\n      if (!callbacksBySubscriptionSlug) {\n        event.publications.push({\n          publishedAt,\n          publishedSubscribers: [],\n        });\n        event.status = \"published\";\n        await withUow(async (uow) => {\n          await uow.eventRepository.save(event);\n        });\n        return;\n      }\n\n      const subscriptionIdsToPublish = getSubscriptionIdsToPublish(\n        event,\n        callbacksBySubscriptionSlug,\n      );\n\n      const failuresOrUndefined = await Promise.all(\n        subscriptionIdsToPublish.map((subscriptionId) =>\n          executeCallback(\n            event,\n            subscriptionId,\n            callbacksBySubscriptionSlug[subscriptionId],\n          ),\n        ),\n      );\n\n      const failures = failuresOrUndefined.filter(\n        (\n          f,\n        ): f is {\n          subscriptionId: string;\n          errorMessage: string;\n          stack?: string;\n        } => f !== undefined,\n      );\n\n      const publications: EventPublication[] = [\n        ...event.publications,\n        {\n          publishedAt,\n          publishedSubscribers: subscriptionIdsToPublish.map(\n            (id) => id as SubscriptionId,\n          ),\n          ...(failures.length > 0 && { failures }),\n        },\n      ];\n\n      if (failures.length === 0) {\n        event.status = \"published\";\n      } else {\n        const wasMaxNumberOfErrorsReached = publications.length >= maxRetries;\n        event.status = wasMaxNumberOfErrorsReached\n          ? \"quarantined\"\n          : \"failed-but-will-retry\";\n      }\n\n      event.publications = publications;\n\n      await withUow(async (uow) => {\n        await uow.eventRepository.save(event);\n      });\n    },\n\n    subscribe: ({ topic, subscriptionId, callBack }) => {\n      if (!subscriptions[topic]) {\n        subscriptions[topic] = {};\n      }\n\n      const subscriptionsForTopic = subscriptions[topic];\n      if (subscriptionsForTopic) {\n        subscriptionsForTopic[subscriptionId] = callBack as (\n          event: GenericEvent<string, unknown, DefaultContext>,\n        ) => Promise<void>;\n      }\n    },\n  };\n\n  /**\n   * Identity function for type inference when defining subscription maps.\n   * Ensures all topics are covered and handlers have correct payload types.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({\n   *   OrderCreated: [{ subscriptionId: \"notify\", handler: async (e) => {...} }],\n   *   OrderShipped: [], // Required even if empty\n   * });\n   * ```\n   */\n  const defineSubscriptions = (\n    subscriptions: TopicSubscriptions<Event>,\n  ): TopicSubscriptions<Event> => subscriptions;\n\n  /**\n   * Subscribe all handlers from a topic subscription map to this event bus.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({...});\n   * subscribeAll(subscriptions);\n   * ```\n   */\n  const subscribeAll = (subscriptions: TopicSubscriptions<Event>): void => {\n    subscribeByTopic(eventBus, subscriptions);\n  };\n\n  /**\n   * Subscribe a global handler to multiple topics with optional filtering.\n   *\n   * @example\n   * ```typescript\n   * subscribeGlobal(subscriptions, {\n   *   subscriptionId: \"audit-log\",\n   *   handler: async (event) => auditLog.record(event),\n   *   filter: { exclude: [\"NotificationAdded\"] },\n   * });\n   * ```\n   */\n  const subscribeGlobal = (\n    subscriptions: TopicSubscriptions<Event>,\n    config: GlobalSubscriberConfig<Event>,\n  ): void => {\n    subscribeGlobalToTopics(eventBus, subscriptions, config);\n  };\n\n  return {\n    eventBus,\n    createNewEvent,\n    defineSubscriptions,\n    subscribeAll,\n    subscribeGlobal,\n  };\n};\n"],"mappings":"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","names":["subscriptions"]}
+{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventBus.ts"],"sourcesContent":["import {\n  type CreateNewEvent,\n  type CreateNewEventFromDefinitions,\n  makeCreateNewEvent,\n} from '../../createNewEvent.mjs';\nimport type {\n  EventDefinitions,\n  InferEventsFromDefinitions,\n} from '../../eventDefinitions.mjs';\nimport type { EventBus } from '../../ports/EventBus.mjs';\nimport type { WithEventsUow } from '../../ports/EventRepository.mjs';\nimport {\n  type GlobalSubscriberConfig,\n  subscribeByTopic,\n  subscribeGlobalToTopics,\n  type TopicSubscriptions,\n} from '../../subscriptions.mjs';\nimport type {\n  DefaultContext,\n  EventId,\n  EventPublication,\n  GenericEvent,\n  SubscriptionId,\n} from '../../types.mjs';\n\ntype SubscriptionsForTopic = Record<\n  string,\n  (event: GenericEvent<string, unknown, DefaultContext>) => Promise<void>\n>;\n\ntype CreateInMemoryEventBusOptions = {\n  maxRetries?: number;\n  getNow?: () => Date;\n  generateId?: () => EventId;\n};\n\ntype CreateInMemoryEventBusFromDefinitionsOptions<\n  Definitions extends EventDefinitions,\n> = CreateInMemoryEventBusOptions & {\n  eventDefinitions: Definitions;\n};\n\ntype CreateInMemoryEventBusResult<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  eventBus: EventBus<Event>;\n  createNewEvent: CreateNewEvent<Event>;\n  defineSubscriptions: (\n    subscriptions: TopicSubscriptions<Event>,\n  ) => TopicSubscriptions<Event>;\n  subscribeAll: (subscriptions: TopicSubscriptions<Event>) => void;\n  subscribeGlobal: (\n    subscriptions: TopicSubscriptions<Event>,\n    config: GlobalSubscriberConfig<Event>,\n  ) => void;\n};\n\nexport function createInMemoryEventBus<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  withUow: WithEventsUow<Event>,\n  options?: CreateInMemoryEventBusOptions,\n): CreateInMemoryEventBusResult<Event>;\nexport function createInMemoryEventBus<Definitions extends EventDefinitions>(\n  withUow: WithEventsUow<InferEventsFromDefinitions<Definitions>>,\n  options: CreateInMemoryEventBusFromDefinitionsOptions<Definitions>,\n): Omit<\n  CreateInMemoryEventBusResult<InferEventsFromDefinitions<Definitions>>,\n  \"createNewEvent\"\n> & {\n  createNewEvent: CreateNewEventFromDefinitions<Definitions>;\n};\nexport function createInMemoryEventBus<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  withUow: WithEventsUow<Event>,\n  options:\n    | CreateInMemoryEventBusOptions\n    | CreateInMemoryEventBusFromDefinitionsOptions<EventDefinitions> = {},\n) {\n  const maxRetries = options.maxRetries ?? 3;\n  const eventDefinitions =\n    \"eventDefinitions\" in options ? options.eventDefinitions : undefined;\n  const createNewEvent = eventDefinitions\n    ? makeCreateNewEvent({\n        getNow: options.getNow,\n        generateId: options.generateId,\n        eventDefinitions,\n      })\n    : makeCreateNewEvent<Event>({\n        getNow: options.getNow,\n        generateId: options.generateId,\n      });\n  const subscriptions: Partial<Record<string, SubscriptionsForTopic>> = {};\n\n  const executeCallback = async (\n    event: Event,\n    subscriptionId: string,\n    callback: (\n      event: GenericEvent<string, unknown, DefaultContext>,\n    ) => Promise<void>,\n  ): Promise<\n    { subscriptionId: string; errorMessage: string; stack?: string } | undefined\n  > => {\n    try {\n      await callback(event);\n    } catch (error) {\n      return {\n        subscriptionId,\n        errorMessage: error instanceof Error ? error.message : String(error),\n        stack: error instanceof Error ? error.stack : undefined,\n      };\n    }\n  };\n\n  const getSubscriptionIdsToPublish = (\n    event: Event,\n    callbacksBySubscriptionId: SubscriptionsForTopic,\n  ): string[] => {\n    const allSubscriptionIds = Object.keys(callbacksBySubscriptionId);\n\n    if (event.publications.length === 0 || event.status === \"to-republish\") {\n      return allSubscriptionIds;\n    }\n\n    const lastPublication = event.publications.reduce((latest, current) =>\n      current.publishedAt > latest.publishedAt ? current : latest,\n    );\n    const failedSubscriptionIds = (lastPublication.failures ?? []).map(\n      (failure) => failure.subscriptionId,\n    );\n\n    return allSubscriptionIds.filter((id) =>\n      failedSubscriptionIds.includes(id),\n    );\n  };\n\n  const eventBus: EventBus<Event> = {\n    publish: async (event) => {\n      const publishedAt = new Date();\n      const topic = event.topic;\n\n      const callbacksBySubscriptionSlug = subscriptions[topic];\n\n      if (!callbacksBySubscriptionSlug) {\n        event.publications.push({\n          publishedAt,\n          publishedSubscribers: [],\n        });\n        event.status = \"published\";\n        await withUow(async (uow) => {\n          await uow.eventRepository.save(event);\n        });\n        return;\n      }\n\n      const subscriptionIdsToPublish = getSubscriptionIdsToPublish(\n        event,\n        callbacksBySubscriptionSlug,\n      );\n\n      const failuresOrUndefined = await Promise.all(\n        subscriptionIdsToPublish.map((subscriptionId) =>\n          executeCallback(\n            event,\n            subscriptionId,\n            callbacksBySubscriptionSlug[subscriptionId],\n          ),\n        ),\n      );\n\n      const failures = failuresOrUndefined.filter(\n        (\n          f,\n        ): f is {\n          subscriptionId: string;\n          errorMessage: string;\n          stack?: string;\n        } => f !== undefined,\n      );\n\n      const publications: EventPublication[] = [\n        ...event.publications,\n        {\n          publishedAt,\n          publishedSubscribers: subscriptionIdsToPublish.map(\n            (id) => id as SubscriptionId,\n          ),\n          ...(failures.length > 0 && { failures }),\n        },\n      ];\n\n      if (failures.length === 0) {\n        event.status = \"published\";\n      } else {\n        const wasMaxNumberOfErrorsReached = publications.length >= maxRetries;\n        event.status = wasMaxNumberOfErrorsReached\n          ? \"quarantined\"\n          : \"failed-but-will-retry\";\n      }\n\n      event.publications = publications;\n\n      await withUow(async (uow) => {\n        await uow.eventRepository.save(event);\n      });\n    },\n\n    subscribe: ({ topic, subscriptionId, callBack }) => {\n      if (!subscriptions[topic]) {\n        subscriptions[topic] = {};\n      }\n\n      const subscriptionsForTopic = subscriptions[topic];\n      if (subscriptionsForTopic) {\n        subscriptionsForTopic[subscriptionId] = callBack as (\n          event: GenericEvent<string, unknown, DefaultContext>,\n        ) => Promise<void>;\n      }\n    },\n  };\n\n  /**\n   * Identity function for type inference when defining subscription maps.\n   * Ensures all topics are covered and handlers have correct payload types.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({\n   *   OrderCreated: [{ subscriptionId: \"notify\", handler: async (e) => {...} }],\n   *   OrderShipped: [], // Required even if empty\n   * });\n   * ```\n   */\n  const defineSubscriptions = (\n    subscriptions: TopicSubscriptions<Event>,\n  ): TopicSubscriptions<Event> => subscriptions;\n\n  /**\n   * Subscribe all handlers from a topic subscription map to this event bus.\n   *\n   * @example\n   * ```typescript\n   * const subscriptions = defineSubscriptions({...});\n   * subscribeAll(subscriptions);\n   * ```\n   */\n  const subscribeAll = (subscriptions: TopicSubscriptions<Event>): void => {\n    subscribeByTopic(eventBus, subscriptions);\n  };\n\n  /**\n   * Subscribe a global handler to multiple topics with optional filtering.\n   *\n   * @example\n   * ```typescript\n   * subscribeGlobal(subscriptions, {\n   *   subscriptionId: \"audit-log\",\n   *   handler: async (event) => auditLog.record(event),\n   *   filter: { exclude: [\"NotificationAdded\"] },\n   * });\n   * ```\n   */\n  const subscribeGlobal = (\n    subscriptions: TopicSubscriptions<Event>,\n    config: GlobalSubscriberConfig<Event>,\n  ): void => {\n    subscribeGlobalToTopics(eventBus, subscriptions, config);\n  };\n\n  return {\n    eventBus,\n    createNewEvent,\n    defineSubscriptions,\n    subscribeAll,\n    subscribeGlobal,\n  };\n}\n"],"mappings":"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","names":["subscriptions"]}

package/dist/adapters/in-memory/index.d.cts

@@ -6,6 +6,7 @@ import { EventRepository, WithEventsUow } from '../../ports/EventRepository.cjs'
 export { createInMemoryEventBus } from './InMemoryEventBus.cjs';
 export { createInMemoryEventQueries } from './InMemoryEventQueries.cjs';
 import '../../createNewEvent.cjs';
+import '../../eventDefinitions.cjs';
 import '../../ports/EventBus.cjs';
 import '../../subscriptions.cjs';
 

package/dist/adapters/in-memory/index.d.ts

@@ -6,6 +6,7 @@ import { EventRepository, WithEventsUow } from '../../ports/EventRepository.js';
 export { createInMemoryEventBus } from './InMemoryEventBus.js';
 export { createInMemoryEventQueries } from './InMemoryEventQueries.js';
 import '../../createNewEvent.js';
+import '../../eventDefinitions.js';
 import '../../ports/EventBus.js';
 import '../../subscriptions.js';
 

package/dist/adapters/kysely/KyselyEventQueries.cjs

@@ -41,6 +41,8 @@ const createKyselyEventQueries = (db) => ({
       (row) => ({
         ...row,
         context: row.context ?? void 0,
+        flowId: row.flowId ?? void 0,
+        causedByEventId: row.causedByEventId ?? void 0,
         priority: row.priority ?? void 0
       })
     );