@l-etabli/events 0.1.0

package/dist/ports/EventBus.d.cts

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

package/dist/ports/EventBus.d.ts

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

package/dist/ports/EventBus.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=EventBus.mjs.map

package/dist/ports/EventBus.mjs.map

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

package/dist/ports/EventQueries.cjs

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

package/dist/ports/EventQueries.cjs.map

@@ -0,0 +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":[]}

package/dist/ports/EventQueries.d.cts

@@ -0,0 +1,24 @@
+import { GenericEvent, DefaultContext, EventStatus } from '../types.cjs';
+
+/** Parameters for querying events. */
+type GetEventsParams = {
+    filters: {
+        /** Filter by event status (e.g., ["never-published", "failed-but-will-retry"]). */
+        statuses: EventStatus[];
+        /** Optional context filter for multi-tenant scenarios. */
+        context?: Partial<Record<string, string>>;
+    };
+    /** Maximum number of events to return. */
+    limit: number;
+};
+/**
+ * Query interface for reading events.
+ * Used by the event crawler to fetch events for processing.
+ * Implement this to query events from your database.
+ */
+type EventQueries<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    /** Fetch events matching the given filters. */
+    getEvents: (params: GetEventsParams) => Promise<Event[]>;
+};
+
+export type { EventQueries };

package/dist/ports/EventQueries.d.ts

@@ -0,0 +1,24 @@
+import { GenericEvent, DefaultContext, EventStatus } from '../types.js';
+
+/** Parameters for querying events. */
+type GetEventsParams = {
+    filters: {
+        /** Filter by event status (e.g., ["never-published", "failed-but-will-retry"]). */
+        statuses: EventStatus[];
+        /** Optional context filter for multi-tenant scenarios. */
+        context?: Partial<Record<string, string>>;
+    };
+    /** Maximum number of events to return. */
+    limit: number;
+};
+/**
+ * Query interface for reading events.
+ * Used by the event crawler to fetch events for processing.
+ * Implement this to query events from your database.
+ */
+type EventQueries<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    /** Fetch events matching the given filters. */
+    getEvents: (params: GetEventsParams) => Promise<Event[]>;
+};
+
+export type { EventQueries };

package/dist/ports/EventQueries.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=EventQueries.mjs.map

package/dist/ports/EventQueries.mjs.map

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

package/dist/ports/EventRepository.cjs

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

package/dist/ports/EventRepository.cjs.map

@@ -0,0 +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":[]}

package/dist/ports/EventRepository.d.cts

@@ -0,0 +1,43 @@
+import { GenericEvent, DefaultContext } from '../types.cjs';
+
+/**
+ * Repository interface for persisting events.
+ * Implement this to store events in your database (e.g., PostgreSQL, MongoDB).
+ * Events should be saved in the same transaction as your domain changes.
+ */
+type EventRepository<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    /** Persist a single event (typically after publication status update). */
+    save: (event: Event) => Promise<void>;
+    /** Persist multiple new events in a batch. */
+    saveNewEventsBatch: (events: Event[]) => Promise<void>;
+    /** Mark events as "in-process" before publishing (prevents duplicate processing). */
+    markEventsAsInProcess: (events: Event[]) => Promise<void>;
+};
+/**
+ * Unit of work containing the event repository.
+ * Extend this with your own repositories for transactional consistency.
+ */
+type EventsUnitOfWork<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    eventRepository: EventRepository<Event>;
+};
+/**
+ * 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 tx = await db.beginTransaction();
+ *   try {
+ *     await fn({ eventRepository: createEventRepo(tx) });
+ *     await tx.commit();
+ *   } catch (e) {
+ *     await tx.rollback();
+ *     throw e;
+ *   }
+ * };
+ * ```
+ */
+type WithEventsUow<Event extends GenericEvent<string, unknown, DefaultContext>> = (fn: (uow: EventsUnitOfWork<Event>) => Promise<void>) => Promise<void>;
+
+export type { EventRepository, EventsUnitOfWork, WithEventsUow };

package/dist/ports/EventRepository.d.ts

@@ -0,0 +1,43 @@
+import { GenericEvent, DefaultContext } from '../types.js';
+
+/**
+ * Repository interface for persisting events.
+ * Implement this to store events in your database (e.g., PostgreSQL, MongoDB).
+ * Events should be saved in the same transaction as your domain changes.
+ */
+type EventRepository<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    /** Persist a single event (typically after publication status update). */
+    save: (event: Event) => Promise<void>;
+    /** Persist multiple new events in a batch. */
+    saveNewEventsBatch: (events: Event[]) => Promise<void>;
+    /** Mark events as "in-process" before publishing (prevents duplicate processing). */
+    markEventsAsInProcess: (events: Event[]) => Promise<void>;
+};
+/**
+ * Unit of work containing the event repository.
+ * Extend this with your own repositories for transactional consistency.
+ */
+type EventsUnitOfWork<Event extends GenericEvent<string, unknown, DefaultContext>> = {
+    eventRepository: EventRepository<Event>;
+};
+/**
+ * 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 tx = await db.beginTransaction();
+ *   try {
+ *     await fn({ eventRepository: createEventRepo(tx) });
+ *     await tx.commit();
+ *   } catch (e) {
+ *     await tx.rollback();
+ *     throw e;
+ *   }
+ * };
+ * ```
+ */
+type WithEventsUow<Event extends GenericEvent<string, unknown, DefaultContext>> = (fn: (uow: EventsUnitOfWork<Event>) => Promise<void>) => Promise<void>;
+
+export type { EventRepository, EventsUnitOfWork, WithEventsUow };

package/dist/ports/EventRepository.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=EventRepository.mjs.map

package/dist/ports/EventRepository.mjs.map

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

package/dist/types.cjs

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

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/**\n * Branded type helper for nominal typing.\n * Adds a phantom type property to distinguish between structurally identical types.\n */\nexport type Flavor<T, FlavorT> = T & {\n  _type?: FlavorT;\n};\n\n/** Unique identifier for an event subscription. */\nexport type SubscriptionId = Flavor<string, \"SubscriptionId\">;\n\n/** Unique identifier for a user who triggered an event. */\nexport type UserId = Flavor<string, \"UserId\">;\n\n/** Unique identifier for an event. */\nexport type EventId = Flavor<string, \"EventId\">;\n\n/**\n * Records a subscription failure during event publication.\n * Contains the subscription that failed and error details for debugging.\n */\nexport type EventFailure = {\n  subscriptionId: SubscriptionId;\n  errorMessage: string;\n  /** Stack trace captured when the subscription callback threw. */\n  stack?: string;\n};\n\n/**\n * Records a single publication attempt for an event.\n * Tracks which subscribers were notified and any failures that occurred.\n */\nexport type EventPublication = {\n  publishedAt: Date;\n  /** All subscription IDs that were attempted in this publication. */\n  publishedSubscribers: SubscriptionId[];\n  /** Subscriptions that failed during this publication attempt. */\n  failures: EventFailure[];\n};\n\n/**\n * Event lifecycle status.\n * - `never-published`: New event, not yet processed by crawler\n * - `in-process`: Currently being published by crawler\n * - `published`: Successfully delivered to all subscribers\n * - `failed-but-will-retry`: Some subscribers failed, will retry\n * - `quarantined`: Exceeded max retries, requires manual intervention\n * - `to-republish`: Force republish to all subscribers (manual trigger)\n */\nexport type EventStatus =\n  | \"never-published\"\n  | \"to-republish\"\n  | \"in-process\"\n  | \"published\"\n  | \"failed-but-will-retry\"\n  | \"quarantined\";\n\n/** Context type constraint - must be a string record or undefined. */\nexport type DefaultContext = Record<string, string> | undefined;\n\n/**\n * Generic event type for the outbox pattern.\n * Events are persisted in the same transaction as domain changes,\n * then asynchronously published to subscribers.\n *\n * @typeParam T - Event topic/type string literal\n * @typeParam P - Event payload type\n * @typeParam C - Optional context for filtering (e.g., tenant ID)\n *\n * @example\n * ```typescript\n * type MyEvents =\n *   | GenericEvent<\"UserCreated\", { userId: string; email: string }>\n *   | GenericEvent<\"OrderPlaced\", { orderId: string }, { tenantId: string }>;\n * ```\n */\nexport type GenericEvent<\n  T extends string,\n  P,\n  C extends DefaultContext = undefined,\n> = {\n  /** Unique event identifier. */\n  id: EventId;\n  /** When the event occurred in the domain. */\n  occurredAt: Date;\n  /** Event type/topic for routing to subscribers. */\n  topic: T;\n  /** Event-specific data. */\n  payload: P;\n  /** Current lifecycle status. */\n  status: EventStatus;\n  /** History of publication attempts. */\n  publications: EventPublication[];\n  /** User who triggered the action that created this event. */\n  triggeredByUserId: UserId;\n  /** Optional priority for processing order (not yet implemented in crawler). */\n  priority?: number;\n  /** Optional context for filtering events (e.g., by tenant). */\n  context?: C;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types.d.cts

@@ -0,0 +1,84 @@
+/**
+ * Branded type helper for nominal typing.
+ * Adds a phantom type property to distinguish between structurally identical types.
+ */
+type Flavor<T, FlavorT> = T & {
+    _type?: FlavorT;
+};
+/** Unique identifier for an event subscription. */
+type SubscriptionId = Flavor<string, "SubscriptionId">;
+/** Unique identifier for a user who triggered an event. */
+type UserId = Flavor<string, "UserId">;
+/** Unique identifier for an event. */
+type EventId = Flavor<string, "EventId">;
+/**
+ * Records a subscription failure during event publication.
+ * Contains the subscription that failed and error details for debugging.
+ */
+type EventFailure = {
+    subscriptionId: SubscriptionId;
+    errorMessage: string;
+    /** Stack trace captured when the subscription callback threw. */
+    stack?: string;
+};
+/**
+ * Records a single publication attempt for an event.
+ * Tracks which subscribers were notified and any failures that occurred.
+ */
+type EventPublication = {
+    publishedAt: Date;
+    /** All subscription IDs that were attempted in this publication. */
+    publishedSubscribers: SubscriptionId[];
+    /** Subscriptions that failed during this publication attempt. */
+    failures: EventFailure[];
+};
+/**
+ * Event lifecycle status.
+ * - `never-published`: New event, not yet processed by crawler
+ * - `in-process`: Currently being published by crawler
+ * - `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 (manual trigger)
+ */
+type EventStatus = "never-published" | "to-republish" | "in-process" | "published" | "failed-but-will-retry" | "quarantined";
+/** Context type constraint - must be a string record or undefined. */
+type DefaultContext = Record<string, string> | undefined;
+/**
+ * Generic event type for the outbox pattern.
+ * Events are persisted in the same transaction as domain changes,
+ * then asynchronously published to subscribers.
+ *
+ * @typeParam T - Event topic/type string literal
+ * @typeParam P - Event payload type
+ * @typeParam C - Optional context for filtering (e.g., tenant ID)
+ *
+ * @example
+ * ```typescript
+ * type MyEvents =
+ *   | GenericEvent<"UserCreated", { userId: string; email: string }>
+ *   | GenericEvent<"OrderPlaced", { orderId: string }, { tenantId: string }>;
+ * ```
+ */
+type GenericEvent<T extends string, P, C extends DefaultContext = undefined> = {
+    /** Unique event identifier. */
+    id: EventId;
+    /** When the event occurred in the domain. */
+    occurredAt: Date;
+    /** Event type/topic for routing to subscribers. */
+    topic: T;
+    /** Event-specific data. */
+    payload: P;
+    /** Current lifecycle status. */
+    status: EventStatus;
+    /** History of publication attempts. */
+    publications: EventPublication[];
+    /** User who triggered the action that created this event. */
+    triggeredByUserId: UserId;
+    /** Optional priority for processing order (not yet implemented in crawler). */
+    priority?: number;
+    /** Optional context for filtering events (e.g., by tenant). */
+    context?: C;
+};
+
+export type { DefaultContext, EventFailure, EventId, EventPublication, EventStatus, Flavor, GenericEvent, SubscriptionId, UserId };

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Branded type helper for nominal typing.
+ * Adds a phantom type property to distinguish between structurally identical types.
+ */
+type Flavor<T, FlavorT> = T & {
+    _type?: FlavorT;
+};
+/** Unique identifier for an event subscription. */
+type SubscriptionId = Flavor<string, "SubscriptionId">;
+/** Unique identifier for a user who triggered an event. */
+type UserId = Flavor<string, "UserId">;
+/** Unique identifier for an event. */
+type EventId = Flavor<string, "EventId">;
+/**
+ * Records a subscription failure during event publication.
+ * Contains the subscription that failed and error details for debugging.
+ */
+type EventFailure = {
+    subscriptionId: SubscriptionId;
+    errorMessage: string;
+    /** Stack trace captured when the subscription callback threw. */
+    stack?: string;
+};
+/**
+ * Records a single publication attempt for an event.
+ * Tracks which subscribers were notified and any failures that occurred.
+ */
+type EventPublication = {
+    publishedAt: Date;
+    /** All subscription IDs that were attempted in this publication. */
+    publishedSubscribers: SubscriptionId[];
+    /** Subscriptions that failed during this publication attempt. */
+    failures: EventFailure[];
+};
+/**
+ * Event lifecycle status.
+ * - `never-published`: New event, not yet processed by crawler
+ * - `in-process`: Currently being published by crawler
+ * - `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 (manual trigger)
+ */
+type EventStatus = "never-published" | "to-republish" | "in-process" | "published" | "failed-but-will-retry" | "quarantined";
+/** Context type constraint - must be a string record or undefined. */
+type DefaultContext = Record<string, string> | undefined;
+/**
+ * Generic event type for the outbox pattern.
+ * Events are persisted in the same transaction as domain changes,
+ * then asynchronously published to subscribers.
+ *
+ * @typeParam T - Event topic/type string literal
+ * @typeParam P - Event payload type
+ * @typeParam C - Optional context for filtering (e.g., tenant ID)
+ *
+ * @example
+ * ```typescript
+ * type MyEvents =
+ *   | GenericEvent<"UserCreated", { userId: string; email: string }>
+ *   | GenericEvent<"OrderPlaced", { orderId: string }, { tenantId: string }>;
+ * ```
+ */
+type GenericEvent<T extends string, P, C extends DefaultContext = undefined> = {
+    /** Unique event identifier. */
+    id: EventId;
+    /** When the event occurred in the domain. */
+    occurredAt: Date;
+    /** Event type/topic for routing to subscribers. */
+    topic: T;
+    /** Event-specific data. */
+    payload: P;
+    /** Current lifecycle status. */
+    status: EventStatus;
+    /** History of publication attempts. */
+    publications: EventPublication[];
+    /** User who triggered the action that created this event. */
+    triggeredByUserId: UserId;
+    /** Optional priority for processing order (not yet implemented in crawler). */
+    priority?: number;
+    /** Optional context for filtering events (e.g., by tenant). */
+    context?: C;
+};
+
+export type { DefaultContext, EventFailure, EventId, EventPublication, EventStatus, Flavor, GenericEvent, SubscriptionId, UserId };

package/dist/types.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

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

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@l-etabli/events",
+  "description": "The purpose of this repositiory is to make it easy to setup event driven architecture using outbox pattern",
+  "module": "src/index.ts",
+  "type": "module",
+  "version": "0.1.0",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/l-etabli/events.git"
+  },
+  "homepage": "https://github.com/l-etabli/events#readme",
+  "bugs": {
+    "url": "https://github.com/l-etabli/events/issues"
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "check": "biome check",
+    "check:fix": "biome check --fix --no-errors-on-unmatched --files-ignore-unknown=true",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "fullcheck": "bun run check:fix && bun run typecheck && bun test --bail tests/ --exclude '**/kyselyAdapter.test.ts'",
+    "release": "semantic-release"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.2.5",
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@types/bun": "latest",
+    "@types/pg": "^8.16.0",
+    "kysely": "^0.28.2",
+    "lefthook": "^1.13.6",
+    "pg": "^8.16.3",
+    "semantic-release": "^24.2.9",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./kysely": {
+      "types": "./dist/adapters/kysely/index.d.ts",
+      "import": "./dist/adapters/kysely/index.mjs",
+      "require": "./dist/adapters/kysely/index.cjs"
+    }
+  },
+  "peerDependencies": {
+    "kysely": "latest"
+  },
+  "peerDependenciesMeta": {
+    "kysely": {
+      "optional": true
+    }
+  }
+}