@pattern-stack/codegen 0.2.0

package/dist/runtime/subsystems/events/domain-events.schema.d.ts

@@ -0,0 +1,187 @@
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { InferSelectModel } from 'drizzle-orm';
+
+declare const domainEvents: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "domain_events";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "domain_events";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: drizzle_orm_pg_core.PgColumn<{
+            name: "type";
+            tableName: "domain_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        aggregateId: drizzle_orm_pg_core.PgColumn<{
+            name: "aggregate_id";
+            tableName: "domain_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        aggregateType: drizzle_orm_pg_core.PgColumn<{
+            name: "aggregate_type";
+            tableName: "domain_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: drizzle_orm_pg_core.PgColumn<{
+            name: "payload";
+            tableName: "domain_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        occurredAt: drizzle_orm_pg_core.PgColumn<{
+            name: "occurred_at";
+            tableName: "domain_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        processedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "processed_at";
+            tableName: "domain_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "domain_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: drizzle_orm_pg_core.PgColumn<{
+            name: "error";
+            tableName: "domain_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "domain_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+type DomainEventRecord = InferSelectModel<typeof domainEvents>;
+
+export { type DomainEventRecord, domainEvents };

package/dist/runtime/subsystems/events/domain-events.schema.js

@@ -0,0 +1,32 @@
+// runtime/subsystems/events/domain-events.schema.ts
+import {
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid
+} from "drizzle-orm/pg-core";
+var domainEvents = pgTable(
+  "domain_events",
+  {
+    id: uuid("id").primaryKey(),
+    type: text("type").notNull(),
+    aggregateId: text("aggregate_id").notNull(),
+    aggregateType: text("aggregate_type").notNull(),
+    payload: jsonb("payload").notNull().$type(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+    processedAt: timestamp("processed_at", { withTimezone: true }),
+    /** Lifecycle status: pending | processed | failed */
+    status: text("status").notNull().default("pending"),
+    /** Error message from the last failed dispatch attempt. */
+    error: text("error"),
+    metadata: jsonb("metadata").$type()
+  }
+  // Indexes: add via migration when deploying
+  // - (status, occurred_at) for polling
+  // - (aggregate_id, aggregate_type) for replay
+);
+export {
+  domainEvents
+};
+//# sourceMappingURL=domain-events.schema.js.map

package/dist/runtime/subsystems/events/domain-events.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../runtime/subsystems/events/domain-events.schema.ts"],"sourcesContent":["/**\n * Drizzle schema for the domain_events outbox table.\n *\n * This table backs the DrizzleEventBus. Events are inserted within the\n * same database transaction as the domain write (outbox pattern). A\n * polling process reads unprocessed rows and dispatches to subscribers.\n *\n * Indexes:\n *   - (status, occurredAt) — polling query filter\n *   - (aggregateId, aggregateType) — event replay per aggregate\n */\nimport {\n  jsonb,\n  pgTable,\n  text,\n  timestamp,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport type { InferSelectModel } from 'drizzle-orm';\n\nexport const domainEvents = pgTable(\n  'domain_events',\n  {\n    id: uuid('id').primaryKey(),\n    type: text('type').notNull(),\n    aggregateId: text('aggregate_id').notNull(),\n    aggregateType: text('aggregate_type').notNull(),\n    payload: jsonb('payload').notNull().$type<Record<string, unknown>>(),\n    occurredAt: timestamp('occurred_at', { withTimezone: true }).notNull(),\n    processedAt: timestamp('processed_at', { withTimezone: true }),\n    /** Lifecycle status: pending | processed | failed */\n    status: text('status').notNull().default('pending'),\n    /** Error message from the last failed dispatch attempt. */\n    error: text('error'),\n    metadata: jsonb('metadata').$type<Record<string, unknown>>(),\n  },\n  // Indexes: add via migration when deploying\n  // - (status, occurred_at) for polling\n  // - (aggregate_id, aggregate_type) for replay\n);\n\nexport type DomainEventRecord = InferSelectModel<typeof domainEvents>;\n"],"mappings":";AAWA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGA,IAAM,eAAe;AAAA,EAC1B;AAAA,EACA;AAAA,IACE,IAAI,KAAK,IAAI,EAAE,WAAW;AAAA,IAC1B,MAAM,KAAK,MAAM,EAAE,QAAQ;AAAA,IAC3B,aAAa,KAAK,cAAc,EAAE,QAAQ;AAAA,IAC1C,eAAe,KAAK,gBAAgB,EAAE,QAAQ;AAAA,IAC9C,SAAS,MAAM,SAAS,EAAE,QAAQ,EAAE,MAA+B;AAAA,IACnE,YAAY,UAAU,eAAe,EAAE,cAAc,KAAK,CAAC,EAAE,QAAQ;AAAA,IACrE,aAAa,UAAU,gBAAgB,EAAE,cAAc,KAAK,CAAC;AAAA;AAAA,IAE7D,QAAQ,KAAK,QAAQ,EAAE,QAAQ,EAAE,QAAQ,SAAS;AAAA;AAAA,IAElD,OAAO,KAAK,OAAO;AAAA,IACnB,UAAU,MAAM,UAAU,EAAE,MAA+B;AAAA,EAC7D;AAAA;AAAA;AAAA;AAIF;","names":[]}

package/dist/runtime/subsystems/events/event-bus.drizzle-backend.d.ts

@@ -0,0 +1,38 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { IEventBus, DomainEvent, DrizzleTransaction } from './event-bus.protocol.js';
+import { DrizzleClient } from '../../types/drizzle.js';
+import 'drizzle-orm/node-postgres';
+
+/**
+ * DrizzleEventBus — Postgres-backed event bus using the transactional outbox pattern.
+ *
+ * Events are inserted into the `domain_events` table within the caller's
+ * Drizzle transaction. A background polling loop (started on module init)
+ * reads unprocessed events and dispatches them to registered subscribers.
+ *
+ * When the transaction rolls back, the event is never persisted — no
+ * phantom events.
+ *
+ * This backend is suitable until you need real-time fan-out or very high
+ * throughput. At that point, swap the backend for Redis Streams or similar
+ * via EventsModule.forRoot({ backend: '...' }) without touching use cases.
+ */
+
+declare class DrizzleEventBus implements IEventBus, OnModuleInit, OnModuleDestroy {
+    private readonly db;
+    private readonly logger;
+    private polling;
+    private pollTimer;
+    private readonly handlers;
+    constructor(db: DrizzleClient);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    publish(event: DomainEvent, tx?: DrizzleTransaction): Promise<void>;
+    publishMany(events: DomainEvent[], tx?: DrizzleTransaction): Promise<void>;
+    subscribe<T extends DomainEvent = DomainEvent>(eventType: string, handler: (event: T) => Promise<void>): () => void;
+    private schedulePoll;
+    private processBatch;
+    private dispatch;
+}
+
+export { DrizzleEventBus };

package/dist/runtime/subsystems/events/event-bus.drizzle-backend.js

@@ -0,0 +1,199 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// runtime/subsystems/events/event-bus.drizzle-backend.ts
+import { Injectable, Inject, Logger } from "@nestjs/common";
+import { eq, and, sql } from "drizzle-orm";
+
+// runtime/subsystems/events/domain-events.schema.ts
+import {
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid
+} from "drizzle-orm/pg-core";
+var domainEvents = pgTable(
+  "domain_events",
+  {
+    id: uuid("id").primaryKey(),
+    type: text("type").notNull(),
+    aggregateId: text("aggregate_id").notNull(),
+    aggregateType: text("aggregate_type").notNull(),
+    payload: jsonb("payload").notNull().$type(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+    processedAt: timestamp("processed_at", { withTimezone: true }),
+    /** Lifecycle status: pending | processed | failed */
+    status: text("status").notNull().default("pending"),
+    /** Error message from the last failed dispatch attempt. */
+    error: text("error"),
+    metadata: jsonb("metadata").$type()
+  }
+  // Indexes: add via migration when deploying
+  // - (status, occurred_at) for polling
+  // - (aggregate_id, aggregate_type) for replay
+);
+
+// runtime/constants/tokens.ts
+var DRIZZLE = "DRIZZLE";
+
+// runtime/subsystems/events/event-bus.drizzle-backend.ts
+var POLL_INTERVAL_MS = 1e3;
+var POLL_BATCH_SIZE = 50;
+var MAX_RETRIES = 3;
+var DrizzleEventBus = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  logger = new Logger(DrizzleEventBus.name);
+  polling = false;
+  pollTimer = null;
+  handlers = /* @__PURE__ */ new Map();
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async onModuleInit() {
+    this.polling = true;
+    this.schedulePoll();
+  }
+  async onModuleDestroy() {
+    this.polling = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  // ============================================================================
+  // IEventBus
+  // ============================================================================
+  async publish(event, tx) {
+    const client = tx ?? this.db;
+    await client.insert(domainEvents).values({
+      id: event.id,
+      type: event.type,
+      aggregateId: event.aggregateId,
+      aggregateType: event.aggregateType,
+      payload: event.payload,
+      occurredAt: event.occurredAt,
+      processedAt: null,
+      status: "pending",
+      metadata: event.metadata
+    });
+  }
+  async publishMany(events, tx) {
+    if (events.length === 0) return;
+    const client = tx ?? this.db;
+    await client.insert(domainEvents).values(
+      events.map((e) => ({
+        id: e.id,
+        type: e.type,
+        aggregateId: e.aggregateId,
+        aggregateType: e.aggregateType,
+        payload: e.payload,
+        occurredAt: e.occurredAt,
+        processedAt: null,
+        status: "pending",
+        metadata: e.metadata
+      }))
+    );
+  }
+  subscribe(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    const set = this.handlers.get(eventType);
+    const h = handler;
+    set.add(h);
+    return () => {
+      set.delete(h);
+    };
+  }
+  // ============================================================================
+  // Polling
+  // ============================================================================
+  schedulePoll() {
+    if (!this.polling) return;
+    this.pollTimer = setTimeout(async () => {
+      try {
+        await this.processBatch();
+      } catch (err) {
+        this.logger.error(`Poll cycle error: ${err}`);
+      } finally {
+        this.schedulePoll();
+      }
+    }, POLL_INTERVAL_MS);
+  }
+  async processBatch() {
+    const rows = await this.db.transaction(async (tx) => {
+      return tx.execute(
+        sql`SELECT * FROM domain_events WHERE status = 'pending' ORDER BY occurred_at ASC LIMIT ${POLL_BATCH_SIZE} FOR UPDATE SKIP LOCKED`
+      );
+    }).then((result) => result.rows ?? result);
+    for (const row of rows) {
+      const event = {
+        id: row["id"],
+        type: row["type"],
+        aggregateId: row["aggregate_id"],
+        aggregateType: row["aggregate_type"],
+        payload: row["payload"],
+        occurredAt: new Date(row["occurred_at"]),
+        metadata: row["metadata"]
+      };
+      let attempt = 0;
+      let lastError;
+      while (attempt < MAX_RETRIES) {
+        try {
+          await this.dispatch(event);
+          await this.db.update(domainEvents).set({ status: "processed", processedAt: /* @__PURE__ */ new Date() }).where(eq(domainEvents.id, event.id));
+          lastError = void 0;
+          break;
+        } catch (err) {
+          lastError = err;
+          attempt++;
+        }
+      }
+      if (lastError !== void 0) {
+        const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);
+        await this.db.update(domainEvents).set({ status: "failed", error: errorMessage }).where(and(eq(domainEvents.id, event.id), eq(domainEvents.status, "pending")));
+      }
+    }
+  }
+  async dispatch(event) {
+    const set = this.handlers.get(event.type);
+    if (!set) return;
+    let firstError;
+    for (const handler of set) {
+      try {
+        await handler(event);
+      } catch (err) {
+        this.logger.error(
+          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
+        );
+        if (firstError === void 0) {
+          firstError = err;
+        }
+      }
+    }
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+  }
+};
+DrizzleEventBus = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE))
+], DrizzleEventBus);
+export {
+  DrizzleEventBus
+};
+//# sourceMappingURL=event-bus.drizzle-backend.js.map

package/dist/runtime/subsystems/events/event-bus.drizzle-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../runtime/subsystems/events/event-bus.drizzle-backend.ts","../../../../runtime/subsystems/events/domain-events.schema.ts","../../../../runtime/constants/tokens.ts"],"sourcesContent":["/**\n * DrizzleEventBus — Postgres-backed event bus using the transactional outbox pattern.\n *\n * Events are inserted into the `domain_events` table within the caller's\n * Drizzle transaction. A background polling loop (started on module init)\n * reads unprocessed events and dispatches them to registered subscribers.\n *\n * When the transaction rolls back, the event is never persisted — no\n * phantom events.\n *\n * This backend is suitable until you need real-time fan-out or very high\n * throughput. At that point, swap the backend for Redis Streams or similar\n * via EventsModule.forRoot({ backend: '...' }) without touching use cases.\n */\nimport { Injectable, OnModuleDestroy, OnModuleInit, Inject, Logger } from '@nestjs/common';\nimport { eq, and, sql } from 'drizzle-orm';\nimport type { DomainEvent, DrizzleTransaction, IEventBus } from './event-bus.protocol';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { domainEvents } from './domain-events.schema';\nimport { DRIZZLE } from '../../constants/tokens';\n\n/** How long to wait between polling cycles (ms). */\nconst POLL_INTERVAL_MS = 1_000;\n/** Max events claimed per polling cycle to bound memory usage. */\nconst POLL_BATCH_SIZE = 50;\n/** Max processing attempts before marking an event failed. */\nconst MAX_RETRIES = 3;\n\n@Injectable()\nexport class DrizzleEventBus implements IEventBus, OnModuleInit, OnModuleDestroy {\n  private readonly logger = new Logger(DrizzleEventBus.name);\n  private polling = false;\n  private pollTimer: ReturnType<typeof setTimeout> | null = null;\n  private readonly handlers = new Map<string, Set<(event: DomainEvent) => Promise<void>>>();\n\n  constructor(@Inject(DRIZZLE) private readonly db: DrizzleClient) {}\n\n  // ============================================================================\n  // Lifecycle\n  // ============================================================================\n\n  async onModuleInit(): Promise<void> {\n    this.polling = true;\n    this.schedulePoll();\n  }\n\n  async onModuleDestroy(): Promise<void> {\n    this.polling = false;\n    if (this.pollTimer) {\n      clearTimeout(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  // ============================================================================\n  // IEventBus\n  // ============================================================================\n\n  async publish(event: DomainEvent, tx?: DrizzleTransaction): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client.insert(domainEvents).values({\n      id: event.id,\n      type: event.type,\n      aggregateId: event.aggregateId,\n      aggregateType: event.aggregateType,\n      payload: event.payload,\n      occurredAt: event.occurredAt,\n      processedAt: null,\n      status: 'pending',\n      metadata: event.metadata,\n    });\n  }\n\n  async publishMany(events: DomainEvent[], tx?: DrizzleTransaction): Promise<void> {\n    if (events.length === 0) return;\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client.insert(domainEvents).values(\n      events.map((e) => ({\n        id: e.id,\n        type: e.type,\n        aggregateId: e.aggregateId,\n        aggregateType: e.aggregateType,\n        payload: e.payload,\n        occurredAt: e.occurredAt,\n        processedAt: null,\n        status: 'pending' as const,\n        metadata: e.metadata,\n      })),\n    );\n  }\n\n  subscribe<T extends DomainEvent = DomainEvent>(\n    eventType: string,\n    handler: (event: T) => Promise<void>,\n  ): () => void {\n    if (!this.handlers.has(eventType)) {\n      this.handlers.set(eventType, new Set());\n    }\n    const set = this.handlers.get(eventType)!;\n    const h = handler as (event: DomainEvent) => Promise<void>;\n    set.add(h);\n    return () => {\n      set.delete(h);\n    };\n  }\n\n  // ============================================================================\n  // Polling\n  // ============================================================================\n\n  private schedulePoll(): void {\n    if (!this.polling) return;\n    this.pollTimer = setTimeout(async () => {\n      try {\n        await this.processBatch();\n      } catch (err) {\n        this.logger.error(`Poll cycle error: ${err}`);\n      } finally {\n        this.schedulePoll();\n      }\n    }, POLL_INTERVAL_MS);\n  }\n\n  private async processBatch(): Promise<void> {\n    // Fetch a batch of pending events with FOR UPDATE SKIP LOCKED to prevent\n    // double-processing when multiple instances are polling concurrently.\n    const rows = await this.db.transaction(async (tx) => {\n      return tx.execute(\n        sql`SELECT * FROM domain_events WHERE status = 'pending' ORDER BY occurred_at ASC LIMIT ${POLL_BATCH_SIZE} FOR UPDATE SKIP LOCKED`,\n      ) as Promise<{ rows: Record<string, unknown>[] }>;\n    }).then((result) => (result as unknown as { rows: Record<string, unknown>[] }).rows ?? result as unknown as Record<string, unknown>[]);\n\n    for (const row of rows) {\n      const event: DomainEvent = {\n        id: row['id'] as string,\n        type: row['type'] as string,\n        aggregateId: row['aggregate_id'] as string,\n        aggregateType: row['aggregate_type'] as string,\n        payload: row['payload'] as Record<string, unknown>,\n        occurredAt: new Date(row['occurred_at'] as string),\n        metadata: row['metadata'] as Record<string, unknown> | undefined,\n      };\n\n      let attempt = 0;\n      let lastError: unknown;\n      while (attempt < MAX_RETRIES) {\n        try {\n          await this.dispatch(event);\n          // Mark processed\n          await this.db\n            .update(domainEvents)\n            .set({ status: 'processed', processedAt: new Date() })\n            .where(eq(domainEvents.id, event.id));\n          lastError = undefined;\n          break;\n        } catch (err) {\n          lastError = err;\n          attempt++;\n        }\n      }\n\n      if (lastError !== undefined) {\n        const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);\n        await this.db\n          .update(domainEvents)\n          .set({ status: 'failed', error: errorMessage })\n          .where(and(eq(domainEvents.id, event.id), eq(domainEvents.status, 'pending')));\n      }\n    }\n  }\n\n  private async dispatch(event: DomainEvent): Promise<void> {\n    const set = this.handlers.get(event.type);\n    if (!set) return;\n\n    let firstError: unknown;\n    for (const handler of set) {\n      try {\n        await handler(event);\n      } catch (err) {\n        this.logger.error(\n          `Handler error for event type \"${event.type}\" (id: ${event.id}): ${err}`,\n        );\n        if (firstError === undefined) {\n          firstError = err;\n        }\n      }\n    }\n\n    if (firstError !== undefined) {\n      throw firstError;\n    }\n  }\n}\n","/**\n * Drizzle schema for the domain_events outbox table.\n *\n * This table backs the DrizzleEventBus. Events are inserted within the\n * same database transaction as the domain write (outbox pattern). A\n * polling process reads unprocessed rows and dispatches to subscribers.\n *\n * Indexes:\n *   - (status, occurredAt) — polling query filter\n *   - (aggregateId, aggregateType) — event replay per aggregate\n */\nimport {\n  jsonb,\n  pgTable,\n  text,\n  timestamp,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport type { InferSelectModel } from 'drizzle-orm';\n\nexport const domainEvents = pgTable(\n  'domain_events',\n  {\n    id: uuid('id').primaryKey(),\n    type: text('type').notNull(),\n    aggregateId: text('aggregate_id').notNull(),\n    aggregateType: text('aggregate_type').notNull(),\n    payload: jsonb('payload').notNull().$type<Record<string, unknown>>(),\n    occurredAt: timestamp('occurred_at', { withTimezone: true }).notNull(),\n    processedAt: timestamp('processed_at', { withTimezone: true }),\n    /** Lifecycle status: pending | processed | failed */\n    status: text('status').notNull().default('pending'),\n    /** Error message from the last failed dispatch attempt. */\n    error: text('error'),\n    metadata: jsonb('metadata').$type<Record<string, unknown>>(),\n  },\n  // Indexes: add via migration when deploying\n  // - (status, occurred_at) for polling\n  // - (aggregate_id, aggregate_type) for replay\n);\n\nexport type DomainEventRecord = InferSelectModel<typeof domainEvents>;\n","/**\n * NestJS injection tokens\n *\n * Used with @Inject() decorator in concrete repository constructors.\n */\n\n/**\n * Injection token for the Drizzle ORM database client.\n *\n * Usage in concrete repositories:\n * ```typescript\n * constructor(@Inject(DRIZZLE) db: DrizzleClient) { super(db); }\n * ```\n */\nexport const DRIZZLE = 'DRIZZLE' as const;\n\n/**\n * Injection token for the event bus (IEventBus).\n *\n * Optional — only resolved when EventsModule.forRoot() is registered.\n * BaseService uses this with @Optional() to emit lifecycle events\n * without requiring the events subsystem to be installed.\n *\n * Usage in services/use cases:\n * ```typescript\n * @Optional() @Inject(EVENT_BUS) eventBus?: IEventBus\n * ```\n */\nexport const EVENT_BUS = 'EVENT_BUS' as const;\n"],"mappings":"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","names":[]}

package/dist/runtime/subsystems/events/event-bus.memory-backend.d.ts

@@ -0,0 +1,18 @@
+import { IEventBus, DomainEvent } from './event-bus.protocol.js';
+import '../../types/drizzle.js';
+import 'drizzle-orm/node-postgres';
+
+declare class MemoryEventBus implements IEventBus {
+    private readonly logger;
+    /** All events published since construction (or last clear). */
+    readonly publishedEvents: DomainEvent[];
+    private readonly handlers;
+    publish(event: DomainEvent): Promise<void>;
+    publishMany(events: DomainEvent[]): Promise<void>;
+    subscribe<T extends DomainEvent = DomainEvent>(eventType: string, handler: (event: T) => Promise<void>): () => void;
+    /** Remove all published events and subscriptions. Useful in beforeEach. */
+    clear(): void;
+    private dispatch;
+}
+
+export { MemoryEventBus };

package/dist/runtime/subsystems/events/event-bus.memory-backend.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// runtime/subsystems/events/event-bus.memory-backend.ts
+import { Injectable, Logger } from "@nestjs/common";
+var MemoryEventBus = class {
+  logger = new Logger(MemoryEventBus.name);
+  /** All events published since construction (or last clear). */
+  publishedEvents = [];
+  handlers = /* @__PURE__ */ new Map();
+  async publish(event) {
+    this.publishedEvents.push(event);
+    await this.dispatch(event);
+  }
+  async publishMany(events) {
+    for (const event of events) {
+      await this.publish(event);
+    }
+  }
+  subscribe(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    const set = this.handlers.get(eventType);
+    const h = handler;
+    set.add(h);
+    return () => {
+      set.delete(h);
+    };
+  }
+  /** Remove all published events and subscriptions. Useful in beforeEach. */
+  clear() {
+    this.publishedEvents.length = 0;
+    this.handlers.clear();
+  }
+  async dispatch(event) {
+    const set = this.handlers.get(event.type);
+    if (!set) return;
+    let firstError;
+    for (const handler of set) {
+      try {
+        await handler(event);
+      } catch (err) {
+        this.logger.error(
+          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
+        );
+        if (firstError === void 0) {
+          firstError = err;
+        }
+      }
+    }
+    if (firstError !== void 0) {
+      throw firstError;
+    }
+  }
+};
+MemoryEventBus = __decorateClass([
+  Injectable()
+], MemoryEventBus);
+export {
+  MemoryEventBus
+};
+//# sourceMappingURL=event-bus.memory-backend.js.map

package/dist/runtime/subsystems/events/event-bus.memory-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../runtime/subsystems/events/event-bus.memory-backend.ts"],"sourcesContent":["/**\n * MemoryEventBus — in-memory backend for the event bus.\n *\n * Dispatches events synchronously to registered subscribers. The `tx`\n * parameter is ignored — all events are dispatched immediately.\n *\n * Use this backend in tests to assert event publication without a database.\n * Swap via EventsModule.forRoot({ backend: 'memory' }).\n */\nimport { Injectable, Logger } from '@nestjs/common';\nimport type { DomainEvent, IEventBus } from './event-bus.protocol';\n\n@Injectable()\nexport class MemoryEventBus implements IEventBus {\n  private readonly logger = new Logger(MemoryEventBus.name);\n\n  /** All events published since construction (or last clear). */\n  readonly publishedEvents: DomainEvent[] = [];\n\n  private readonly handlers = new Map<string, Set<(event: DomainEvent) => Promise<void>>>();\n\n  async publish(event: DomainEvent): Promise<void> {\n    this.publishedEvents.push(event);\n    await this.dispatch(event);\n  }\n\n  async publishMany(events: DomainEvent[]): Promise<void> {\n    for (const event of events) {\n      await this.publish(event);\n    }\n  }\n\n  subscribe<T extends DomainEvent = DomainEvent>(\n    eventType: string,\n    handler: (event: T) => Promise<void>,\n  ): () => void {\n    if (!this.handlers.has(eventType)) {\n      this.handlers.set(eventType, new Set());\n    }\n    // Cast is safe — callers pass a typed handler; we store as the base type\n    const set = this.handlers.get(eventType)!;\n    const h = handler as (event: DomainEvent) => Promise<void>;\n    set.add(h);\n\n    return () => {\n      set.delete(h);\n    };\n  }\n\n  /** Remove all published events and subscriptions. Useful in beforeEach. */\n  clear(): void {\n    this.publishedEvents.length = 0;\n    this.handlers.clear();\n  }\n\n  private async dispatch(event: DomainEvent): Promise<void> {\n    const set = this.handlers.get(event.type);\n    if (!set) return;\n\n    let firstError: unknown;\n    for (const handler of set) {\n      try {\n        await handler(event);\n      } catch (err) {\n        this.logger.error(\n          `Handler error for event type \"${event.type}\" (id: ${event.id}): ${err}`,\n        );\n        if (firstError === undefined) {\n          firstError = err;\n        }\n      }\n    }\n\n    if (firstError !== undefined) {\n      throw firstError;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,SAAS,YAAY,cAAc;AAI5B,IAAM,iBAAN,MAA0C;AAAA,EAC9B,SAAS,IAAI,OAAO,eAAe,IAAI;AAAA;AAAA,EAG/C,kBAAiC,CAAC;AAAA,EAE1B,WAAW,oBAAI,IAAwD;AAAA,EAExF,MAAM,QAAQ,OAAmC;AAC/C,SAAK,gBAAgB,KAAK,KAAK;AAC/B,UAAM,KAAK,SAAS,KAAK;AAAA,EAC3B;AAAA,EAEA,MAAM,YAAY,QAAsC;AACtD,eAAW,SAAS,QAAQ;AAC1B,YAAM,KAAK,QAAQ,KAAK;AAAA,IAC1B;AAAA,EACF;AAAA,EAEA,UACE,WACA,SACY;AACZ,QAAI,CAAC,KAAK,SAAS,IAAI,SAAS,GAAG;AACjC,WAAK,SAAS,IAAI,WAAW,oBAAI,IAAI,CAAC;AAAA,IACxC;AAEA,UAAM,MAAM,KAAK,SAAS,IAAI,SAAS;AACvC,UAAM,IAAI;AACV,QAAI,IAAI,CAAC;AAET,WAAO,MAAM;AACX,UAAI,OAAO,CAAC;AAAA,IACd;AAAA,EACF;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,gBAAgB,SAAS;AAC9B,SAAK,SAAS,MAAM;AAAA,EACtB;AAAA,EAEA,MAAc,SAAS,OAAmC;AACxD,UAAM,MAAM,KAAK,SAAS,IAAI,MAAM,IAAI;AACxC,QAAI,CAAC,IAAK;AAEV,QAAI;AACJ,eAAW,WAAW,KAAK;AACzB,UAAI;AACF,cAAM,QAAQ,KAAK;AAAA,MACrB,SAAS,KAAK;AACZ,aAAK,OAAO;AAAA,UACV,iCAAiC,MAAM,IAAI,UAAU,MAAM,EAAE,MAAM,GAAG;AAAA,QACxE;AACA,YAAI,eAAe,QAAW;AAC5B,uBAAa;AAAA,QACf;AAAA,MACF;AAAA,IACF;AAEA,QAAI,eAAe,QAAW;AAC5B,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAhEa,iBAAN;AAAA,EADN,WAAW;AAAA,GACC;","names":[]}

package/dist/runtime/subsystems/events/event-bus.protocol.d.ts

@@ -0,0 +1,52 @@
+import { DrizzleClient } from '../../types/drizzle.js';
+import 'drizzle-orm/node-postgres';
+
+/**
+ * Events subsystem — protocol (port)
+ *
+ * IEventBus is the hexagonal port. Use cases inject this interface via
+ * EVENT_BUS token. They never depend on a specific backend implementation.
+ *
+ * The DrizzleTransaction type mirrors what the Drizzle client exposes
+ * so callers can pass a transaction for the outbox pattern.
+ */
+
+type DrizzleTransaction = Parameters<Parameters<DrizzleClient['transaction']>[0]>[0];
+interface DomainEvent {
+    /** UUID — used for deduplication and idempotency. */
+    readonly id: string;
+    /** Event type discriminator, e.g. 'contact_created'. */
+    readonly type: string;
+    /** ID of the aggregate that produced this event. */
+    readonly aggregateId: string;
+    /** Aggregate type name, e.g. 'contact'. */
+    readonly aggregateType: string;
+    /** Event-specific payload. */
+    readonly payload: Record<string, unknown>;
+    /** Wall-clock time the event occurred. */
+    readonly occurredAt: Date;
+    /** Optional routing / audit metadata. */
+    readonly metadata?: Record<string, unknown>;
+}
+interface IEventBus {
+    /**
+     * Publish a single domain event.
+     *
+     * Pass `tx` to include the event in an ongoing Drizzle transaction
+     * (transactional outbox pattern). If the transaction rolls back, the
+     * event is never persisted.
+     */
+    publish(event: DomainEvent, tx?: DrizzleTransaction): Promise<void>;
+    /**
+     * Publish multiple domain events atomically.
+     * Same transactional semantics as `publish`.
+     */
+    publishMany(events: DomainEvent[], tx?: DrizzleTransaction): Promise<void>;
+    /**
+     * Subscribe to events of the given type.
+     * Returns an unsubscribe function — call it to remove the handler.
+     */
+    subscribe<T extends DomainEvent = DomainEvent>(eventType: string, handler: (event: T) => Promise<void>): () => void;
+}
+
+export type { DomainEvent, DrizzleTransaction, IEventBus };

package/dist/runtime/subsystems/events/event-bus.protocol.js

@@ -0,0 +1 @@
+//# sourceMappingURL=event-bus.protocol.js.map

package/dist/runtime/subsystems/events/event-bus.protocol.js.map

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