@l-etabli/events 0.2.0 → 0.4.0

package/README.md

@@ -1,16 +1,267 @@
-# l-etabli/events
+# @l-etabli/events
 
-${project_description}
+Event-driven architecture library implementing the **outbox pattern** for TypeScript.
 
+Events are persisted in the same transaction as your domain changes, then reliably published asynchronously. No lost events, even on failures.
 
-This project is a template for creating typscript libraries.
+## Installation
 
-It uses :
+```bash
+pnpm add @l-etabli/events
+```
 
-- Typescript for type checking
-- Bun for running tests
-- Bun as a package manager
-- Biome as a formatter
-- Biome as a linter
-- Lefthook for pre-commit hooks
-- GitHub Actions for CI, which will run typecheck, format, lint, test and than deploy the package to npm
+For Kysely adapter (PostgreSQL):
+
+```bash
+pnpm add @l-etabli/events kysely pg
+```
+
+## Quick Start
+
+### 1. Define Your Events
+
+```typescript
+import { GenericEvent } from "@l-etabli/events";
+
+type MyEvents =
+  | GenericEvent<"UserCreated", { userId: string; email: string }>
+  | GenericEvent<"OrderPlaced", { orderId: string; amount: number }>;
+```
+
+### 2. Setup Event Infrastructure
+
+```typescript
+import {
+  createInMemoryEventBus,
+  createInMemoryEventRepositoryAndQueries,
+  createEventCrawler,
+} from "@l-etabli/events";
+
+const { eventQueries, withUow } = createInMemoryEventRepositoryAndQueries<MyEvents>();
+const { eventBus, createNewEvent } = createInMemoryEventBus<MyEvents>(withUow);
+
+const crawler = createEventCrawler({
+  withUow,
+  eventQueries,
+  eventBus,
+});
+```
+
+### 3. Subscribe to Events
+
+```typescript
+eventBus.subscribe({
+  topic: "OrderPlaced",
+  subscriptionId: "send-confirmation-email",
+  callBack: async (event) => {
+    await emailService.sendOrderConfirmation(event.payload.orderId);
+  },
+});
+```
+
+### 4. Emit Events (in a use case)
+
+```typescript
+await withUow(async (uow) => {
+  // Save your domain entity
+  await orderRepository.save(order);
+
+  // Emit event in the same transaction
+  await uow.eventRepository.saveNewEventsBatch([
+    createNewEvent({
+      topic: "OrderPlaced",
+      payload: { orderId: order.id, amount: order.total },
+      triggeredByUserId: currentUserId,
+    }),
+  ]);
+});
+```
+
+### 5. Process Events
+
+**Traditional server** - start background polling:
+
+```typescript
+crawler.start();
+```
+
+**Serverless** - trigger on-demand after commit:
+
+```typescript
+await withUow(
+  async (uow) => {
+    await uow.eventRepository.saveNewEventsBatch([event]);
+  },
+  {
+    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
+
+```
+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
+
+```typescript
+// Define events with topic, payload, and optional context
+type GenericEvent<Topic, Payload, Context?> = {
+  id: EventId;
+  topic: Topic;
+  payload: Payload;
+  status: EventStatus;
+  occurredAt: Date;
+  triggeredByUserId: UserId;
+  publications: EventPublication[];
+  context?: Context;
+  priority?: number;
+};
+```
+
+### `makeCreateNewEvent<Events>(options?)`
+
+Creates a type-safe event factory. Payload is validated against topic at compile time.
+
+```typescript
+const createEvent = makeCreateNewEvent<MyEvents>({
+  getNow: () => new Date(),      // optional, for testing
+  generateId: () => crypto.randomUUID(), // optional, for testing
+});
+
+// Type-safe: payload must match topic
+createEvent({ topic: "UserCreated", payload: { userId: "1", email: "a@b.com" }, triggeredByUserId: "u1" });
+```
+
+### `createInMemoryEventBus<Events>(withUow, options?)`
+
+Creates an in-memory event bus with a typed `createNewEvent` function.
+
+```typescript
+const { eventBus, createNewEvent } = createInMemoryEventBus<MyEvents>(withUow, {
+  maxRetries: 3, // default
+});
+```
+
+### `createEventCrawler(config)`
+
+Creates a background processor for publishing events.
+
+```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)
+  },
+});
+
+crawler.start();              // Start background polling
+crawler.processNewEvents();   // Manual: process new events
+crawler.retryFailedEvents();  // Manual: retry failed events
+crawler.triggerProcessing();  // Manual: process new + retry failed
+```
+
+## Database Setup (Kysely/PostgreSQL)
+
+### Migration
+
+```typescript
+import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable("events")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("topic", "text", (col) => col.notNull())
+    .addColumn("payload", "jsonb", (col) => col.notNull())
+    .addColumn("context", "jsonb")
+    .addColumn("status", "text", (col) => col.notNull())
+    .addColumn("triggeredByUserId", "text", (col) => col.notNull())
+    .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

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

@@ -31,8 +31,16 @@ const createInMemoryEventQueries = (helpers) => ({
           ([key, value]) => event.context?.[key] === value
         );
       };
+      const matchesOccurredAt = (event) => {
+        if (!filters.occurredAt) return true;
+        const { from, to } = filters.occurredAt;
+        const eventTime = event.occurredAt.getTime();
+        if (from && eventTime < from.getTime()) return false;
+        if (to && eventTime > to.getTime()) return false;
+        return true;
+      };
       return helpers.getAllEvents().filter(
-        (event) => filters.statuses.includes(event.status) && matchesContext(event)
+        (event) => filters.statuses.includes(event.status) && matchesContext(event) && matchesOccurredAt(event)
       ).slice(0, limit);
     }
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventQueries.ts"],"sourcesContent":["import type { EventQueries } from \"../../ports/EventQueries.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\nimport type { InMemoryEventRepositoryHelpers } from \"./InMemoryEventRepository.ts\";\n\nexport const createInMemoryEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  helpers: InMemoryEventRepositoryHelpers<Event>,\n): { eventQueries: EventQueries<Event> } => ({\n  eventQueries: {\n    getEvents: async ({ filters, limit }) => {\n      const matchesContext = (event: Event): boolean => {\n        if (!filters.context) return true;\n        if (!event.context) return false;\n\n        return Object.entries(filters.context).every(\n          ([key, value]) => event.context?.[key] === value,\n        );\n      };\n\n      return helpers\n        .getAllEvents()\n        .filter(\n          (event) =>\n            filters.statuses.includes(event.status) && matchesContext(event),\n        )\n        .slice(0, limit);\n    },\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIO,MAAM,6BAA6B,CAGxC,aAC2C;AAAA,EAC3C,cAAc;AAAA,IACZ,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,YAAM,iBAAiB,CAAC,UAA0B;AAChD,YAAI,CAAC,QAAQ,QAAS,QAAO;AAC7B,YAAI,CAAC,MAAM,QAAS,QAAO;AAE3B,eAAO,OAAO,QAAQ,QAAQ,OAAO,EAAE;AAAA,UACrC,CAAC,CAAC,KAAK,KAAK,MAAM,MAAM,UAAU,GAAG,MAAM;AAAA,QAC7C;AAAA,MACF;AAEA,aAAO,QACJ,aAAa,EACb;AAAA,QACC,CAAC,UACC,QAAQ,SAAS,SAAS,MAAM,MAAM,KAAK,eAAe,KAAK;AAAA,MACnE,EACC,MAAM,GAAG,KAAK;AAAA,IACnB;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventQueries.ts"],"sourcesContent":["import type { EventQueries } from \"../../ports/EventQueries.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\nimport type { InMemoryEventRepositoryHelpers } from \"./InMemoryEventRepository.ts\";\n\nexport const createInMemoryEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  helpers: InMemoryEventRepositoryHelpers<Event>,\n): { eventQueries: EventQueries<Event> } => ({\n  eventQueries: {\n    getEvents: async ({ filters, limit }) => {\n      const matchesContext = (event: Event): boolean => {\n        if (!filters.context) return true;\n        if (!event.context) return false;\n\n        return Object.entries(filters.context).every(\n          ([key, value]) => event.context?.[key] === value,\n        );\n      };\n\n      const matchesOccurredAt = (event: Event): boolean => {\n        if (!filters.occurredAt) return true;\n\n        const { from, to } = filters.occurredAt;\n        const eventTime = event.occurredAt.getTime();\n\n        if (from && eventTime < from.getTime()) return false;\n        if (to && eventTime > to.getTime()) return false;\n\n        return true;\n      };\n\n      return helpers\n        .getAllEvents()\n        .filter(\n          (event) =>\n            filters.statuses.includes(event.status) &&\n            matchesContext(event) &&\n            matchesOccurredAt(event),\n        )\n        .slice(0, limit);\n    },\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIO,MAAM,6BAA6B,CAGxC,aAC2C;AAAA,EAC3C,cAAc;AAAA,IACZ,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,YAAM,iBAAiB,CAAC,UAA0B;AAChD,YAAI,CAAC,QAAQ,QAAS,QAAO;AAC7B,YAAI,CAAC,MAAM,QAAS,QAAO;AAE3B,eAAO,OAAO,QAAQ,QAAQ,OAAO,EAAE;AAAA,UACrC,CAAC,CAAC,KAAK,KAAK,MAAM,MAAM,UAAU,GAAG,MAAM;AAAA,QAC7C;AAAA,MACF;AAEA,YAAM,oBAAoB,CAAC,UAA0B;AACnD,YAAI,CAAC,QAAQ,WAAY,QAAO;AAEhC,cAAM,EAAE,MAAM,GAAG,IAAI,QAAQ;AAC7B,cAAM,YAAY,MAAM,WAAW,QAAQ;AAE3C,YAAI,QAAQ,YAAY,KAAK,QAAQ,EAAG,QAAO;AAC/C,YAAI,MAAM,YAAY,GAAG,QAAQ,EAAG,QAAO;AAE3C,eAAO;AAAA,MACT;AAEA,aAAO,QACJ,aAAa,EACb;AAAA,QACC,CAAC,UACC,QAAQ,SAAS,SAAS,MAAM,MAAM,KACtC,eAAe,KAAK,KACpB,kBAAkB,KAAK;AAAA,MAC3B,EACC,MAAM,GAAG,KAAK;AAAA,IACnB;AAAA,EACF;AACF;","names":[]}

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

@@ -8,8 +8,16 @@ const createInMemoryEventQueries = (helpers) => ({
           ([key, value]) => event.context?.[key] === value
         );
       };
+      const matchesOccurredAt = (event) => {
+        if (!filters.occurredAt) return true;
+        const { from, to } = filters.occurredAt;
+        const eventTime = event.occurredAt.getTime();
+        if (from && eventTime < from.getTime()) return false;
+        if (to && eventTime > to.getTime()) return false;
+        return true;
+      };
       return helpers.getAllEvents().filter(
-        (event) => filters.statuses.includes(event.status) && matchesContext(event)
+        (event) => filters.statuses.includes(event.status) && matchesContext(event) && matchesOccurredAt(event)
       ).slice(0, limit);
     }
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventQueries.ts"],"sourcesContent":["import type { EventQueries } from '../../ports/EventQueries.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\nimport type { InMemoryEventRepositoryHelpers } from './InMemoryEventRepository.ts.mjs';\n\nexport const createInMemoryEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  helpers: InMemoryEventRepositoryHelpers<Event>,\n): { eventQueries: EventQueries<Event> } => ({\n  eventQueries: {\n    getEvents: async ({ filters, limit }) => {\n      const matchesContext = (event: Event): boolean => {\n        if (!filters.context) return true;\n        if (!event.context) return false;\n\n        return Object.entries(filters.context).every(\n          ([key, value]) => event.context?.[key] === value,\n        );\n      };\n\n      return helpers\n        .getAllEvents()\n        .filter(\n          (event) =>\n            filters.statuses.includes(event.status) && matchesContext(event),\n        )\n        .slice(0, limit);\n    },\n  },\n});\n"],"mappings":"AAIO,MAAM,6BAA6B,CAGxC,aAC2C;AAAA,EAC3C,cAAc;AAAA,IACZ,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,YAAM,iBAAiB,CAAC,UAA0B;AAChD,YAAI,CAAC,QAAQ,QAAS,QAAO;AAC7B,YAAI,CAAC,MAAM,QAAS,QAAO;AAE3B,eAAO,OAAO,QAAQ,QAAQ,OAAO,EAAE;AAAA,UACrC,CAAC,CAAC,KAAK,KAAK,MAAM,MAAM,UAAU,GAAG,MAAM;AAAA,QAC7C;AAAA,MACF;AAEA,aAAO,QACJ,aAAa,EACb;AAAA,QACC,CAAC,UACC,QAAQ,SAAS,SAAS,MAAM,MAAM,KAAK,eAAe,KAAK;AAAA,MACnE,EACC,MAAM,GAAG,KAAK;AAAA,IACnB;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventQueries.ts"],"sourcesContent":["import type { EventQueries } from '../../ports/EventQueries.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\nimport type { InMemoryEventRepositoryHelpers } from './InMemoryEventRepository.ts.mjs';\n\nexport const createInMemoryEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  helpers: InMemoryEventRepositoryHelpers<Event>,\n): { eventQueries: EventQueries<Event> } => ({\n  eventQueries: {\n    getEvents: async ({ filters, limit }) => {\n      const matchesContext = (event: Event): boolean => {\n        if (!filters.context) return true;\n        if (!event.context) return false;\n\n        return Object.entries(filters.context).every(\n          ([key, value]) => event.context?.[key] === value,\n        );\n      };\n\n      const matchesOccurredAt = (event: Event): boolean => {\n        if (!filters.occurredAt) return true;\n\n        const { from, to } = filters.occurredAt;\n        const eventTime = event.occurredAt.getTime();\n\n        if (from && eventTime < from.getTime()) return false;\n        if (to && eventTime > to.getTime()) return false;\n\n        return true;\n      };\n\n      return helpers\n        .getAllEvents()\n        .filter(\n          (event) =>\n            filters.statuses.includes(event.status) &&\n            matchesContext(event) &&\n            matchesOccurredAt(event),\n        )\n        .slice(0, limit);\n    },\n  },\n});\n"],"mappings":"AAIO,MAAM,6BAA6B,CAGxC,aAC2C;AAAA,EAC3C,cAAc;AAAA,IACZ,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,YAAM,iBAAiB,CAAC,UAA0B;AAChD,YAAI,CAAC,QAAQ,QAAS,QAAO;AAC7B,YAAI,CAAC,MAAM,QAAS,QAAO;AAE3B,eAAO,OAAO,QAAQ,QAAQ,OAAO,EAAE;AAAA,UACrC,CAAC,CAAC,KAAK,KAAK,MAAM,MAAM,UAAU,GAAG,MAAM;AAAA,QAC7C;AAAA,MACF;AAEA,YAAM,oBAAoB,CAAC,UAA0B;AACnD,YAAI,CAAC,QAAQ,WAAY,QAAO;AAEhC,cAAM,EAAE,MAAM,GAAG,IAAI,QAAQ;AAC7B,cAAM,YAAY,MAAM,WAAW,QAAQ;AAE3C,YAAI,QAAQ,YAAY,KAAK,QAAQ,EAAG,QAAO;AAC/C,YAAI,MAAM,YAAY,GAAG,QAAQ,EAAG,QAAO;AAE3C,eAAO;AAAA,MACT;AAEA,aAAO,QACJ,aAAa,EACb;AAAA,QACC,CAAC,UACC,QAAQ,SAAS,SAAS,MAAM,MAAM,KACtC,eAAe,KAAK,KACpB,kBAAkB,KAAK;AAAA,MAC3B,EACC,MAAM,GAAG,KAAK;AAAA,IACnB;AAAA,EACF;AACF;","names":[]}

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

@@ -55,8 +55,10 @@ const createInMemoryEventRepository = () => {
   };
 };
 const createInMemoryWithUow = (eventRepository) => {
-  const withUow = async (fn) => {
-    await fn({ eventRepository });
+  const withUow = async (fn, options) => {
+    const result = await fn({ eventRepository });
+    await options?.afterCommit?.();
+    return result;
   };
   return { withUow };
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventRepository.ts"],"sourcesContent":["import type {\n  EventRepository,\n  WithEventsUow,\n} from \"../../ports/EventRepository.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\n\nexport type InMemoryEventRepositoryHelpers<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = { getAllEvents: () => Event[]; setEvents: (events: Event[]) => void };\n\nexport const createInMemoryEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(): {\n  eventRepository: EventRepository<Event>;\n  helpers: InMemoryEventRepositoryHelpers<Event>;\n} => {\n  const eventById: Record<string, Event> = {};\n\n  const eventRepository: EventRepository<Event> = {\n    save: async (event) => {\n      eventById[event.id] = event;\n    },\n    saveNewEventsBatch: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = event;\n      });\n    },\n    markEventsAsInProcess: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = { ...event, status: \"in-process\" };\n      });\n    },\n  };\n\n  return {\n    eventRepository,\n    helpers: {\n      getAllEvents: () => Object.values(eventById),\n      setEvents: (events) => {\n        Object.keys(eventById).forEach((key) => {\n          delete eventById[key];\n        });\n\n        events.forEach((event) => {\n          eventById[event.id] = event;\n        });\n      },\n    },\n  };\n};\n\nexport const createInMemoryWithUow = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventRepository: EventRepository<Event>,\n): { withUow: WithEventsUow<Event> } => {\n  const withUow: WithEventsUow<Event> = async (fn) => {\n    await fn({ eventRepository });\n  };\n  return { withUow };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,MAAM,gCAAgC,MAKxC;AACH,QAAM,YAAmC,CAAC;AAE1C,QAAM,kBAA0C;AAAA,IAC9C,MAAM,OAAO,UAAU;AACrB,gBAAU,MAAM,EAAE,IAAI;AAAA,IACxB;AAAA,IACA,oBAAoB,OAAO,WAAW;AACpC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,IACA,uBAAuB,OAAO,WAAW;AACvC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,QAAQ,aAAa;AAAA,MACzD,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP,cAAc,MAAM,OAAO,OAAO,SAAS;AAAA,MAC3C,WAAW,CAAC,WAAW;AACrB,eAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,QAAQ;AACtC,iBAAO,UAAU,GAAG;AAAA,QACtB,CAAC;AAED,eAAO,QAAQ,CAAC,UAAU;AACxB,oBAAU,MAAM,EAAE,IAAI;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,wBAAwB,CAGnC,oBACsC;AACtC,QAAM,UAAgC,OAAO,OAAO;AAClD,UAAM,GAAG,EAAE,gBAAgB,CAAC;AAAA,EAC9B;AACA,SAAO,EAAE,QAAQ;AACnB;","names":[]}
+{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventRepository.ts"],"sourcesContent":["import type {\n  EventRepository,\n  WithEventsUow,\n} from \"../../ports/EventRepository.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\n\nexport type InMemoryEventRepositoryHelpers<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = { getAllEvents: () => Event[]; setEvents: (events: Event[]) => void };\n\nexport const createInMemoryEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(): {\n  eventRepository: EventRepository<Event>;\n  helpers: InMemoryEventRepositoryHelpers<Event>;\n} => {\n  const eventById: Record<string, Event> = {};\n\n  const eventRepository: EventRepository<Event> = {\n    save: async (event) => {\n      eventById[event.id] = event;\n    },\n    saveNewEventsBatch: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = event;\n      });\n    },\n    markEventsAsInProcess: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = { ...event, status: \"in-process\" };\n      });\n    },\n  };\n\n  return {\n    eventRepository,\n    helpers: {\n      getAllEvents: () => Object.values(eventById),\n      setEvents: (events) => {\n        Object.keys(eventById).forEach((key) => {\n          delete eventById[key];\n        });\n\n        events.forEach((event) => {\n          eventById[event.id] = event;\n        });\n      },\n    },\n  };\n};\n\nexport const createInMemoryWithUow = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventRepository: EventRepository<Event>,\n): { withUow: WithEventsUow<Event> } => {\n  // In-memory adapter awaits afterCommit for predictable test behavior\n  const withUow: WithEventsUow<Event> = async (fn, options) => {\n    const result = await fn({ eventRepository });\n    await options?.afterCommit?.();\n    return result;\n  };\n  return { withUow };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,MAAM,gCAAgC,MAKxC;AACH,QAAM,YAAmC,CAAC;AAE1C,QAAM,kBAA0C;AAAA,IAC9C,MAAM,OAAO,UAAU;AACrB,gBAAU,MAAM,EAAE,IAAI;AAAA,IACxB;AAAA,IACA,oBAAoB,OAAO,WAAW;AACpC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,IACA,uBAAuB,OAAO,WAAW;AACvC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,QAAQ,aAAa;AAAA,MACzD,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP,cAAc,MAAM,OAAO,OAAO,SAAS;AAAA,MAC3C,WAAW,CAAC,WAAW;AACrB,eAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,QAAQ;AACtC,iBAAO,UAAU,GAAG;AAAA,QACtB,CAAC;AAED,eAAO,QAAQ,CAAC,UAAU;AACxB,oBAAU,MAAM,EAAE,IAAI;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,wBAAwB,CAGnC,oBACsC;AAEtC,QAAM,UAAgC,OAAO,IAAI,YAAY;AAC3D,UAAM,SAAS,MAAM,GAAG,EAAE,gBAAgB,CAAC;AAC3C,UAAM,SAAS,cAAc;AAC7B,WAAO;AAAA,EACT;AACA,SAAO,EAAE,QAAQ;AACnB;","names":[]}

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

@@ -31,8 +31,10 @@ const createInMemoryEventRepository = () => {
   };
 };
 const createInMemoryWithUow = (eventRepository) => {
-  const withUow = async (fn) => {
-    await fn({ eventRepository });
+  const withUow = async (fn, options) => {
+    const result = await fn({ eventRepository });
+    await options?.afterCommit?.();
+    return result;
   };
   return { withUow };
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventRepository.ts"],"sourcesContent":["import type {\n  EventRepository,\n  WithEventsUow,\n} from '../../ports/EventRepository.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\n\nexport type InMemoryEventRepositoryHelpers<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = { getAllEvents: () => Event[]; setEvents: (events: Event[]) => void };\n\nexport const createInMemoryEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(): {\n  eventRepository: EventRepository<Event>;\n  helpers: InMemoryEventRepositoryHelpers<Event>;\n} => {\n  const eventById: Record<string, Event> = {};\n\n  const eventRepository: EventRepository<Event> = {\n    save: async (event) => {\n      eventById[event.id] = event;\n    },\n    saveNewEventsBatch: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = event;\n      });\n    },\n    markEventsAsInProcess: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = { ...event, status: \"in-process\" };\n      });\n    },\n  };\n\n  return {\n    eventRepository,\n    helpers: {\n      getAllEvents: () => Object.values(eventById),\n      setEvents: (events) => {\n        Object.keys(eventById).forEach((key) => {\n          delete eventById[key];\n        });\n\n        events.forEach((event) => {\n          eventById[event.id] = event;\n        });\n      },\n    },\n  };\n};\n\nexport const createInMemoryWithUow = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventRepository: EventRepository<Event>,\n): { withUow: WithEventsUow<Event> } => {\n  const withUow: WithEventsUow<Event> = async (fn) => {\n    await fn({ eventRepository });\n  };\n  return { withUow };\n};\n"],"mappings":"AAUO,MAAM,gCAAgC,MAKxC;AACH,QAAM,YAAmC,CAAC;AAE1C,QAAM,kBAA0C;AAAA,IAC9C,MAAM,OAAO,UAAU;AACrB,gBAAU,MAAM,EAAE,IAAI;AAAA,IACxB;AAAA,IACA,oBAAoB,OAAO,WAAW;AACpC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,IACA,uBAAuB,OAAO,WAAW;AACvC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,QAAQ,aAAa;AAAA,MACzD,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP,cAAc,MAAM,OAAO,OAAO,SAAS;AAAA,MAC3C,WAAW,CAAC,WAAW;AACrB,eAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,QAAQ;AACtC,iBAAO,UAAU,GAAG;AAAA,QACtB,CAAC;AAED,eAAO,QAAQ,CAAC,UAAU;AACxB,oBAAU,MAAM,EAAE,IAAI;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,wBAAwB,CAGnC,oBACsC;AACtC,QAAM,UAAgC,OAAO,OAAO;AAClD,UAAM,GAAG,EAAE,gBAAgB,CAAC;AAAA,EAC9B;AACA,SAAO,EAAE,QAAQ;AACnB;","names":[]}
+{"version":3,"sources":["../../../src/adapters/in-memory/InMemoryEventRepository.ts"],"sourcesContent":["import type {\n  EventRepository,\n  WithEventsUow,\n} from '../../ports/EventRepository.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\n\nexport type InMemoryEventRepositoryHelpers<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = { getAllEvents: () => Event[]; setEvents: (events: Event[]) => void };\n\nexport const createInMemoryEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(): {\n  eventRepository: EventRepository<Event>;\n  helpers: InMemoryEventRepositoryHelpers<Event>;\n} => {\n  const eventById: Record<string, Event> = {};\n\n  const eventRepository: EventRepository<Event> = {\n    save: async (event) => {\n      eventById[event.id] = event;\n    },\n    saveNewEventsBatch: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = event;\n      });\n    },\n    markEventsAsInProcess: async (events) => {\n      events.forEach((event) => {\n        eventById[event.id] = { ...event, status: \"in-process\" };\n      });\n    },\n  };\n\n  return {\n    eventRepository,\n    helpers: {\n      getAllEvents: () => Object.values(eventById),\n      setEvents: (events) => {\n        Object.keys(eventById).forEach((key) => {\n          delete eventById[key];\n        });\n\n        events.forEach((event) => {\n          eventById[event.id] = event;\n        });\n      },\n    },\n  };\n};\n\nexport const createInMemoryWithUow = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  eventRepository: EventRepository<Event>,\n): { withUow: WithEventsUow<Event> } => {\n  // In-memory adapter awaits afterCommit for predictable test behavior\n  const withUow: WithEventsUow<Event> = async (fn, options) => {\n    const result = await fn({ eventRepository });\n    await options?.afterCommit?.();\n    return result;\n  };\n  return { withUow };\n};\n"],"mappings":"AAUO,MAAM,gCAAgC,MAKxC;AACH,QAAM,YAAmC,CAAC;AAE1C,QAAM,kBAA0C;AAAA,IAC9C,MAAM,OAAO,UAAU;AACrB,gBAAU,MAAM,EAAE,IAAI;AAAA,IACxB;AAAA,IACA,oBAAoB,OAAO,WAAW;AACpC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,IACA,uBAAuB,OAAO,WAAW;AACvC,aAAO,QAAQ,CAAC,UAAU;AACxB,kBAAU,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,QAAQ,aAAa;AAAA,MACzD,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP,cAAc,MAAM,OAAO,OAAO,SAAS;AAAA,MAC3C,WAAW,CAAC,WAAW;AACrB,eAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,QAAQ;AACtC,iBAAO,UAAU,GAAG;AAAA,QACtB,CAAC;AAED,eAAO,QAAQ,CAAC,UAAU;AACxB,oBAAU,MAAM,EAAE,IAAI;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,wBAAwB,CAGnC,oBACsC;AAEtC,QAAM,UAAgC,OAAO,IAAI,YAAY;AAC3D,UAAM,SAAS,MAAM,GAAG,EAAE,gBAAgB,CAAC;AAC3C,UAAM,SAAS,cAAc;AAC7B,WAAO;AAAA,EACT;AACA,SAAO,EAAE,QAAQ;AACnB;","names":[]}

package/dist/adapters/kysely/KyselyEventQueries.cjs

@@ -30,6 +30,12 @@ const createKyselyEventQueries = (db) => ({
         query = query.where(import_kysely.sql`context->>${key} = ${value}`);
       }
     }
+    if (filters.occurredAt?.from) {
+      query = query.where("occurredAt", ">=", filters.occurredAt.from);
+    }
+    if (filters.occurredAt?.to) {
+      query = query.where("occurredAt", "<=", filters.occurredAt.to);
+    }
     const rows = await query.execute();
     return rows.map(
       (row) => ({

package/dist/adapters/kysely/KyselyEventQueries.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventQueries.ts"],"sourcesContent":["import type { Kysely, SqlBool } from \"kysely\";\nimport { sql } from \"kysely\";\nimport type { EventQueries } from \"../../ports/EventQueries.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\nimport type { EventsTable } from \"./types.ts\";\n\nexport const createKyselyEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventQueries<Event> => ({\n  getEvents: async ({ filters, limit }) => {\n    let query = db\n      .selectFrom(\"events\")\n      .selectAll()\n      .where(\"status\", \"in\", filters.statuses)\n      .limit(limit);\n\n    if (filters.context) {\n      for (const [key, value] of Object.entries(filters.context)) {\n        query = query.where(sql<SqlBool>`context->>${key} = ${value}`);\n      }\n    }\n\n    const rows = await query.execute();\n    return rows.map(\n      (row) =>\n        ({\n          ...row,\n          context: row.context ?? undefined,\n          priority: row.priority ?? undefined,\n        }) as Event,\n    );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAAoB;AAKb,MAAM,2BAA2B,CAGtC,QACyB;AAAA,EACzB,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,QAAI,QAAQ,GACT,WAAW,QAAQ,EACnB,UAAU,EACV,MAAM,UAAU,MAAM,QAAQ,QAAQ,EACtC,MAAM,KAAK;AAEd,QAAI,QAAQ,SAAS;AACnB,iBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AAC1D,gBAAQ,MAAM,MAAM,8BAAyB,GAAG,MAAM,KAAK,EAAE;AAAA,MAC/D;AAAA,IACF;AAEA,UAAM,OAAO,MAAM,MAAM,QAAQ;AACjC,WAAO,KAAK;AAAA,MACV,CAAC,SACE;AAAA,QACC,GAAG;AAAA,QACH,SAAS,IAAI,WAAW;AAAA,QACxB,UAAU,IAAI,YAAY;AAAA,MAC5B;AAAA,IACJ;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventQueries.ts"],"sourcesContent":["import type { Kysely, SqlBool } from \"kysely\";\nimport { sql } from \"kysely\";\nimport type { EventQueries } from \"../../ports/EventQueries.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\nimport type { EventsTable } from \"./types.ts\";\n\nexport const createKyselyEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventQueries<Event> => ({\n  getEvents: async ({ filters, limit }) => {\n    let query = db\n      .selectFrom(\"events\")\n      .selectAll()\n      .where(\"status\", \"in\", filters.statuses)\n      .limit(limit);\n\n    if (filters.context) {\n      for (const [key, value] of Object.entries(filters.context)) {\n        query = query.where(sql<SqlBool>`context->>${key} = ${value}`);\n      }\n    }\n\n    if (filters.occurredAt?.from) {\n      query = query.where(\"occurredAt\", \">=\", filters.occurredAt.from);\n    }\n\n    if (filters.occurredAt?.to) {\n      query = query.where(\"occurredAt\", \"<=\", filters.occurredAt.to);\n    }\n\n    const rows = await query.execute();\n    return rows.map(\n      (row: EventsTable[\"events\"]) =>\n        ({\n          ...row,\n          context: row.context ?? undefined,\n          priority: row.priority ?? undefined,\n        }) as Event,\n    );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAAoB;AAKb,MAAM,2BAA2B,CAGtC,QACyB;AAAA,EACzB,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,QAAI,QAAQ,GACT,WAAW,QAAQ,EACnB,UAAU,EACV,MAAM,UAAU,MAAM,QAAQ,QAAQ,EACtC,MAAM,KAAK;AAEd,QAAI,QAAQ,SAAS;AACnB,iBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AAC1D,gBAAQ,MAAM,MAAM,8BAAyB,GAAG,MAAM,KAAK,EAAE;AAAA,MAC/D;AAAA,IACF;AAEA,QAAI,QAAQ,YAAY,MAAM;AAC5B,cAAQ,MAAM,MAAM,cAAc,MAAM,QAAQ,WAAW,IAAI;AAAA,IACjE;AAEA,QAAI,QAAQ,YAAY,IAAI;AAC1B,cAAQ,MAAM,MAAM,cAAc,MAAM,QAAQ,WAAW,EAAE;AAAA,IAC/D;AAEA,UAAM,OAAO,MAAM,MAAM,QAAQ;AACjC,WAAO,KAAK;AAAA,MACV,CAAC,SACE;AAAA,QACC,GAAG;AAAA,QACH,SAAS,IAAI,WAAW;AAAA,QACxB,UAAU,IAAI,YAAY;AAAA,MAC5B;AAAA,IACJ;AAAA,EACF;AACF;","names":[]}

package/dist/adapters/kysely/KyselyEventQueries.mjs

@@ -7,6 +7,12 @@ const createKyselyEventQueries = (db) => ({
         query = query.where(sql`context->>${key} = ${value}`);
       }
     }
+    if (filters.occurredAt?.from) {
+      query = query.where("occurredAt", ">=", filters.occurredAt.from);
+    }
+    if (filters.occurredAt?.to) {
+      query = query.where("occurredAt", "<=", filters.occurredAt.to);
+    }
     const rows = await query.execute();
     return rows.map(
       (row) => ({

package/dist/adapters/kysely/KyselyEventQueries.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventQueries.ts"],"sourcesContent":["import type { Kysely, SqlBool } from \"kysely\";\nimport { sql } from \"kysely\";\nimport type { EventQueries } from '../../ports/EventQueries.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\nimport type { EventsTable } from './types.ts.mjs';\n\nexport const createKyselyEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventQueries<Event> => ({\n  getEvents: async ({ filters, limit }) => {\n    let query = db\n      .selectFrom(\"events\")\n      .selectAll()\n      .where(\"status\", \"in\", filters.statuses)\n      .limit(limit);\n\n    if (filters.context) {\n      for (const [key, value] of Object.entries(filters.context)) {\n        query = query.where(sql<SqlBool>`context->>${key} = ${value}`);\n      }\n    }\n\n    const rows = await query.execute();\n    return rows.map(\n      (row) =>\n        ({\n          ...row,\n          context: row.context ?? undefined,\n          priority: row.priority ?? undefined,\n        }) as Event,\n    );\n  },\n});\n"],"mappings":"AACA,SAAS,WAAW;AAKb,MAAM,2BAA2B,CAGtC,QACyB;AAAA,EACzB,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,QAAI,QAAQ,GACT,WAAW,QAAQ,EACnB,UAAU,EACV,MAAM,UAAU,MAAM,QAAQ,QAAQ,EACtC,MAAM,KAAK;AAEd,QAAI,QAAQ,SAAS;AACnB,iBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AAC1D,gBAAQ,MAAM,MAAM,gBAAyB,GAAG,MAAM,KAAK,EAAE;AAAA,MAC/D;AAAA,IACF;AAEA,UAAM,OAAO,MAAM,MAAM,QAAQ;AACjC,WAAO,KAAK;AAAA,MACV,CAAC,SACE;AAAA,QACC,GAAG;AAAA,QACH,SAAS,IAAI,WAAW;AAAA,QACxB,UAAU,IAAI,YAAY;AAAA,MAC5B;AAAA,IACJ;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventQueries.ts"],"sourcesContent":["import type { Kysely, SqlBool } from \"kysely\";\nimport { sql } from \"kysely\";\nimport type { EventQueries } from '../../ports/EventQueries.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\nimport type { EventsTable } from './types.ts.mjs';\n\nexport const createKyselyEventQueries = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventQueries<Event> => ({\n  getEvents: async ({ filters, limit }) => {\n    let query = db\n      .selectFrom(\"events\")\n      .selectAll()\n      .where(\"status\", \"in\", filters.statuses)\n      .limit(limit);\n\n    if (filters.context) {\n      for (const [key, value] of Object.entries(filters.context)) {\n        query = query.where(sql<SqlBool>`context->>${key} = ${value}`);\n      }\n    }\n\n    if (filters.occurredAt?.from) {\n      query = query.where(\"occurredAt\", \">=\", filters.occurredAt.from);\n    }\n\n    if (filters.occurredAt?.to) {\n      query = query.where(\"occurredAt\", \"<=\", filters.occurredAt.to);\n    }\n\n    const rows = await query.execute();\n    return rows.map(\n      (row: EventsTable[\"events\"]) =>\n        ({\n          ...row,\n          context: row.context ?? undefined,\n          priority: row.priority ?? undefined,\n        }) as Event,\n    );\n  },\n});\n"],"mappings":"AACA,SAAS,WAAW;AAKb,MAAM,2BAA2B,CAGtC,QACyB;AAAA,EACzB,WAAW,OAAO,EAAE,SAAS,MAAM,MAAM;AACvC,QAAI,QAAQ,GACT,WAAW,QAAQ,EACnB,UAAU,EACV,MAAM,UAAU,MAAM,QAAQ,QAAQ,EACtC,MAAM,KAAK;AAEd,QAAI,QAAQ,SAAS;AACnB,iBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AAC1D,gBAAQ,MAAM,MAAM,gBAAyB,GAAG,MAAM,KAAK,EAAE;AAAA,MAC/D;AAAA,IACF;AAEA,QAAI,QAAQ,YAAY,MAAM;AAC5B,cAAQ,MAAM,MAAM,cAAc,MAAM,QAAQ,WAAW,IAAI;AAAA,IACjE;AAEA,QAAI,QAAQ,YAAY,IAAI;AAC1B,cAAQ,MAAM,MAAM,cAAc,MAAM,QAAQ,WAAW,EAAE;AAAA,IAC/D;AAEA,UAAM,OAAO,MAAM,MAAM,QAAQ;AACjC,WAAO,KAAK;AAAA,MACV,CAAC,SACE;AAAA,QACC,GAAG;AAAA,QACH,SAAS,IAAI,WAAW;AAAA,QACxB,UAAU,IAAI,YAAY;AAAA,MAC5B;AAAA,IACJ;AAAA,EACF;AACF;","names":[]}

package/dist/adapters/kysely/KyselyEventRepository.cjs

@@ -43,7 +43,10 @@ const createKyselyEventRepository = (db) => ({
   markEventsAsInProcess: async (events) => {
     if (events.length === 0) return;
     const ids = events.map((e) => e.id);
-    await db.updateTable("events").set({ status: "in-process" }).where("id", "in", ids).execute();
+    const lockedRows = await db.selectFrom("events").select("id").where("id", "in", ids).forUpdate().skipLocked().execute();
+    if (lockedRows.length === 0) return;
+    const lockedIds = lockedRows.map((r) => r.id);
+    await db.updateTable("events").set({ status: "in-process" }).where("id", "in", lockedIds).execute();
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/dist/adapters/kysely/KyselyEventRepository.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventRepository.ts"],"sourcesContent":["import type { Kysely } from \"kysely\";\nimport type { EventRepository } from \"../../ports/EventRepository.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\nimport type { EventsTable } from \"./types.ts\";\n\nexport const createKyselyEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventRepository<Event> => ({\n  save: async (event) => {\n    await db\n      .insertInto(\"events\")\n      .values(event)\n      .onConflict((oc) =>\n        oc.column(\"id\").doUpdateSet({\n          topic: event.topic,\n          payload: event.payload,\n          context: event.context,\n          status: event.status,\n          triggeredByUserId: event.triggeredByUserId,\n          occurredAt: event.occurredAt,\n          publications: event.publications,\n          priority: event.priority,\n        }),\n      )\n      .execute();\n  },\n\n  saveNewEventsBatch: async (events) => {\n    if (events.length === 0) return;\n    await db.insertInto(\"events\").values(events).execute();\n  },\n\n  markEventsAsInProcess: async (events) => {\n    if (events.length === 0) return;\n    const ids = events.map((e) => e.id);\n    await db\n      .updateTable(\"events\")\n      .set({ status: \"in-process\" })\n      .where(\"id\", \"in\", ids)\n      .execute();\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,MAAM,8BAA8B,CAGzC,QAC4B;AAAA,EAC5B,MAAM,OAAO,UAAU;AACrB,UAAM,GACH,WAAW,QAAQ,EACnB,OAAO,KAAK,EACZ;AAAA,MAAW,CAAC,OACX,GAAG,OAAO,IAAI,EAAE,YAAY;AAAA,QAC1B,OAAO,MAAM;AAAA,QACb,SAAS,MAAM;AAAA,QACf,SAAS,MAAM;AAAA,QACf,QAAQ,MAAM;AAAA,QACd,mBAAmB,MAAM;AAAA,QACzB,YAAY,MAAM;AAAA,QAClB,cAAc,MAAM;AAAA,QACpB,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IACH,EACC,QAAQ;AAAA,EACb;AAAA,EAEA,oBAAoB,OAAO,WAAW;AACpC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,GAAG,WAAW,QAAQ,EAAE,OAAO,MAAM,EAAE,QAAQ;AAAA,EACvD;AAAA,EAEA,uBAAuB,OAAO,WAAW;AACvC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,MAAM,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE;AAClC,UAAM,GACH,YAAY,QAAQ,EACpB,IAAI,EAAE,QAAQ,aAAa,CAAC,EAC5B,MAAM,MAAM,MAAM,GAAG,EACrB,QAAQ;AAAA,EACb;AACF;","names":[]}
+{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventRepository.ts"],"sourcesContent":["import type { Kysely } from \"kysely\";\nimport type { EventRepository } from \"../../ports/EventRepository.ts\";\nimport type { DefaultContext, GenericEvent } from \"../../types.ts\";\nimport type { EventsTable } from \"./types.ts\";\n\nexport const createKyselyEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventRepository<Event> => ({\n  save: async (event) => {\n    await db\n      .insertInto(\"events\")\n      .values(event)\n      .onConflict((oc) =>\n        oc.column(\"id\").doUpdateSet({\n          topic: event.topic,\n          payload: event.payload,\n          context: event.context,\n          status: event.status,\n          triggeredByUserId: event.triggeredByUserId,\n          occurredAt: event.occurredAt,\n          publications: event.publications,\n          priority: event.priority,\n        }),\n      )\n      .execute();\n  },\n\n  saveNewEventsBatch: async (events) => {\n    if (events.length === 0) return;\n    await db.insertInto(\"events\").values(events).execute();\n  },\n\n  markEventsAsInProcess: async (events) => {\n    if (events.length === 0) return;\n    const ids = events.map((e) => e.id);\n\n    // Lock the rows to prevent concurrent processing\n    const lockedRows = await db\n      .selectFrom(\"events\")\n      .select(\"id\")\n      .where(\"id\", \"in\", ids)\n      .forUpdate()\n      .skipLocked()\n      .execute();\n\n    if (lockedRows.length === 0) return;\n    const lockedIds = lockedRows.map((r) => r.id);\n\n    // Update status to in-process (only for locked rows)\n    await db\n      .updateTable(\"events\")\n      .set({ status: \"in-process\" })\n      .where(\"id\", \"in\", lockedIds)\n      .execute();\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,MAAM,8BAA8B,CAGzC,QAC4B;AAAA,EAC5B,MAAM,OAAO,UAAU;AACrB,UAAM,GACH,WAAW,QAAQ,EACnB,OAAO,KAAK,EACZ;AAAA,MAAW,CAAC,OACX,GAAG,OAAO,IAAI,EAAE,YAAY;AAAA,QAC1B,OAAO,MAAM;AAAA,QACb,SAAS,MAAM;AAAA,QACf,SAAS,MAAM;AAAA,QACf,QAAQ,MAAM;AAAA,QACd,mBAAmB,MAAM;AAAA,QACzB,YAAY,MAAM;AAAA,QAClB,cAAc,MAAM;AAAA,QACpB,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IACH,EACC,QAAQ;AAAA,EACb;AAAA,EAEA,oBAAoB,OAAO,WAAW;AACpC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,GAAG,WAAW,QAAQ,EAAE,OAAO,MAAM,EAAE,QAAQ;AAAA,EACvD;AAAA,EAEA,uBAAuB,OAAO,WAAW;AACvC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,MAAM,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE;AAGlC,UAAM,aAAa,MAAM,GACtB,WAAW,QAAQ,EACnB,OAAO,IAAI,EACX,MAAM,MAAM,MAAM,GAAG,EACrB,UAAU,EACV,WAAW,EACX,QAAQ;AAEX,QAAI,WAAW,WAAW,EAAG;AAC7B,UAAM,YAAY,WAAW,IAAI,CAAC,MAAM,EAAE,EAAE;AAG5C,UAAM,GACH,YAAY,QAAQ,EACpB,IAAI,EAAE,QAAQ,aAAa,CAAC,EAC5B,MAAM,MAAM,MAAM,SAAS,EAC3B,QAAQ;AAAA,EACb;AACF;","names":[]}

package/dist/adapters/kysely/KyselyEventRepository.mjs

@@ -20,7 +20,10 @@ const createKyselyEventRepository = (db) => ({
   markEventsAsInProcess: async (events) => {
     if (events.length === 0) return;
     const ids = events.map((e) => e.id);
-    await db.updateTable("events").set({ status: "in-process" }).where("id", "in", ids).execute();
+    const lockedRows = await db.selectFrom("events").select("id").where("id", "in", ids).forUpdate().skipLocked().execute();
+    if (lockedRows.length === 0) return;
+    const lockedIds = lockedRows.map((r) => r.id);
+    await db.updateTable("events").set({ status: "in-process" }).where("id", "in", lockedIds).execute();
   }
 });
 export {

package/dist/adapters/kysely/KyselyEventRepository.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventRepository.ts"],"sourcesContent":["import type { Kysely } from \"kysely\";\nimport type { EventRepository } from '../../ports/EventRepository.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\nimport type { EventsTable } from './types.ts.mjs';\n\nexport const createKyselyEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventRepository<Event> => ({\n  save: async (event) => {\n    await db\n      .insertInto(\"events\")\n      .values(event)\n      .onConflict((oc) =>\n        oc.column(\"id\").doUpdateSet({\n          topic: event.topic,\n          payload: event.payload,\n          context: event.context,\n          status: event.status,\n          triggeredByUserId: event.triggeredByUserId,\n          occurredAt: event.occurredAt,\n          publications: event.publications,\n          priority: event.priority,\n        }),\n      )\n      .execute();\n  },\n\n  saveNewEventsBatch: async (events) => {\n    if (events.length === 0) return;\n    await db.insertInto(\"events\").values(events).execute();\n  },\n\n  markEventsAsInProcess: async (events) => {\n    if (events.length === 0) return;\n    const ids = events.map((e) => e.id);\n    await db\n      .updateTable(\"events\")\n      .set({ status: \"in-process\" })\n      .where(\"id\", \"in\", ids)\n      .execute();\n  },\n});\n"],"mappings":"AAKO,MAAM,8BAA8B,CAGzC,QAC4B;AAAA,EAC5B,MAAM,OAAO,UAAU;AACrB,UAAM,GACH,WAAW,QAAQ,EACnB,OAAO,KAAK,EACZ;AAAA,MAAW,CAAC,OACX,GAAG,OAAO,IAAI,EAAE,YAAY;AAAA,QAC1B,OAAO,MAAM;AAAA,QACb,SAAS,MAAM;AAAA,QACf,SAAS,MAAM;AAAA,QACf,QAAQ,MAAM;AAAA,QACd,mBAAmB,MAAM;AAAA,QACzB,YAAY,MAAM;AAAA,QAClB,cAAc,MAAM;AAAA,QACpB,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IACH,EACC,QAAQ;AAAA,EACb;AAAA,EAEA,oBAAoB,OAAO,WAAW;AACpC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,GAAG,WAAW,QAAQ,EAAE,OAAO,MAAM,EAAE,QAAQ;AAAA,EACvD;AAAA,EAEA,uBAAuB,OAAO,WAAW;AACvC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,MAAM,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE;AAClC,UAAM,GACH,YAAY,QAAQ,EACpB,IAAI,EAAE,QAAQ,aAAa,CAAC,EAC5B,MAAM,MAAM,MAAM,GAAG,EACrB,QAAQ;AAAA,EACb;AACF;","names":[]}
+{"version":3,"sources":["../../../src/adapters/kysely/KyselyEventRepository.ts"],"sourcesContent":["import type { Kysely } from \"kysely\";\nimport type { EventRepository } from '../../ports/EventRepository.ts.mjs';\nimport type { DefaultContext, GenericEvent } from '../../types.ts.mjs';\nimport type { EventsTable } from './types.ts.mjs';\n\nexport const createKyselyEventRepository = <\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n>(\n  db: Kysely<EventsTable>,\n): EventRepository<Event> => ({\n  save: async (event) => {\n    await db\n      .insertInto(\"events\")\n      .values(event)\n      .onConflict((oc) =>\n        oc.column(\"id\").doUpdateSet({\n          topic: event.topic,\n          payload: event.payload,\n          context: event.context,\n          status: event.status,\n          triggeredByUserId: event.triggeredByUserId,\n          occurredAt: event.occurredAt,\n          publications: event.publications,\n          priority: event.priority,\n        }),\n      )\n      .execute();\n  },\n\n  saveNewEventsBatch: async (events) => {\n    if (events.length === 0) return;\n    await db.insertInto(\"events\").values(events).execute();\n  },\n\n  markEventsAsInProcess: async (events) => {\n    if (events.length === 0) return;\n    const ids = events.map((e) => e.id);\n\n    // Lock the rows to prevent concurrent processing\n    const lockedRows = await db\n      .selectFrom(\"events\")\n      .select(\"id\")\n      .where(\"id\", \"in\", ids)\n      .forUpdate()\n      .skipLocked()\n      .execute();\n\n    if (lockedRows.length === 0) return;\n    const lockedIds = lockedRows.map((r) => r.id);\n\n    // Update status to in-process (only for locked rows)\n    await db\n      .updateTable(\"events\")\n      .set({ status: \"in-process\" })\n      .where(\"id\", \"in\", lockedIds)\n      .execute();\n  },\n});\n"],"mappings":"AAKO,MAAM,8BAA8B,CAGzC,QAC4B;AAAA,EAC5B,MAAM,OAAO,UAAU;AACrB,UAAM,GACH,WAAW,QAAQ,EACnB,OAAO,KAAK,EACZ;AAAA,MAAW,CAAC,OACX,GAAG,OAAO,IAAI,EAAE,YAAY;AAAA,QAC1B,OAAO,MAAM;AAAA,QACb,SAAS,MAAM;AAAA,QACf,SAAS,MAAM;AAAA,QACf,QAAQ,MAAM;AAAA,QACd,mBAAmB,MAAM;AAAA,QACzB,YAAY,MAAM;AAAA,QAClB,cAAc,MAAM;AAAA,QACpB,UAAU,MAAM;AAAA,MAClB,CAAC;AAAA,IACH,EACC,QAAQ;AAAA,EACb;AAAA,EAEA,oBAAoB,OAAO,WAAW;AACpC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,GAAG,WAAW,QAAQ,EAAE,OAAO,MAAM,EAAE,QAAQ;AAAA,EACvD;AAAA,EAEA,uBAAuB,OAAO,WAAW;AACvC,QAAI,OAAO,WAAW,EAAG;AACzB,UAAM,MAAM,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE;AAGlC,UAAM,aAAa,MAAM,GACtB,WAAW,QAAQ,EACnB,OAAO,IAAI,EACX,MAAM,MAAM,MAAM,GAAG,EACrB,UAAU,EACV,WAAW,EACX,QAAQ;AAEX,QAAI,WAAW,WAAW,EAAG;AAC7B,UAAM,YAAY,WAAW,IAAI,CAAC,MAAM,EAAE,EAAE;AAG5C,UAAM,GACH,YAAY,QAAQ,EACpB,IAAI,EAAE,QAAQ,aAAa,CAAC,EAC5B,MAAM,MAAM,MAAM,SAAS,EAC3B,QAAQ;AAAA,EACb;AACF;","names":[]}

package/dist/createEventCrawler.cjs

@@ -56,13 +56,27 @@ const createEventCrawler = ({
     await publishEventsInParallel(events);
   };
   const retryFailedEvents = async () => {
+    const oneMinuteAgo = new Date(Date.now() - 6e4);
     const events = await eventQueries.getEvents({
-      filters: { statuses: ["to-republish", "failed-but-will-retry"] },
+      filters: {
+        statuses: ["to-republish", "failed-but-will-retry"],
+        occurredAt: { to: oneMinuteAgo }
+      },
       limit: batchSize
     });
     if (events.length === 0) return;
     await publishEventsInParallel(events);
   };
+  const triggerProcessing = async () => {
+    const results = await Promise.allSettled([
+      processNewEvents(),
+      retryFailedEvents()
+    ]);
+    const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "Event processing failed");
+    }
+  };
   const start = () => {
     const scheduleProcessNewEvents = () => {
       setTimeout(async () => {
@@ -92,6 +106,7 @@ const createEventCrawler = ({
   return {
     processNewEvents,
     retryFailedEvents,
+    triggerProcessing,
     start
   };
 };

package/dist/createEventCrawler.cjs.map

@@ -1 +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":[]}
+{"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 (for traditional server environments)\n * - `processNewEvents()`: Manually trigger new event processing\n * - `retryFailedEvents()`: Manually trigger failed event retry\n * - `triggerProcessing()`: Process both new and failed events (for serverless environments)\n *\n * @example\n * ```typescript\n * const crawler = createEventCrawler({\n *   withUow,\n *   eventQueries,\n *   eventBus,\n *   options: { batchSize: 50, newEventsIntervalMs: 5000 },\n * });\n *\n * // Traditional server mode: Start background processing\n * crawler.start();\n *\n * // Serverless mode: Trigger on-demand after saving events\n * await withUow(async (uow) => {\n *   await uow.eventRepository.save(event);\n * }, {\n *   afterCommit: () => {\n *     crawler.triggerProcessing().catch(console.error);\n *   }\n * });\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 oneMinuteAgo = new Date(Date.now() - 60_000);\n\n    const events = await eventQueries.getEvents({\n      filters: {\n        statuses: [\"to-republish\", \"failed-but-will-retry\"],\n        occurredAt: { to: oneMinuteAgo },\n      },\n      limit: batchSize,\n    });\n\n    if (events.length === 0) return;\n\n    await publishEventsInParallel(events);\n  };\n\n  const triggerProcessing = async (): Promise<void> => {\n    // Use Promise.allSettled to ensure both processing steps run independently\n    // If processNewEvents fails, retryFailedEvents will still execute\n    const results = await Promise.allSettled([\n      processNewEvents(),\n      retryFailedEvents(),\n    ]);\n\n    // Re-throw if both failed\n    const errors = results\n      .filter((r) => r.status === \"rejected\")\n      .map((r) => (r as PromiseRejectedResult).reason);\n\n    if (errors.length > 0) {\n      throw new AggregateError(errors, \"Event processing failed\");\n    }\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    triggerProcessing,\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;AAwCO,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,eAAe,IAAI,KAAK,KAAK,IAAI,IAAI,GAAM;AAEjD,UAAM,SAAS,MAAM,aAAa,UAAU;AAAA,MAC1C,SAAS;AAAA,QACP,UAAU,CAAC,gBAAgB,uBAAuB;AAAA,QAClD,YAAY,EAAE,IAAI,aAAa;AAAA,MACjC;AAAA,MACA,OAAO;AAAA,IACT,CAAC;AAED,QAAI,OAAO,WAAW,EAAG;AAEzB,UAAM,wBAAwB,MAAM;AAAA,EACtC;AAEA,QAAM,oBAAoB,YAA2B;AAGnD,UAAM,UAAU,MAAM,QAAQ,WAAW;AAAA,MACvC,iBAAiB;AAAA,MACjB,kBAAkB;AAAA,IACpB,CAAC;AAGD,UAAM,SAAS,QACZ,OAAO,CAAC,MAAM,EAAE,WAAW,UAAU,EACrC,IAAI,CAAC,MAAO,EAA4B,MAAM;AAEjD,QAAI,OAAO,SAAS,GAAG;AACrB,YAAM,IAAI,eAAe,QAAQ,yBAAyB;AAAA,IAC5D;AAAA,EACF;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,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/createEventCrawler.d.cts

@@ -22,9 +22,10 @@ type CreateEventCrawlerOptions = {
  * 2. Retry failed events: polls for failed events and retries them
  *
  * @returns Object with:
- * - `start()`: Start the background polling loops
+ * - `start()`: Start the background polling loops (for traditional server environments)
  * - `processNewEvents()`: Manually trigger new event processing
  * - `retryFailedEvents()`: Manually trigger failed event retry
+ * - `triggerProcessing()`: Process both new and failed events (for serverless environments)
  *
  * @example
  * ```typescript
@@ -35,9 +36,18 @@ type CreateEventCrawlerOptions = {
  *   options: { batchSize: 50, newEventsIntervalMs: 5000 },
  * });
  *
- * // Start background processing
+ * // Traditional server mode: Start background processing
  * crawler.start();
  *
+ * // Serverless mode: Trigger on-demand after saving events
+ * await withUow(async (uow) => {
+ *   await uow.eventRepository.save(event);
+ * }, {
+ *   afterCommit: () => {
+ *     crawler.triggerProcessing().catch(console.error);
+ *   }
+ * });
+ *
  * // Or trigger manually (useful for testing)
  * await crawler.processNewEvents();
  * ```
@@ -50,6 +60,7 @@ declare const createEventCrawler: <Event extends GenericEvent<string, unknown, D
 }) => {
     processNewEvents: () => Promise<void>;
     retryFailedEvents: () => Promise<void>;
+    triggerProcessing: () => Promise<void>;
     start: () => void;
 };
 

package/dist/createEventCrawler.d.ts

@@ -22,9 +22,10 @@ type CreateEventCrawlerOptions = {
  * 2. Retry failed events: polls for failed events and retries them
  *
  * @returns Object with:
- * - `start()`: Start the background polling loops
+ * - `start()`: Start the background polling loops (for traditional server environments)
  * - `processNewEvents()`: Manually trigger new event processing
  * - `retryFailedEvents()`: Manually trigger failed event retry
+ * - `triggerProcessing()`: Process both new and failed events (for serverless environments)
  *
  * @example
  * ```typescript
@@ -35,9 +36,18 @@ type CreateEventCrawlerOptions = {
  *   options: { batchSize: 50, newEventsIntervalMs: 5000 },
  * });
  *
- * // Start background processing
+ * // Traditional server mode: Start background processing
  * crawler.start();
  *
+ * // Serverless mode: Trigger on-demand after saving events
+ * await withUow(async (uow) => {
+ *   await uow.eventRepository.save(event);
+ * }, {
+ *   afterCommit: () => {
+ *     crawler.triggerProcessing().catch(console.error);
+ *   }
+ * });
+ *
  * // Or trigger manually (useful for testing)
  * await crawler.processNewEvents();
  * ```
@@ -50,6 +60,7 @@ declare const createEventCrawler: <Event extends GenericEvent<string, unknown, D
 }) => {
     processNewEvents: () => Promise<void>;
     retryFailedEvents: () => Promise<void>;
+    triggerProcessing: () => Promise<void>;
     start: () => void;
 };
 

package/dist/createEventCrawler.mjs

@@ -33,13 +33,27 @@ const createEventCrawler = ({
     await publishEventsInParallel(events);
   };
   const retryFailedEvents = async () => {
+    const oneMinuteAgo = new Date(Date.now() - 6e4);
     const events = await eventQueries.getEvents({
-      filters: { statuses: ["to-republish", "failed-but-will-retry"] },
+      filters: {
+        statuses: ["to-republish", "failed-but-will-retry"],
+        occurredAt: { to: oneMinuteAgo }
+      },
       limit: batchSize
     });
     if (events.length === 0) return;
     await publishEventsInParallel(events);
   };
+  const triggerProcessing = async () => {
+    const results = await Promise.allSettled([
+      processNewEvents(),
+      retryFailedEvents()
+    ]);
+    const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "Event processing failed");
+    }
+  };
   const start = () => {
     const scheduleProcessNewEvents = () => {
       setTimeout(async () => {
@@ -69,6 +83,7 @@ const createEventCrawler = ({
   return {
     processNewEvents,
     retryFailedEvents,
+    triggerProcessing,
     start
   };
 };

package/dist/createEventCrawler.mjs.map

@@ -1 +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":[]}
+{"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 (for traditional server environments)\n * - `processNewEvents()`: Manually trigger new event processing\n * - `retryFailedEvents()`: Manually trigger failed event retry\n * - `triggerProcessing()`: Process both new and failed events (for serverless environments)\n *\n * @example\n * ```typescript\n * const crawler = createEventCrawler({\n *   withUow,\n *   eventQueries,\n *   eventBus,\n *   options: { batchSize: 50, newEventsIntervalMs: 5000 },\n * });\n *\n * // Traditional server mode: Start background processing\n * crawler.start();\n *\n * // Serverless mode: Trigger on-demand after saving events\n * await withUow(async (uow) => {\n *   await uow.eventRepository.save(event);\n * }, {\n *   afterCommit: () => {\n *     crawler.triggerProcessing().catch(console.error);\n *   }\n * });\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 oneMinuteAgo = new Date(Date.now() - 60_000);\n\n    const events = await eventQueries.getEvents({\n      filters: {\n        statuses: [\"to-republish\", \"failed-but-will-retry\"],\n        occurredAt: { to: oneMinuteAgo },\n      },\n      limit: batchSize,\n    });\n\n    if (events.length === 0) return;\n\n    await publishEventsInParallel(events);\n  };\n\n  const triggerProcessing = async (): Promise<void> => {\n    // Use Promise.allSettled to ensure both processing steps run independently\n    // If processNewEvents fails, retryFailedEvents will still execute\n    const results = await Promise.allSettled([\n      processNewEvents(),\n      retryFailedEvents(),\n    ]);\n\n    // Re-throw if both failed\n    const errors = results\n      .filter((r) => r.status === \"rejected\")\n      .map((r) => (r as PromiseRejectedResult).reason);\n\n    if (errors.length > 0) {\n      throw new AggregateError(errors, \"Event processing failed\");\n    }\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    triggerProcessing,\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;AAwCO,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,eAAe,IAAI,KAAK,KAAK,IAAI,IAAI,GAAM;AAEjD,UAAM,SAAS,MAAM,aAAa,UAAU;AAAA,MAC1C,SAAS;AAAA,QACP,UAAU,CAAC,gBAAgB,uBAAuB;AAAA,QAClD,YAAY,EAAE,IAAI,aAAa;AAAA,MACjC;AAAA,MACA,OAAO;AAAA,IACT,CAAC;AAED,QAAI,OAAO,WAAW,EAAG;AAEzB,UAAM,wBAAwB,MAAM;AAAA,EACtC;AAEA,QAAM,oBAAoB,YAA2B;AAGnD,UAAM,UAAU,MAAM,QAAQ,WAAW;AAAA,MACvC,iBAAiB;AAAA,MACjB,kBAAkB;AAAA,IACpB,CAAC;AAGD,UAAM,SAAS,QACZ,OAAO,CAAC,MAAM,EAAE,WAAW,UAAU,EACrC,IAAI,CAAC,MAAO,EAA4B,MAAM;AAEjD,QAAI,OAAO,SAAS,GAAG;AACrB,YAAM,IAAI,eAAe,QAAQ,yBAAyB;AAAA,IAC5D;AAAA,EACF;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,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.cts

@@ -3,7 +3,7 @@ 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 { EventRepository, EventsUnitOfWork, WithEventsUow, WithEventsUowOptions } 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';

package/dist/index.d.ts

@@ -3,7 +3,7 @@ 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 { EventRepository, EventsUnitOfWork, WithEventsUow, WithEventsUowOptions } 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';

package/dist/ports/EventQueries.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/ports/EventQueries.ts"],"sourcesContent":["import type { DefaultContext, EventStatus, GenericEvent } from \"../types.ts\";\n\n/** Parameters for querying events. */\ntype GetEventsParams = {\n  filters: {\n    /** Filter by event status (e.g., [\"never-published\", \"failed-but-will-retry\"]). */\n    statuses: EventStatus[];\n    /** Optional context filter for multi-tenant scenarios. */\n    context?: Partial<Record<string, string>>;\n  };\n  /** Maximum number of events to return. */\n  limit: number;\n};\n\n/**\n * Query interface for reading events.\n * Used by the event crawler to fetch events for processing.\n * Implement this to query events from your database.\n */\nexport type EventQueries<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  /** Fetch events matching the given filters. */\n  getEvents: (params: GetEventsParams) => Promise<Event[]>;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../../src/ports/EventQueries.ts"],"sourcesContent":["import type { DefaultContext, EventStatus, GenericEvent } from \"../types.ts\";\n\n/** Parameters for querying events. */\ntype GetEventsParams = {\n  filters: {\n    /** Filter by event status (e.g., [\"never-published\", \"failed-but-will-retry\"]). */\n    statuses: EventStatus[];\n    /** Optional context filter for multi-tenant scenarios. */\n    context?: Partial<Record<string, string>>;\n    /** Optional time-based filter for when events occurred. */\n    occurredAt?: {\n      /** Include events that occurred on or after this date. */\n      from?: Date;\n      /** Include events that occurred on or before this date. */\n      to?: Date;\n    };\n  };\n  /** Maximum number of events to return. */\n  limit: number;\n};\n\n/**\n * Query interface for reading events.\n * Used by the event crawler to fetch events for processing.\n * Implement this to query events from your database.\n */\nexport type EventQueries<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  /** Fetch events matching the given filters. */\n  getEvents: (params: GetEventsParams) => Promise<Event[]>;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/ports/EventQueries.d.cts

@@ -7,6 +7,13 @@ type GetEventsParams = {
         statuses: EventStatus[];
         /** Optional context filter for multi-tenant scenarios. */
         context?: Partial<Record<string, string>>;
+        /** Optional time-based filter for when events occurred. */
+        occurredAt?: {
+            /** Include events that occurred on or after this date. */
+            from?: Date;
+            /** Include events that occurred on or before this date. */
+            to?: Date;
+        };
     };
     /** Maximum number of events to return. */
     limit: number;

package/dist/ports/EventQueries.d.ts

@@ -7,6 +7,13 @@ type GetEventsParams = {
         statuses: EventStatus[];
         /** Optional context filter for multi-tenant scenarios. */
         context?: Partial<Record<string, string>>;
+        /** Optional time-based filter for when events occurred. */
+        occurredAt?: {
+            /** Include events that occurred on or after this date. */
+            from?: Date;
+            /** Include events that occurred on or before this date. */
+            to?: Date;
+        };
     };
     /** Maximum number of events to return. */
     limit: number;

package/dist/ports/EventRepository.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/ports/EventRepository.ts"],"sourcesContent":["import type { DefaultContext, GenericEvent } from \"../types.ts\";\n\n/**\n * Repository interface for persisting events.\n * Implement this to store events in your database (e.g., PostgreSQL, MongoDB).\n * Events should be saved in the same transaction as your domain changes.\n */\nexport type EventRepository<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  /** Persist a single event (typically after publication status update). */\n  save: (event: Event) => Promise<void>;\n  /** Persist multiple new events in a batch. */\n  saveNewEventsBatch: (events: Event[]) => Promise<void>;\n  /** Mark events as \"in-process\" before publishing (prevents duplicate processing). */\n  markEventsAsInProcess: (events: Event[]) => Promise<void>;\n};\n\n/**\n * Unit of work containing the event repository.\n * Extend this with your own repositories for transactional consistency.\n */\nexport type EventsUnitOfWork<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  eventRepository: EventRepository<Event>;\n};\n\n/**\n * Higher-order function that provides a unit of work for transactional operations.\n * Your implementation should handle transaction begin/commit/rollback.\n *\n * @example\n * ```typescript\n * const withUow: WithEventsUow<MyEvent> = async (fn) => {\n *   const tx = await db.beginTransaction();\n *   try {\n *     await fn({ eventRepository: createEventRepo(tx) });\n *     await tx.commit();\n *   } catch (e) {\n *     await tx.rollback();\n *     throw e;\n *   }\n * };\n * ```\n */\nexport type WithEventsUow<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = (fn: (uow: EventsUnitOfWork<Event>) => Promise<void>) => Promise<void>;\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../../src/ports/EventRepository.ts"],"sourcesContent":["import type { DefaultContext, GenericEvent } from \"../types.ts\";\n\n/**\n * Repository interface for persisting events.\n * Implement this to store events in your database (e.g., PostgreSQL, MongoDB).\n * Events should be saved in the same transaction as your domain changes.\n */\nexport type EventRepository<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  /** Persist a single event (typically after publication status update). */\n  save: (event: Event) => Promise<void>;\n  /** Persist multiple new events in a batch. */\n  saveNewEventsBatch: (events: Event[]) => Promise<void>;\n  /** Mark events as \"in-process\" before publishing (prevents duplicate processing). */\n  markEventsAsInProcess: (events: Event[]) => Promise<void>;\n};\n\n/**\n * Unit of work containing the event repository.\n * Extend this with your own repositories for transactional consistency.\n */\nexport type EventsUnitOfWork<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = {\n  eventRepository: EventRepository<Event>;\n};\n\n/**\n * Options for unit of work execution.\n */\nexport type WithEventsUowOptions = {\n  /**\n   * Callback executed after successful transaction commit.\n   * Useful for triggering event processing in serverless environments.\n   *\n   * The callback should return a Promise. Whether it's awaited depends on\n   * the withUow implementation:\n   * - Serverless (Lambda): await to ensure completion before runtime freezes\n   * - Long-running servers: fire-and-forget for faster response times\n   *\n   * @example\n   * ```typescript\n   * await withUow(async (uow) => {\n   *   await uow.eventRepository.save(event);\n   * }, {\n   *   afterCommit: async () => {\n   *     await eventCrawler.triggerProcessing();\n   *   }\n   * });\n   * ```\n   */\n  afterCommit?: () => Promise<void>;\n};\n\n/**\n * Higher-order function that provides a unit of work for transactional operations.\n * Your implementation should handle transaction begin/commit/rollback.\n *\n * @example\n * ```typescript\n * const withUow: WithEventsUow<MyEvent> = async (fn, options) => {\n *   const tx = await db.beginTransaction();\n *   try {\n *     const result = await fn({ eventRepository: createEventRepo(tx) });\n *     await tx.commit();\n *     await options?.afterCommit?.();\n *     return result;\n *   } catch (e) {\n *     await tx.rollback();\n *     throw e;\n *   }\n * };\n * ```\n */\nexport type WithEventsUow<\n  Event extends GenericEvent<string, unknown, DefaultContext>,\n> = <T>(\n  fn: (uow: EventsUnitOfWork<Event>) => Promise<T>,\n  options?: WithEventsUowOptions,\n) => Promise<T>;\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/ports/EventRepository.d.cts

@@ -20,17 +20,45 @@ type EventRepository<Event extends GenericEvent<string, unknown, DefaultContext>
 type EventsUnitOfWork<Event extends GenericEvent<string, unknown, DefaultContext>> = {
     eventRepository: EventRepository<Event>;
 };
+/**
+ * Options for unit of work execution.
+ */
+type WithEventsUowOptions = {
+    /**
+     * Callback executed after successful transaction commit.
+     * Useful for triggering event processing in serverless environments.
+     *
+     * The callback should return a Promise. Whether it's awaited depends on
+     * the withUow implementation:
+     * - Serverless (Lambda): await to ensure completion before runtime freezes
+     * - Long-running servers: fire-and-forget for faster response times
+     *
+     * @example
+     * ```typescript
+     * await withUow(async (uow) => {
+     *   await uow.eventRepository.save(event);
+     * }, {
+     *   afterCommit: async () => {
+     *     await eventCrawler.triggerProcessing();
+     *   }
+     * });
+     * ```
+     */
+    afterCommit?: () => Promise<void>;
+};
 /**
  * Higher-order function that provides a unit of work for transactional operations.
  * Your implementation should handle transaction begin/commit/rollback.
  *
  * @example
  * ```typescript
- * const withUow: WithEventsUow<MyEvent> = async (fn) => {
+ * const withUow: WithEventsUow<MyEvent> = async (fn, options) => {
  *   const tx = await db.beginTransaction();
  *   try {
- *     await fn({ eventRepository: createEventRepo(tx) });
+ *     const result = await fn({ eventRepository: createEventRepo(tx) });
  *     await tx.commit();
+ *     await options?.afterCommit?.();
+ *     return result;
  *   } catch (e) {
  *     await tx.rollback();
  *     throw e;
@@ -38,6 +66,6 @@ type EventsUnitOfWork<Event extends GenericEvent<string, unknown, DefaultContext
  * };
  * ```
  */
-type WithEventsUow<Event extends GenericEvent<string, unknown, DefaultContext>> = (fn: (uow: EventsUnitOfWork<Event>) => Promise<void>) => Promise<void>;
+type WithEventsUow<Event extends GenericEvent<string, unknown, DefaultContext>> = <T>(fn: (uow: EventsUnitOfWork<Event>) => Promise<T>, options?: WithEventsUowOptions) => Promise<T>;
 
-export type { EventRepository, EventsUnitOfWork, WithEventsUow };
+export type { EventRepository, EventsUnitOfWork, WithEventsUow, WithEventsUowOptions };

package/dist/ports/EventRepository.d.ts

@@ -20,17 +20,45 @@ type EventRepository<Event extends GenericEvent<string, unknown, DefaultContext>
 type EventsUnitOfWork<Event extends GenericEvent<string, unknown, DefaultContext>> = {
     eventRepository: EventRepository<Event>;
 };
+/**
+ * Options for unit of work execution.
+ */
+type WithEventsUowOptions = {
+    /**
+     * Callback executed after successful transaction commit.
+     * Useful for triggering event processing in serverless environments.
+     *
+     * The callback should return a Promise. Whether it's awaited depends on
+     * the withUow implementation:
+     * - Serverless (Lambda): await to ensure completion before runtime freezes
+     * - Long-running servers: fire-and-forget for faster response times
+     *
+     * @example
+     * ```typescript
+     * await withUow(async (uow) => {
+     *   await uow.eventRepository.save(event);
+     * }, {
+     *   afterCommit: async () => {
+     *     await eventCrawler.triggerProcessing();
+     *   }
+     * });
+     * ```
+     */
+    afterCommit?: () => Promise<void>;
+};
 /**
  * Higher-order function that provides a unit of work for transactional operations.
  * Your implementation should handle transaction begin/commit/rollback.
  *
  * @example
  * ```typescript
- * const withUow: WithEventsUow<MyEvent> = async (fn) => {
+ * const withUow: WithEventsUow<MyEvent> = async (fn, options) => {
  *   const tx = await db.beginTransaction();
  *   try {
- *     await fn({ eventRepository: createEventRepo(tx) });
+ *     const result = await fn({ eventRepository: createEventRepo(tx) });
  *     await tx.commit();
+ *     await options?.afterCommit?.();
+ *     return result;
  *   } catch (e) {
  *     await tx.rollback();
  *     throw e;
@@ -38,6 +66,6 @@ type EventsUnitOfWork<Event extends GenericEvent<string, unknown, DefaultContext
  * };
  * ```
  */
-type WithEventsUow<Event extends GenericEvent<string, unknown, DefaultContext>> = (fn: (uow: EventsUnitOfWork<Event>) => Promise<void>) => Promise<void>;
+type WithEventsUow<Event extends GenericEvent<string, unknown, DefaultContext>> = <T>(fn: (uow: EventsUnitOfWork<Event>) => Promise<T>, options?: WithEventsUowOptions) => Promise<T>;
 
-export type { EventRepository, EventsUnitOfWork, WithEventsUow };
+export type { EventRepository, EventsUnitOfWork, WithEventsUow, WithEventsUowOptions };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@l-etabli/events",
-  "description": "The purpose of this repositiory is to make it easy to setup event driven architecture using outbox pattern",
+  "description": "The purpose of this repository is to make it easy to setup event driven architecture using outbox pattern",
   "module": "src/index.ts",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
@@ -28,8 +28,9 @@
     "check": "biome check",
     "check:fix": "biome check --fix --no-errors-on-unmatched --files-ignore-unknown=true",
     "test": "bun test",
+    "test:integration": "bun test .integration.test.ts",
     "typecheck": "tsc --noEmit",
-    "fullcheck": "bun run check:fix && bun run typecheck && bun test --bail tests/ --exclude '**/kyselyAdapter.test.ts'",
+    "fullcheck": "bun run check:fix && bun run typecheck && bun test --bail $(find tests -name '*.test.ts' ! -name '*.integration.test.ts')",
     "release": "semantic-release"
   },
   "devDependencies": {

package/src/adapters/in-memory/InMemoryEventQueries.ts

@@ -18,11 +18,25 @@ export const createInMemoryEventQueries = <
         );
       };
 
+      const matchesOccurredAt = (event: Event): boolean => {
+        if (!filters.occurredAt) return true;
+
+        const { from, to } = filters.occurredAt;
+        const eventTime = event.occurredAt.getTime();
+
+        if (from && eventTime < from.getTime()) return false;
+        if (to && eventTime > to.getTime()) return false;
+
+        return true;
+      };
+
       return helpers
         .getAllEvents()
         .filter(
           (event) =>
-            filters.statuses.includes(event.status) && matchesContext(event),
+            filters.statuses.includes(event.status) &&
+            matchesContext(event) &&
+            matchesOccurredAt(event),
         )
         .slice(0, limit);
     },

package/src/adapters/in-memory/InMemoryEventRepository.ts

@@ -54,8 +54,11 @@ export const createInMemoryWithUow = <
 >(
   eventRepository: EventRepository<Event>,
 ): { withUow: WithEventsUow<Event> } => {
-  const withUow: WithEventsUow<Event> = async (fn) => {
-    await fn({ eventRepository });
+  // In-memory adapter awaits afterCommit for predictable test behavior
+  const withUow: WithEventsUow<Event> = async (fn, options) => {
+    const result = await fn({ eventRepository });
+    await options?.afterCommit?.();
+    return result;
   };
   return { withUow };
 };

package/src/adapters/kysely/KyselyEventQueries.ts

@@ -22,9 +22,17 @@ export const createKyselyEventQueries = <
       }
     }
 
+    if (filters.occurredAt?.from) {
+      query = query.where("occurredAt", ">=", filters.occurredAt.from);
+    }
+
+    if (filters.occurredAt?.to) {
+      query = query.where("occurredAt", "<=", filters.occurredAt.to);
+    }
+
     const rows = await query.execute();
     return rows.map(
-      (row) =>
+      (row: EventsTable["events"]) =>
         ({
           ...row,
           context: row.context ?? undefined,

package/src/adapters/kysely/KyselyEventRepository.ts

@@ -35,10 +35,24 @@ export const createKyselyEventRepository = <
   markEventsAsInProcess: async (events) => {
     if (events.length === 0) return;
     const ids = events.map((e) => e.id);
+
+    // Lock the rows to prevent concurrent processing
+    const lockedRows = await db
+      .selectFrom("events")
+      .select("id")
+      .where("id", "in", ids)
+      .forUpdate()
+      .skipLocked()
+      .execute();
+
+    if (lockedRows.length === 0) return;
+    const lockedIds = lockedRows.map((r) => r.id);
+
+    // Update status to in-process (only for locked rows)
     await db
       .updateTable("events")
       .set({ status: "in-process" })
-      .where("id", "in", ids)
+      .where("id", "in", lockedIds)
       .execute();
   },
 });

package/src/createEventCrawler.ts

@@ -31,9 +31,10 @@ const splitIntoChunks = <T>(array: T[], chunkSize: number): T[][] => {
  * 2. Retry failed events: polls for failed events and retries them
  *
  * @returns Object with:
- * - `start()`: Start the background polling loops
+ * - `start()`: Start the background polling loops (for traditional server environments)
  * - `processNewEvents()`: Manually trigger new event processing
  * - `retryFailedEvents()`: Manually trigger failed event retry
+ * - `triggerProcessing()`: Process both new and failed events (for serverless environments)
  *
  * @example
  * ```typescript
@@ -44,9 +45,18 @@ const splitIntoChunks = <T>(array: T[], chunkSize: number): T[][] => {
  *   options: { batchSize: 50, newEventsIntervalMs: 5000 },
  * });
  *
- * // Start background processing
+ * // Traditional server mode: Start background processing
  * crawler.start();
  *
+ * // Serverless mode: Trigger on-demand after saving events
+ * await withUow(async (uow) => {
+ *   await uow.eventRepository.save(event);
+ * }, {
+ *   afterCommit: () => {
+ *     crawler.triggerProcessing().catch(console.error);
+ *   }
+ * });
+ *
  * // Or trigger manually (useful for testing)
  * await crawler.processNewEvents();
  * ```
@@ -92,8 +102,13 @@ export const createEventCrawler = <
   };
 
   const retryFailedEvents = async (): Promise<void> => {
+    const oneMinuteAgo = new Date(Date.now() - 60_000);
+
     const events = await eventQueries.getEvents({
-      filters: { statuses: ["to-republish", "failed-but-will-retry"] },
+      filters: {
+        statuses: ["to-republish", "failed-but-will-retry"],
+        occurredAt: { to: oneMinuteAgo },
+      },
       limit: batchSize,
     });
 
@@ -102,6 +117,24 @@ export const createEventCrawler = <
     await publishEventsInParallel(events);
   };
 
+  const triggerProcessing = async (): Promise<void> => {
+    // Use Promise.allSettled to ensure both processing steps run independently
+    // If processNewEvents fails, retryFailedEvents will still execute
+    const results = await Promise.allSettled([
+      processNewEvents(),
+      retryFailedEvents(),
+    ]);
+
+    // Re-throw if both failed
+    const errors = results
+      .filter((r) => r.status === "rejected")
+      .map((r) => (r as PromiseRejectedResult).reason);
+
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "Event processing failed");
+    }
+  };
+
   const start = () => {
     const scheduleProcessNewEvents = () => {
       setTimeout(async () => {
@@ -134,6 +167,7 @@ export const createEventCrawler = <
   return {
     processNewEvents,
     retryFailedEvents,
+    triggerProcessing,
     start,
   };
 };

package/src/ports/EventQueries.ts

@@ -7,6 +7,13 @@ type GetEventsParams = {
     statuses: EventStatus[];
     /** Optional context filter for multi-tenant scenarios. */
     context?: Partial<Record<string, string>>;
+    /** Optional time-based filter for when events occurred. */
+    occurredAt?: {
+      /** Include events that occurred on or after this date. */
+      from?: Date;
+      /** Include events that occurred on or before this date. */
+      to?: Date;
+    };
   };
   /** Maximum number of events to return. */
   limit: number;

package/src/ports/EventRepository.ts

@@ -26,17 +26,46 @@ export type EventsUnitOfWork<
   eventRepository: EventRepository<Event>;
 };
 
+/**
+ * Options for unit of work execution.
+ */
+export type WithEventsUowOptions = {
+  /**
+   * Callback executed after successful transaction commit.
+   * Useful for triggering event processing in serverless environments.
+   *
+   * The callback should return a Promise. Whether it's awaited depends on
+   * the withUow implementation:
+   * - Serverless (Lambda): await to ensure completion before runtime freezes
+   * - Long-running servers: fire-and-forget for faster response times
+   *
+   * @example
+   * ```typescript
+   * await withUow(async (uow) => {
+   *   await uow.eventRepository.save(event);
+   * }, {
+   *   afterCommit: async () => {
+   *     await eventCrawler.triggerProcessing();
+   *   }
+   * });
+   * ```
+   */
+  afterCommit?: () => Promise<void>;
+};
+
 /**
  * Higher-order function that provides a unit of work for transactional operations.
  * Your implementation should handle transaction begin/commit/rollback.
  *
  * @example
  * ```typescript
- * const withUow: WithEventsUow<MyEvent> = async (fn) => {
+ * const withUow: WithEventsUow<MyEvent> = async (fn, options) => {
  *   const tx = await db.beginTransaction();
  *   try {
- *     await fn({ eventRepository: createEventRepo(tx) });
+ *     const result = await fn({ eventRepository: createEventRepo(tx) });
  *     await tx.commit();
+ *     await options?.afterCommit?.();
+ *     return result;
  *   } catch (e) {
  *     await tx.rollback();
  *     throw e;
@@ -46,4 +75,7 @@ export type EventsUnitOfWork<
  */
 export type WithEventsUow<
   Event extends GenericEvent<string, unknown, DefaultContext>,
-> = (fn: (uow: EventsUnitOfWork<Event>) => Promise<void>) => Promise<void>;
+> = <T>(
+  fn: (uow: EventsUnitOfWork<Event>) => Promise<T>,
+  options?: WithEventsUowOptions,
+) => Promise<T>;