@pattern-stack/codegen 0.4.0 → 0.4.2

package/runtime/subsystems/events/events.module.ts

@@ -0,0 +1,230 @@
+/**
+ * EventsModule — DynamicModule factory for the event bus subsystem.
+ *
+ * Register once in AppModule:
+ * ```typescript
+ * @Module({
+ *   imports: [
+ *     EventsModule.forRoot({ backend: 'drizzle' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * Tests swap to the memory backend without touching application code:
+ * ```typescript
+ * Test.createTestingModule({
+ *   imports: [EventsModule.forRoot({ backend: 'memory' })],
+ * });
+ * ```
+ *
+ * Per-pool drain isolation (EVT-4):
+ * ```typescript
+ * EventsModule.forRoot({ backend: 'drizzle', pools: ['events_change'] });
+ * ```
+ * Each process restricts its drain loop to the pools listed here. `pools`
+ * is undefined by default → drain all pending rows (backwards-compatible).
+ *
+ * Typed facade + multi-tenancy (EVT-6):
+ * - `TYPED_EVENT_BUS` resolves to the generated `TypedEventBus` wrapping
+ *   whichever backend is selected.
+ * - `multiTenant: true` makes `TypedEventBus.publish` throw
+ *   `MissingTenantIdError` when the caller forgets `metadata.tenantId`.
+ *
+ * `global: true` means entity modules do not need to import EventsModule
+ * individually — the EVENT_BUS and TYPED_EVENT_BUS tokens are available
+ * project-wide.
+ *
+ * Async configuration (`forRootAsync`):
+ * The async factory returns `EventsModuleOptions`; the EVENT_BUS provider
+ * then receives its backend dependencies — DRIZZLE for the drizzle
+ * backend, REDIS_URL for the redis backend, the resolved options for the
+ * memory backend — through a proper `useFactory` so Nest DI wires them
+ * correctly. Earlier revisions hand-constructed backends with
+ * `new Class()` which silently left `db` / `redisUrl` undefined
+ * (issue #108).
+ */
+import { Module, type DynamicModule, type Provider } from '@nestjs/common';
+import {
+  EVENT_BUS,
+  EVENTS_MODULE_OPTIONS,
+  EVENTS_MULTI_TENANT,
+  REDIS_URL,
+  TYPED_EVENT_BUS,
+} from './events.tokens';
+import { DRIZZLE } from '../../constants/tokens';
+import type { DrizzleClient } from '../../types/drizzle';
+import { DrizzleEventBus } from './event-bus.drizzle-backend';
+import { MemoryEventBus } from './event-bus.memory-backend';
+import { RedisEventBus } from './event-bus.redis-backend';
+import { TypedEventBus } from './generated/bus';
+
+export interface EventsModuleOptions {
+  backend: 'drizzle' | 'memory' | 'redis';
+  /**
+   * Redis connection URL used when `backend` is `'redis'`.
+   * Falls back to the REDIS_URL environment variable, then
+   * `redis://localhost:6379` if neither is set.
+   */
+  redisUrl?: string;
+  /**
+   * Restrict the drain loop to these pools. Each pool name matches the
+   * `domain_events.pool` column (populated from `event.metadata.pool` at
+   * publish time). Leave undefined to drain all pending rows.
+   *
+   * Typical lane split: one process per `events_inbound` /
+   * `events_change` / `events_outbound` so a slow outbound handler
+   * cannot stall change-event propagation (see ADR-022).
+   */
+  pools?: string[];
+  /**
+   * Multi-tenancy opt-in (EVT-6).
+   *
+   * When `true`, every `TypedEventBus.publish()` call must supply
+   * `opts.metadata.tenantId` — otherwise it throws `MissingTenantIdError`.
+   * The tenantId is preserved on `event.metadata` and, for the Drizzle
+   * backend, written to `domain_events.tenant_id` (EVT-4).
+   *
+   * Drain-side tenant filtering is deferred — the tenant-context model
+   * (per-process vs. per-request vs. async-local-storage) is still
+   * unsettled; see ADR-024 §Multi-tenancy. Only the publish-side
+   * requirement ships here.
+   *
+   * Defaults to `false`.
+   */
+  multiTenant?: boolean;
+}
+
+export interface EventsModuleAsyncOptions {
+  useFactory: (...args: unknown[]) => Promise<EventsModuleOptions> | EventsModuleOptions;
+  inject?: unknown[];
+  imports?: unknown[];
+}
+
+/**
+ * Shared provider set: `TypedEventBus` itself, the `TYPED_EVENT_BUS` token
+ * binding, and the resolved `EVENTS_MULTI_TENANT` flag. Returned from one
+ * place so every `forRoot` branch and `forRootAsync` agree.
+ */
+function buildTypedBusProviders(multiTenant: boolean): Provider[] {
+  return [
+    TypedEventBus,
+    { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus },
+    { provide: EVENTS_MULTI_TENANT, useValue: multiTenant },
+  ];
+}
+
+/**
+ * Construct the backend instance for the async path, routing constructor
+ * arguments through Nest-resolved dependencies.
+ *
+ * DRIZZLE is declared optional at inject time so that memory-backend
+ * consumers aren't required to also import `DatabaseModule`. If the
+ * drizzle backend is selected but no DRIZZLE provider is registered, we
+ * throw a clear error instead of silently constructing a broken bus.
+ */
+function buildEventBusAsync(
+  options: EventsModuleOptions,
+  db: DrizzleClient | null,
+  redisUrl: string,
+): unknown {
+  if (options.backend === 'drizzle') {
+    if (!db) {
+      throw new Error(
+        "EventsModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. " +
+          'Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before EventsModule.forRootAsync.',
+      );
+    }
+    return new DrizzleEventBus(db, options);
+  }
+  if (options.backend === 'redis') {
+    return new RedisEventBus(redisUrl);
+  }
+  return new MemoryEventBus(options);
+}
+
+@Module({})
+export class EventsModule {
+  static forRootAsync(asyncOptions: EventsModuleAsyncOptions): DynamicModule {
+    return {
+      module: EventsModule,
+      global: true,
+      imports: (asyncOptions.imports ?? []) as Parameters<typeof Module>[0]['imports'],
+      providers: [
+        {
+          provide: EVENTS_MODULE_OPTIONS,
+          useFactory: asyncOptions.useFactory,
+          inject: (asyncOptions.inject ?? []) as (string | symbol | Function)[],
+        },
+        {
+          provide: EVENTS_MULTI_TENANT,
+          useFactory: (options: EventsModuleOptions) => options.multiTenant ?? false,
+          inject: [EVENTS_MODULE_OPTIONS],
+        },
+        {
+          provide: REDIS_URL,
+          useFactory: (options: EventsModuleOptions) =>
+            options.redisUrl ?? process.env['REDIS_URL'] ?? 'redis://localhost:6379',
+          inject: [EVENTS_MODULE_OPTIONS],
+        },
+        {
+          provide: EVENT_BUS,
+          useFactory: (
+            options: EventsModuleOptions,
+            db: DrizzleClient | null,
+            redisUrl: string,
+          ) => buildEventBusAsync(options, db, redisUrl),
+          inject: [
+            EVENTS_MODULE_OPTIONS,
+            { token: DRIZZLE, optional: true },
+            REDIS_URL,
+          ],
+        },
+        TypedEventBus,
+        { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus },
+      ],
+      exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],
+    };
+  }
+
+  static forRoot(
+    options: EventsModuleOptions = { backend: 'drizzle' },
+  ): DynamicModule {
+    const multiTenant = options.multiTenant ?? false;
+
+    if (options.backend === 'redis') {
+      const resolvedUrl =
+        options.redisUrl ?? process.env['REDIS_URL'] ?? 'redis://localhost:6379';
+
+      return {
+        module: EventsModule,
+        global: true,
+        providers: [
+          { provide: EVENTS_MODULE_OPTIONS, useValue: options },
+          { provide: REDIS_URL, useValue: resolvedUrl },
+          { provide: EVENT_BUS, useClass: RedisEventBus },
+          // Register concrete class so NestJS can resolve lifecycle hooks
+          RedisEventBus,
+          ...buildTypedBusProviders(multiTenant),
+        ],
+        exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],
+      };
+    }
+
+    const provider =
+      options.backend === 'drizzle'
+        ? { provide: EVENT_BUS, useClass: DrizzleEventBus }
+        : { provide: EVENT_BUS, useClass: MemoryEventBus };
+
+    return {
+      module: EventsModule,
+      global: true,
+      providers: [
+        { provide: EVENTS_MODULE_OPTIONS, useValue: options },
+        provider,
+        ...buildTypedBusProviders(multiTenant),
+      ],
+      exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],
+    };
+  }
+}

package/runtime/subsystems/events/events.tokens.ts

@@ -0,0 +1,62 @@
+/**
+ * Injection token for the event bus.
+ *
+ * String constant (not Symbol) so it matches by value across import boundaries.
+ * Matches the token in runtime/constants/tokens.ts — both are 'EVENT_BUS'.
+ *
+ * Usage in use cases:
+ * ```typescript
+ * constructor(@Inject(EVENT_BUS) private readonly eventBus: IEventBus) {}
+ * ```
+ */
+export const EVENT_BUS = 'EVENT_BUS' as const;
+
+/**
+ * Injection token for the generated `TypedEventBus` facade.
+ *
+ * `TypedEventBus` lives in `runtime/subsystems/events/generated/bus.ts` and
+ * wraps `IEventBus` with project-specific `AppDomainEvent`-typed `publish<T>()`
+ * and `subscribe<T>()`. Use cases inject this token in preference to
+ * `EVENT_BUS` when they want compile-time type safety on event shapes.
+ *
+ * String constant (not Symbol) so it matches by value across import
+ * boundaries — same convention as `EVENT_BUS`.
+ *
+ * Provider registration lands in EVT-6 (EventsModule wiring); the token is
+ * declared here so generated code can import it without depending on the
+ * still-being-formalised module.
+ */
+export const TYPED_EVENT_BUS = 'TYPED_EVENT_BUS' as const;
+
+/**
+ * Injection token for the resolved multi-tenancy flag.
+ *
+ * Provided by `EventsModule.forRoot(...)` as `options.multiTenant ?? false`.
+ * Consumed by `TypedEventBus` to enforce the tenantId-is-required rule at
+ * publish time.
+ *
+ * String constant (not Symbol) so it matches by value across import
+ * boundaries — same convention as the other events tokens. (The jobs
+ * subsystem uses Symbols for the analogous token; events chose strings
+ * from the start and we keep the file internally consistent.)
+ */
+export const EVENTS_MULTI_TENANT = 'EVENTS_MULTI_TENANT' as const;
+
+/**
+ * Injection token for the Redis connection URL used by RedisEventBus.
+ * Provided automatically by EventsModule.forRoot({ backend: 'redis' }).
+ */
+export const REDIS_URL = Symbol('REDIS_URL');
+
+/**
+ * Injection token for the resolved `EventsModuleOptions` object.
+ *
+ * Provided automatically by `EventsModule.forRoot(...)` /
+ * `EventsModule.forRootAsync(...)`. Backends that need to observe module
+ * configuration (e.g. `DrizzleEventBus` reading `opts.pools` for
+ * pool-filtered drain) inject via this token.
+ *
+ * String-valued (not `Symbol`) so it matches by value across import
+ * boundaries — same convention as `EVENT_BUS`.
+ */
+export const EVENTS_MODULE_OPTIONS = 'EVENTS_MODULE_OPTIONS' as const;

package/runtime/subsystems/events/generated/bus.ts

@@ -0,0 +1,103 @@
+// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+// Run `codegen entity new --all` to refresh.
+
+import { Injectable, Inject } from '@nestjs/common';
+import { randomUUID } from 'crypto';
+import { EVENT_BUS, EVENTS_MULTI_TENANT } from '../events.tokens';
+import { MissingTenantIdError } from '../events-errors';
+import type { IEventBus, DrizzleTransaction } from '../event-bus.protocol';
+import { eventPayloadSchemas } from './schemas';
+import { getEventMetadata } from './registry';
+import type { EventTypeName, EventOfType, PayloadOfType } from './types';
+
+/**
+ * Typed facade over IEventBus.
+ *
+ * Stamps `pool`, `direction`, and `version` into `event.metadata` from
+ * the generated `eventRegistry` before delegating to `IEventBus.publish()`.
+ * Downstream backends (DrizzleEventBus) read those values to populate the
+ * explicit `domain_events` columns.
+ *
+ * Validation gating (EVT-Q5): `CODEGEN_EVENT_VALIDATE` env flag, default on.
+ * Uses `safeParse` + `console.warn` — never throws, so a bad publish does
+ * not crash a hot path.
+ *
+ * Multi-tenancy (EVT-6): when the EventsModule is configured with
+ * `multiTenant: true`, every publish must supply `opts.metadata.tenantId`
+ * — otherwise `publish()` throws `MissingTenantIdError`. When `multiTenant`
+ * is `false` (default), no tenantId is required. If a tenantId IS supplied,
+ * it is preserved on `event.metadata` and the Drizzle backend writes it to
+ * `domain_events.tenant_id` (EVT-4).
+ */
+@Injectable()
+export class TypedEventBus {
+	constructor(
+		@Inject(EVENT_BUS) private readonly bus: IEventBus,
+		@Inject(EVENTS_MULTI_TENANT) private readonly multiTenant: boolean,
+	) {}
+
+	async publish<T extends EventTypeName>(
+		type: T,
+		aggregateId: string,
+		payload: PayloadOfType<T>,
+		opts?: { tx?: DrizzleTransaction; metadata?: Record<string, unknown> },
+	): Promise<void> {
+		const meta = getEventMetadata(type);
+
+		const flag = process.env['CODEGEN_EVENT_VALIDATE'];
+		const shouldValidate =
+			flag === undefined ? true : flag !== 'false' && flag !== '0';
+		if (shouldValidate) {
+			// `eventPayloadSchemas` is typed as `Record<EventTypeName, z.ZodType>`,
+			// so under `noUncheckedIndexedAccess` the indexed lookup widens
+			// to `z.ZodType | undefined`. When no events are registered at
+			// codegen time `EventTypeName` degrades to `string` and the
+			// schemas object is literally `{}` — the guard below is the
+			// honest handling of that empty-registry case (skip validation;
+			// it's a warn-only best-effort check per the class docblock).
+			const schema = eventPayloadSchemas[type];
+			if (schema) {
+				const check = schema.safeParse(payload);
+				if (!check.success) {
+					console.warn(
+						`[TypedEventBus] payload validation failed for ${String(type)}:`,
+						check.error.issues,
+					);
+				}
+			}
+		}
+
+		const tenantId = opts?.metadata?.['tenantId'];
+		if (this.multiTenant && (tenantId === undefined || tenantId === null)) {
+			throw new MissingTenantIdError(type as string);
+		}
+
+		const aggregateType =
+			meta.aggregate ?? meta.source ?? meta.destination ?? (type as string);
+
+		await this.bus.publish(
+			{
+				id: randomUUID(),
+				type,
+				aggregateId,
+				aggregateType,
+				payload: payload as Record<string, unknown>,
+				occurredAt: new Date(),
+				metadata: {
+					...(opts?.metadata ?? {}),
+					pool: meta.pool,
+					direction: meta.direction,
+					version: meta.version,
+				},
+			},
+			opts?.tx,
+		);
+	}
+
+	subscribe<T extends EventTypeName>(
+		type: T,
+		handler: (event: EventOfType<T>) => Promise<void>,
+	): () => void {
+		return this.bus.subscribe<EventOfType<T>>(type, handler as never);
+	}
+}

package/runtime/subsystems/events/generated/index.ts

@@ -0,0 +1,7 @@
+// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+// Run `codegen entity new --all` to refresh.
+
+export * from './types';
+export * from './schemas';
+export * from './registry';
+export * from './bus';

package/runtime/subsystems/events/generated/registry.ts

@@ -0,0 +1,84 @@
+// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+// Run `codegen entity new --all` to refresh.
+
+
+import type { EventTypeName } from './types';
+
+export interface EventMetadata {
+	type: EventTypeName;
+	direction: 'inbound' | 'change' | 'outbound';
+	pool: 'events_inbound' | 'events_change' | 'events_outbound';
+	aggregate?: string;
+	source?: string;
+	destination?: string;
+	version: number;
+	retry: { attempts: number; backoff: 'linear' | 'exponential' };
+}
+
+export const eventRegistry = {
+	'contact_created': {
+		type: 'contact_created',
+		direction: 'change',
+		pool: 'events_change',
+		aggregate: 'contact',
+		version: 1,
+		retry: { attempts: 3, backoff: 'exponential' },
+	},
+	'contact_marked_champion': {
+		type: 'contact_marked_champion',
+		direction: 'change',
+		pool: 'events_change',
+		aggregate: 'contact',
+		version: 1,
+		retry: { attempts: 3, backoff: 'exponential' },
+	},
+	'contact_merged': {
+		type: 'contact_merged',
+		direction: 'change',
+		pool: 'events_change',
+		aggregate: 'contact',
+		version: 1,
+		retry: { attempts: 3, backoff: 'exponential' },
+	},
+	'deal_created': {
+		type: 'deal_created',
+		direction: 'change',
+		pool: 'events_change',
+		aggregate: 'deal',
+		version: 1,
+		retry: { attempts: 3, backoff: 'exponential' },
+	},
+	'deal_stage_changed': {
+		type: 'deal_stage_changed',
+		direction: 'change',
+		pool: 'events_change',
+		aggregate: 'deal',
+		version: 1,
+		retry: { attempts: 3, backoff: 'exponential' },
+	},
+	'stripe_payment_received': {
+		type: 'stripe_payment_received',
+		direction: 'inbound',
+		pool: 'events_inbound',
+		source: 'stripe',
+		version: 1,
+		retry: { attempts: 5, backoff: 'exponential' },
+	},
+	'webhook_outbound_contact_sync': {
+		type: 'webhook_outbound_contact_sync',
+		direction: 'outbound',
+		pool: 'events_outbound',
+		aggregate: 'contact',
+		destination: 'crm',
+		version: 1,
+		retry: { attempts: 3, backoff: 'exponential' },
+	},
+} as const satisfies Record<EventTypeName, EventMetadata>;
+
+export function getEventMetadata<T extends EventTypeName>(type: T): EventMetadata {
+	const meta = eventRegistry[type];
+	if (!meta) {
+		throw new Error(`No registry entry for event type '${String(type)}' — declare events under events/*.yaml and re-run \`codegen entity new --all\`.`);
+	}
+	return meta;
+}

package/runtime/subsystems/events/generated/schemas.ts

@@ -0,0 +1,59 @@
+// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+// Run `codegen entity new --all` to refresh.
+
+
+import { z } from 'zod';
+import type { EventTypeName } from './types';
+
+export const contactCreatedPayloadSchema = z.object({
+	accountId: z.string().uuid().nullable(),
+	contactId: z.string().uuid(),
+	createdBy: z.string().uuid(),
+}).strict();
+
+export const contactMarkedChampionPayloadSchema = z.object({
+	contactId: z.string().uuid(),
+	opportunityId: z.string().uuid(),
+}).strict();
+
+export const contactMergedPayloadSchema = z.object({
+	mergedBy: z.string().uuid(),
+	sourceId: z.string().uuid(),
+	targetId: z.string().uuid(),
+}).strict();
+
+export const dealCreatedPayloadSchema = z.object({
+	accountId: z.string().uuid(),
+	dealId: z.string().uuid(),
+	ownerId: z.string().uuid(),
+}).strict();
+
+export const dealStageChangedPayloadSchema = z.object({
+	dealId: z.string().uuid(),
+	newStage: z.string(),
+	oldStage: z.string(),
+}).strict();
+
+export const stripePaymentReceivedPayloadSchema = z.object({
+	amountCents: z.number(),
+	currency: z.string(),
+	customerId: z.string(),
+	eventId: z.string(),
+	receivedAt: z.coerce.date(),
+}).strict();
+
+export const webhookOutboundContactSyncPayloadSchema = z.object({
+	contactId: z.string().uuid(),
+	occurredAt: z.coerce.date(),
+	operation: z.string(),
+}).strict();
+
+export const eventPayloadSchemas = {
+	'contact_created': contactCreatedPayloadSchema,
+	'contact_marked_champion': contactMarkedChampionPayloadSchema,
+	'contact_merged': contactMergedPayloadSchema,
+	'deal_created': dealCreatedPayloadSchema,
+	'deal_stage_changed': dealStageChangedPayloadSchema,
+	'stripe_payment_received': stripePaymentReceivedPayloadSchema,
+	'webhook_outbound_contact_sync': webhookOutboundContactSyncPayloadSchema,
+} as const satisfies Record<EventTypeName, z.ZodType>;

package/runtime/subsystems/events/generated/types.ts

@@ -0,0 +1,94 @@
+// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+// Run `codegen entity new --all` to refresh.
+
+
+import type { DomainEvent } from '../event-bus.protocol';
+
+/** Emitted after a contact row is committed. */
+export interface ContactCreatedEvent extends DomainEvent {
+	readonly type: 'contact_created';
+	readonly aggregateType: 'contact';
+	readonly payload: {
+		accountId: string | null;
+		contactId: string;
+		createdBy: string;
+	};
+}
+
+export interface ContactMarkedChampionEvent extends DomainEvent {
+	readonly type: 'contact_marked_champion';
+	readonly aggregateType: 'contact';
+	readonly payload: {
+		contactId: string;
+		opportunityId: string;
+	};
+}
+
+export interface ContactMergedEvent extends DomainEvent {
+	readonly type: 'contact_merged';
+	readonly aggregateType: 'contact';
+	readonly payload: {
+		mergedBy: string;
+		sourceId: string;
+		targetId: string;
+	};
+}
+
+export interface DealCreatedEvent extends DomainEvent {
+	readonly type: 'deal_created';
+	readonly aggregateType: 'deal';
+	readonly payload: {
+		accountId: string;
+		dealId: string;
+		ownerId: string;
+	};
+}
+
+export interface DealStageChangedEvent extends DomainEvent {
+	readonly type: 'deal_stage_changed';
+	readonly aggregateType: 'deal';
+	readonly payload: {
+		dealId: string;
+		newStage: string;
+		oldStage: string;
+	};
+}
+
+/** Stripe charge.succeeded webhook, post-signature-verification. */
+export interface StripePaymentReceivedEvent extends DomainEvent {
+	readonly type: 'stripe_payment_received';
+	readonly aggregateType: 'stripe';
+	readonly payload: {
+		amountCents: number;
+		currency: string;
+		customerId: string;
+		/** Stripe event id (evt_...) */
+		eventId: string;
+		receivedAt: Date;
+	};
+}
+
+/** Outbound notification to the configured CRM when a contact changes. */
+export interface WebhookOutboundContactSyncEvent extends DomainEvent {
+	readonly type: 'webhook_outbound_contact_sync';
+	readonly aggregateType: 'contact';
+	readonly payload: {
+		contactId: string;
+		occurredAt: Date;
+		/** create | update | delete */
+		operation: string;
+	};
+}
+
+export type AppDomainEvent =
+	| ContactCreatedEvent
+	| ContactMarkedChampionEvent
+	| ContactMergedEvent
+	| DealCreatedEvent
+	| DealStageChangedEvent
+	| StripePaymentReceivedEvent
+	| WebhookOutboundContactSyncEvent;
+
+export type EventTypeName = AppDomainEvent['type'];
+export type EventOfType<T extends EventTypeName> = Extract<AppDomainEvent, { type: T }>;
+export type PayloadOfType<T extends EventTypeName> = EventOfType<T>['payload'];

package/runtime/subsystems/events/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Events subsystem — public API
+ *
+ * Import the module in AppModule, inject the bus via EVENT_BUS token.
+ */
+export type { DomainEvent, IEventBus, DrizzleTransaction } from './event-bus.protocol';
+export {
+  EVENT_BUS,
+  EVENTS_MODULE_OPTIONS,
+  EVENTS_MULTI_TENANT,
+  TYPED_EVENT_BUS,
+} from './events.tokens';
+export { TypedEventBus } from './generated/bus';
+export { MissingTenantIdError } from './events-errors';
+export { EventsModule } from './events.module';
+export type { EventsModuleOptions } from './events.module';
+export { MemoryEventBus } from './event-bus.memory-backend';
+export { DrizzleEventBus } from './event-bus.drizzle-backend';
+export { RedisEventBus } from './event-bus.redis-backend';
+export { domainEvents } from './domain-events.schema';
+export type { DomainEventRecord } from './domain-events.schema';