@pattern-stack/codegen 0.19.0 → 0.20.0

package/dist/chunk-FN2PYDPP.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-FN2PYDPP.js.map

package/dist/chunk-OFRRBC7M.js.map

@@ -1 +0,0 @@
-{"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 * First-class routing columns (EVT-1):\n *   - `pool`       — populated by DrizzleEventBus.publish() (EVT-4); enables\n *                    pool-filtered drain queries without unpacking metadata JSON.\n *                    NULL when `tier='audit'` (audit events are not routed).\n *   - `direction`  — `inbound` | `change` | `outbound`; mirrors the routing\n *                    dimension used by jobs' reserved `events_inbound` /\n *                    `events_change` / `events_outbound` pools.\n *                    NULL when `tier='audit'`.\n *   - `tenant_id`  — conditional: emitted only when `events.multi_tenant: true`\n *                    in `codegen.config.yaml`. The runtime source declares it\n *                    unconditionally; EVT-8's scaffold template handles the\n *                    config-driven include/exclude.\n *\n * Audit-tier column (AUDIT-1):\n *   - `tier`       — `'domain'` | `'audit'`. Defaults to `'domain'`. Audit-tier\n *                    rows are observability-only (subscribers may observe but\n *                    the bridge MUST NOT spawn jobs from them); they have null\n *                    `pool` and `direction` by construction. The CHECK\n *                    constraint `domain_events_tier_routing_check` enforces\n *                    `tier='audit' ⇔ (pool IS NULL AND direction IS NULL)`.\n *\n * The `metadata` JSON column continues to carry these values for protocol\n * stability; the first-class columns are an optimization for drain filtering.\n *\n * Indexes (declared below in the index callback):\n *   - (status, occurred_at)             — polling drain filter\n *   - (aggregate_id, aggregate_type)    — event replay per aggregate\n *   - (pool, status, occurred_at)       — per-pool drain filter (EVT-1)\n *   - (tier, status, occurred_at)       — per-tier filter for the observability\n *                                          viewer's tier toggle (AUDIT-1).\n */\nimport {\n  check,\n  index,\n  jsonb,\n  pgTable,\n  text,\n  timestamp,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport { sql } from 'drizzle-orm';\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    /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. NULL when `tier='audit'`. */\n    pool: text('pool'),\n    /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. NULL when `tier='audit'`. */\n    direction: text('direction'),\n    /**\n     * Event tier: `'domain'` (default) or `'audit'`. Audit-tier rows are\n     * observability-only and have null `pool`/`direction` by construction —\n     * enforced by the `domain_events_tier_routing_check` CHECK constraint\n     * declared below. (AUDIT-1)\n     */\n    tier: text('tier').notNull().default('domain'),\n    // conditional: emitted only when events.multi_tenant: true\n    tenantId: text('tenant_id'),\n  },\n  (t) => ({\n    /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */\n    idxDomainEventsStatusOccurredAt: index('idx_domain_events_status_occurred_at').on(\n      t.status,\n      t.occurredAt,\n    ),\n    /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */\n    idxDomainEventsAggregate: index('idx_domain_events_aggregate').on(\n      t.aggregateId,\n      t.aggregateType,\n    ),\n    /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */\n    idxDomainEventsPoolStatusOccurredAt: index(\n      'idx_domain_events_pool_status_occurred_at',\n    ).on(t.pool, t.status, t.occurredAt),\n    /** Per-tier filter (AUDIT-1). Backs the observability viewer's tier toggle. */\n    idxDomainEventsTierStatusOccurredAt: index(\n      'idx_domain_events_tier_status_occurred_at',\n    ).on(t.tier, t.status, t.occurredAt),\n    /**\n     * Tier ↔ routing-fields invariant (AUDIT-1):\n     *   - `tier` is one of `'domain' | 'audit'`.\n     *   - `tier='audit'` ⇔ `pool IS NULL AND direction IS NULL`.\n     *   - `tier='domain'` ⇒ `pool` and `direction` are populated (the\n     *     DrizzleEventBus inserts always supply them; the bus stamps them\n     *     in AUDIT-3).\n     */\n    tierRoutingCheck: check(\n      'domain_events_tier_routing_check',\n      sql`${t.tier} in ('domain','audit') AND ((${t.tier} = 'audit') = (${t.pool} is null and ${t.direction} is null))`,\n    ),\n  }),\n);\n\nexport type DomainEventRecord = InferSelectModel<typeof domainEvents>;\n"],"mappings":";AAsCA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AAGb,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;AAAA,IAE3D,MAAM,KAAK,MAAM;AAAA;AAAA,IAEjB,WAAW,KAAK,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAO3B,MAAM,KAAK,MAAM,EAAE,QAAQ,EAAE,QAAQ,QAAQ;AAAA;AAAA,IAE7C,UAAU,KAAK,WAAW;AAAA,EAC5B;AAAA,EACA,CAAC,OAAO;AAAA;AAAA,IAEN,iCAAiC,MAAM,sCAAsC,EAAE;AAAA,MAC7E,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,0BAA0B,MAAM,6BAA6B,EAAE;AAAA,MAC7D,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,qCAAqC;AAAA,MACnC;AAAA,IACF,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;AAAA;AAAA,IAEnC,qCAAqC;AAAA,MACnC;AAAA,IACF,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASnC,kBAAkB;AAAA,MAChB;AAAA,MACA,MAAM,EAAE,IAAI,gCAAgC,EAAE,IAAI,kBAAkB,EAAE,IAAI,gBAAgB,EAAE,SAAS;AAAA,IACvG;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-OZEPJGMA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../runtime/subsystems/events/events.module.ts"],"sourcesContent":["/**\n * EventsModule — DynamicModule factory for the event bus subsystem.\n *\n * Register once in AppModule:\n * ```typescript\n * @Module({\n *   imports: [\n *     EventsModule.forRoot({ backend: 'drizzle' }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n *\n * Tests swap to the memory backend without touching application code:\n * ```typescript\n * Test.createTestingModule({\n *   imports: [EventsModule.forRoot({ backend: 'memory' })],\n * });\n * ```\n *\n * Per-pool drain isolation (EVT-4):\n * ```typescript\n * EventsModule.forRoot({ backend: 'drizzle', pools: ['events_change'] });\n * ```\n * Each process restricts its drain loop to the pools listed here. `pools`\n * is undefined by default → drain all pending rows (backwards-compatible).\n *\n * Typed facade + multi-tenancy (EVT-6):\n * - `TYPED_EVENT_BUS` resolves to the generated `TypedEventBus` wrapping\n *   whichever backend is selected.\n * - `multiTenant: true` makes `TypedEventBus.publish` throw\n *   `MissingTenantIdError` when the caller forgets `metadata.tenantId`.\n *\n * `global: true` means entity modules do not need to import EventsModule\n * individually — the EVENT_BUS and TYPED_EVENT_BUS tokens are available\n * project-wide.\n *\n * Async configuration (`forRootAsync`):\n * The async factory returns `EventsModuleOptions`; the EVENT_BUS provider\n * then receives its backend dependencies — DRIZZLE for the drizzle\n * backend, REDIS_URL for the redis backend, the resolved options for the\n * memory backend — through a proper `useFactory` so Nest DI wires them\n * correctly. Earlier revisions hand-constructed backends with\n * `new Class()` which silently left `db` / `redisUrl` undefined\n * (issue #108).\n */\nimport { Module, type DynamicModule, type Provider, type Type } from '@nestjs/common';\nimport {\n  EVENT_BUS,\n  EVENT_READ_PORT,\n  EVENTS_MODULE_OPTIONS,\n  EVENTS_MULTI_TENANT,\n  REDIS_URL,\n  TYPED_EVENT_BUS,\n} from './events.tokens';\nimport { DRIZZLE } from '../../constants/tokens';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DrizzleEventBus } from './event-bus.drizzle-backend';\nimport { MemoryEventBus } from './event-bus.memory-backend';\n// #6 — `RedisEventBus` is lazy-loaded only when `backend: 'redis'` is selected.\n// The file is filtered out of the vendor set for non-redis installs (see\n// `backendFileFilter` in src/cli/commands/subsystem.ts); the dynamic-string\n// import below makes TS treat the specifier as `any` so the consumer's tsc\n// never tries to resolve the absent file.\nimport { TypedEventBus } from './generated/bus';\n\n/**\n * Lazy-load the Redis backend. Routed through a non-literal specifier so\n * the consumer's `tsc` doesn't resolve `./event-bus.redis-backend` at type\n * check time — important because that file is filtered out of drizzle/\n * memory installs (#6).\n */\nasync function loadRedisEventBus(): Promise<new (url: string) => object> {\n  // Non-literal specifier — TS gives this an `any` module type, sidestepping\n  // resolution of a file that may not be vendored.\n  const specifier = './event-bus.redis-backend';\n  const mod = (await import(specifier)) as { RedisEventBus: new (url: string) => object };\n  return mod.RedisEventBus;\n}\n\nexport interface EventsModuleOptions {\n  backend: 'drizzle' | 'memory' | 'redis';\n  /**\n   * Redis connection URL used when `backend` is `'redis'`.\n   * Falls back to the REDIS_URL environment variable, then\n   * `redis://localhost:6379` if neither is set.\n   */\n  redisUrl?: string;\n  /**\n   * Restrict the drain loop to these pools. Each pool name matches the\n   * `domain_events.pool` column (populated from `event.metadata.pool` at\n   * publish time). Leave undefined to drain all pending rows.\n   *\n   * Typical lane split: one process per `events_inbound` /\n   * `events_change` / `events_outbound` so a slow outbound handler\n   * cannot stall change-event propagation (see ADR-022).\n   */\n  pools?: string[];\n  /**\n   * LISTEN-NOTIFY-1 — when `true` (drizzle backend only), the drainer holds a\n   * dedicated listener connection and LISTENs on `codegen_events_wake`. Each\n   * `publish`/`publishMany` emits an in-tx `pg_notify(codegen_events_wake,\n   * <pool>)` so the drainer wakes the moment the publishing transaction commits,\n   * instead of waiting for the next poll tick. Polling continues unchanged as\n   * the fallback heartbeat; a lost notify degrades to poll latency, never to\n   * lost work. Defaults to `false`.\n   *\n   * Ignored by the memory + redis backends (memory dispatches inline; redis has\n   * its own fan-out). Requires a direct (non-transaction-pooler) connection —\n   * see the events/jobs config block re: PgBouncer.\n   */\n  listenNotify?: boolean;\n  /**\n   * Multi-tenancy opt-in (EVT-6).\n   *\n   * When `true`, every `TypedEventBus.publish()` call must supply\n   * `opts.metadata.tenantId` — otherwise it throws `MissingTenantIdError`.\n   * The tenantId is preserved on `event.metadata` and, for the Drizzle\n   * backend, written to `domain_events.tenant_id` (EVT-4).\n   *\n   * Drain-side tenant filtering is deferred — the tenant-context model\n   * (per-process vs. per-request vs. async-local-storage) is still\n   * unsettled; see ADR-024 §Multi-tenancy. Only the publish-side\n   * requirement ships here.\n   *\n   * Defaults to `false`.\n   */\n  multiTenant?: boolean;\n  /**\n   * The generated `TypedEventBus` class to bind to `TYPED_EVENT_BUS`.\n   *\n   * **Package mode (ADR-037).** When the runtime is imported from\n   * `@pattern-stack/codegen` (not vendored), the bundled `./generated/bus`\n   * `TypedEventBus` is typed to an EMPTY event union and reads the bundled\n   * empty `eventRegistry` — a consumer's `events/*.yaml` are scanned into\n   * `src/generated/events/bus.ts` (typed to THEIR union, reading THEIR\n   * registry), which the package can't import. The generated subsystem barrel\n   * therefore threads that class in here:\n   * `EventsModule.forRoot({ ..., typedBus: TypedEventBus })`. Nest constructs\n   * it with this module's `EVENT_BUS` + `EVENTS_MULTI_TENANT` providers (the\n   * generated class injects the same string-valued tokens, which match across\n   * the package boundary).\n   *\n   * Omitted (vendored mode / tests) ⇒ falls back to the bundled\n   * `./generated/bus`, which in a vendored tree IS the consumer's generated\n   * file. Without this, a package-mode consumer's typed `publish<'…'>()` calls\n   * resolve against the empty union and their events never get the right\n   * `pool` / `direction` stamped.\n   *\n   * Only consulted by `forRoot` (the path the barrel emits); `forRootAsync`\n   * keeps the bundled bus.\n   */\n  typedBus?: Type<unknown>;\n}\n\nexport interface EventsModuleAsyncOptions {\n  useFactory: (...args: unknown[]) => Promise<EventsModuleOptions> | EventsModuleOptions;\n  inject?: unknown[];\n  imports?: unknown[];\n}\n\n/**\n * Shared provider set: `TypedEventBus` itself, the `TYPED_EVENT_BUS` token\n * binding, and the resolved `EVENTS_MULTI_TENANT` flag. Returned from one\n * place so every `forRoot` branch and `forRootAsync` agree.\n */\nfunction buildTypedBusProviders(\n  multiTenant: boolean,\n  typedBus?: Type<unknown>,\n): Provider[] {\n  // Package mode threads the consumer's generated `TypedEventBus` (typed to\n  // their event union, reading their registry) via `typedBus`; vendored mode\n  // omits it and we fall back to the bundled `./generated/bus` (which IS the\n  // consumer's generated file in a vendored tree). See `EventsModuleOptions.typedBus`.\n  const BusClass = typedBus ?? TypedEventBus;\n  return [\n    BusClass,\n    { provide: TYPED_EVENT_BUS, useExisting: BusClass },\n    { provide: EVENTS_MULTI_TENANT, useValue: multiTenant },\n  ];\n}\n\n/**\n * Construct the backend instance for the async path, routing constructor\n * arguments through Nest-resolved dependencies.\n *\n * DRIZZLE is declared optional at inject time so that memory-backend\n * consumers aren't required to also import `DatabaseModule`. If the\n * drizzle backend is selected but no DRIZZLE provider is registered, we\n * throw a clear error instead of silently constructing a broken bus.\n */\nasync function buildEventBusAsync(\n  options: EventsModuleOptions,\n  db: DrizzleClient | null,\n  redisUrl: string,\n): Promise<unknown> {\n  if (options.backend === 'drizzle') {\n    if (!db) {\n      throw new Error(\n        \"EventsModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. \" +\n          'Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before EventsModule.forRootAsync.',\n      );\n    }\n    return new DrizzleEventBus(db, options);\n  }\n  if (options.backend === 'redis') {\n    // #6: lazy import — the redis backend ships only with `--backend redis`\n    // installs; drizzle/memory consumers never touch the file.\n    const RedisEventBus = await loadRedisEventBus();\n    return new RedisEventBus(redisUrl);\n  }\n  return new MemoryEventBus(options);\n}\n\n@Module({})\nexport class EventsModule {\n  static forRootAsync(asyncOptions: EventsModuleAsyncOptions): DynamicModule {\n    return {\n      module: EventsModule,\n      global: true,\n      imports: (asyncOptions.imports ?? []) as Parameters<typeof Module>[0]['imports'],\n      providers: [\n        {\n          provide: EVENTS_MODULE_OPTIONS,\n          useFactory: asyncOptions.useFactory,\n          inject: (asyncOptions.inject ?? []) as (string | symbol | Function)[],\n        },\n        {\n          provide: EVENTS_MULTI_TENANT,\n          useFactory: (options: EventsModuleOptions) => options.multiTenant ?? false,\n          inject: [EVENTS_MODULE_OPTIONS],\n        },\n        {\n          provide: REDIS_URL,\n          useFactory: (options: EventsModuleOptions) =>\n            options.redisUrl ?? process.env['REDIS_URL'] ?? 'redis://localhost:6379',\n          inject: [EVENTS_MODULE_OPTIONS],\n        },\n        {\n          provide: EVENT_BUS,\n          useFactory: (\n            options: EventsModuleOptions,\n            db: DrizzleClient | null,\n            redisUrl: string,\n          ) => buildEventBusAsync(options, db, redisUrl),\n          inject: [\n            EVENTS_MODULE_OPTIONS,\n            { token: DRIZZLE, optional: true },\n            REDIS_URL,\n          ],\n        },\n        {\n          // Read port (OBS-LIST-1). Drizzle + memory backends implement\n          // IEventReadPort on the EVENT_BUS instance; the redis backend\n          // retains no history, so EVENT_READ_PORT resolves to `null` and\n          // optional consumers (the observability combiner) degrade to\n          // empty results.\n          provide: EVENT_READ_PORT,\n          useFactory: (options: EventsModuleOptions, bus: unknown) =>\n            options.backend === 'redis' ? null : bus,\n          inject: [EVENTS_MODULE_OPTIONS, EVENT_BUS],\n        },\n        TypedEventBus,\n        { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus },\n      ],\n      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],\n    };\n  }\n\n  static forRoot(\n    options: EventsModuleOptions = { backend: 'drizzle' },\n  ): DynamicModule {\n    const multiTenant = options.multiTenant ?? false;\n\n    if (options.backend === 'redis') {\n      const resolvedUrl =\n        options.redisUrl ?? process.env['REDIS_URL'] ?? 'redis://localhost:6379';\n\n      return {\n        module: EventsModule,\n        global: true,\n        providers: [\n          { provide: EVENTS_MODULE_OPTIONS, useValue: options },\n          { provide: REDIS_URL, useValue: resolvedUrl },\n          {\n            // #6: useFactory + dynamic import so the consumer's tsc never\n            // needs to resolve `event-bus.redis-backend.ts` for drizzle/\n            // memory installs (the file is filtered out by\n            // `backendFileFilter`). Nest awaits async factories + manages\n            // lifecycle on the returned instance, so we drop the old bare\n            // `RedisEventBus` provider entry.\n            provide: EVENT_BUS,\n            useFactory: async (url: string): Promise<object> => {\n              const RedisEventBus = await loadRedisEventBus();\n              return new RedisEventBus(url);\n            },\n            inject: [REDIS_URL],\n          },\n          ...buildTypedBusProviders(multiTenant, options.typedBus),\n        ],\n        exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],\n      };\n    }\n\n    const provider =\n      options.backend === 'drizzle'\n        ? { provide: EVENT_BUS, useClass: DrizzleEventBus }\n        : { provide: EVENT_BUS, useClass: MemoryEventBus };\n\n    return {\n      module: EventsModule,\n      global: true,\n      providers: [\n        { provide: EVENTS_MODULE_OPTIONS, useValue: options },\n        provider,\n        // Read port (OBS-LIST-1): drizzle + memory backends implement\n        // IEventReadPort on the same instance as EVENT_BUS. The redis\n        // backend retains no history and does not provide this token.\n        { provide: EVENT_READ_PORT, useExisting: EVENT_BUS },\n        ...buildTypedBusProviders(multiTenant, options.typedBus),\n      ],\n      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],\n    };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-Z7PQCAVK.js.map

@@ -1 +0,0 @@
-{"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 *\n * Pool awareness (EVT-5):\n * - Mirrors the `DrizzleEventBus` per-process restriction (EVT-4). When\n *   `opts.pools` is set, `publish`/`publishMany` still push the event into\n *   `publishedEvents` (so test code can assert the full set of emitted\n *   events regardless of pool filter), but handlers are NOT invoked for\n *   events whose `metadata.pool` is outside the configured pools.\n * - `publishedEventsForPool(pool)` and `publishedEventsForDirection(dir)`\n *   helpers are provided for targeted assertions.\n * - Shares the `EventsModuleOptions` shape (same token as Drizzle) rather\n *   than introducing a memory-only options type — the surface is the same\n *   and keeping them unified avoids drift between backends.\n */\nimport { Inject, Injectable, Logger, Optional } from '@nestjs/common';\nimport type { DomainEvent, IEventBus } from './event-bus.protocol';\nimport type {\n  EventPage,\n  EventSummary,\n  IEventReadPort,\n  ListEventsQuery,\n} from './event-read.protocol';\nimport {\n  clampEventLimit,\n  decodeEventCursor,\n  encodeEventCursor,\n} from './event-keyset-cursor';\nimport { EVENTS_MODULE_OPTIONS } from './events.tokens';\nimport type { EventsModuleOptions } from './events.module';\n\n/**\n * Project an in-memory `DomainEvent` into the narrow `EventSummary` shape.\n * The memory backend has no first-class columns, so `pool` / `direction` /\n * `tier` / `tenantId` / `rootRunId` are read from `metadata` (mirroring how\n * the Drizzle backend stamps them onto columns at publish time). `status`\n * is reported as `'processed'` — the memory bus dispatches synchronously,\n * so once an event is in `publishedEvents` it has been handled.\n */\nfunction toEventSummary(event: DomainEvent): EventSummary {\n  const metadata = event.metadata;\n  const str = (key: string): string | null => {\n    const v = metadata?.[key];\n    return typeof v === 'string' ? v : null;\n  };\n  return {\n    id: event.id,\n    type: event.type,\n    aggregateId: event.aggregateId,\n    aggregateType: event.aggregateType,\n    status: 'processed',\n    pool: str('pool'),\n    direction: str('direction'),\n    tier: str('tier') ?? 'domain',\n    rootRunId: str('rootRunId'),\n    tenantId: str('tenantId'),\n    occurredAt: event.occurredAt,\n    processedAt: event.occurredAt,\n  };\n}\n\n@Injectable()\nexport class MemoryEventBus implements IEventBus, IEventReadPort {\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  private readonly opts: EventsModuleOptions;\n\n  constructor(\n    @Optional() @Inject(EVENTS_MODULE_OPTIONS) opts?: EventsModuleOptions,\n  ) {\n    // Default so direct construction (e.g. `new MemoryEventBus()` from a\n    // unit test outside NestJS DI) keeps working without an explicit\n    // options object.\n    this.opts = opts ?? { backend: 'memory' };\n  }\n\n  async publish(event: DomainEvent): Promise<void> {\n    // Mirror the `domain_events_tier_routing_check` DB constraint at the\n    // memory backend boundary so misuse fails the same way regardless of\n    // backend (AUDIT-1).\n    this.assertTierRouting(event);\n\n    // Always record the event — even if this process is configured with a\n    // pool filter that excludes it. Test code relies on `publishedEvents`\n    // being a complete log of what was published, not a filtered view.\n    this.publishedEvents.push(event);\n\n    if (this.shouldDispatch(event)) {\n      await this.dispatch(event);\n    }\n  }\n\n  async publishMany(events: DomainEvent[]): Promise<void> {\n    for (const event of events) {\n      await this.publish(event);\n    }\n  }\n\n  async findById(eventId: string): Promise<DomainEvent | null> {\n    return this.publishedEvents.find((e) => e.id === eventId) ?? null;\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  // ============================================================================\n  // IEventReadPort (OBS-LIST-1)\n  // ============================================================================\n\n  async listEvents(query: ListEventsQuery = {}): Promise<EventPage> {\n    const limit = clampEventLimit(query.limit);\n    const keyset = query.cursor ? decodeEventCursor(query.cursor) : null;\n\n    const str = (e: DomainEvent, key: string): string | null => {\n      const v = e.metadata?.[key];\n      return typeof v === 'string' ? v : null;\n    };\n\n    const matched = this.publishedEvents.filter((e) => {\n      if (query.poolId && str(e, 'pool') !== query.poolId) return false;\n      if (query.direction && str(e, 'direction') !== query.direction)\n        return false;\n      if (query.rootRunId && str(e, 'rootRunId') !== query.rootRunId)\n        return false;\n      if (query.since && e.occurredAt.getTime() < query.since.getTime())\n        return false;\n      if (query.tenantId !== undefined) {\n        const t = str(e, 'tenantId');\n        if (query.tenantId === null) {\n          if (t !== null) return false;\n        } else if (t !== query.tenantId) {\n          return false;\n        }\n      }\n      return true;\n    });\n\n    // Order occurred_at DESC, id DESC to match the Drizzle backend keyset.\n    matched.sort((a, b) => {\n      const dt = b.occurredAt.getTime() - a.occurredAt.getTime();\n      if (dt !== 0) return dt;\n      return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;\n    });\n\n    const seeked = keyset\n      ? matched.filter((e) => {\n          const ct = e.occurredAt.getTime();\n          const kt = keyset.occurredAt.getTime();\n          if (ct < kt) return true;\n          if (ct > kt) return false;\n          return e.id < keyset.id;\n        })\n      : matched;\n\n    const hasMore = seeked.length > limit;\n    const page = hasMore ? seeked.slice(0, limit) : seeked;\n    const items = page.map(toEventSummary);\n    const last = page[page.length - 1];\n    const nextCursor =\n      hasMore && last\n        ? encodeEventCursor({ occurredAt: last.occurredAt, id: last.id })\n        : null;\n\n    return { items, nextCursor };\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  /** Filter published events by `metadata.pool`. */\n  publishedEventsForPool(pool: string): DomainEvent[] {\n    return this.publishedEvents.filter((e) => e.metadata?.['pool'] === pool);\n  }\n\n  /** Filter published events by `metadata.direction`. */\n  publishedEventsForDirection(direction: string): DomainEvent[] {\n    return this.publishedEvents.filter((e) => e.metadata?.['direction'] === direction);\n  }\n\n  /**\n   * Decide whether `event` should be dispatched to handlers given the\n   * current pool filter.\n   *\n   * Semantics (mirroring `DrizzleEventBus.processBatch`):\n   * - `opts.pools` undefined  → dispatch everything (no filter).\n   * - `opts.pools` empty array → treated as \"no filter\" to match the\n   *   Drizzle backend, where `pools && pools.length > 0` is the gate on\n   *   the `inArray` WHERE clause. Empty arrays dispatch everything.\n   * - `opts.pools` non-empty  → dispatch only when `event.metadata.pool`\n   *   is in the list. Events without `metadata.pool` do NOT match — they\n   *   are out of all configured pools by definition.\n   */\n  private shouldDispatch(event: DomainEvent): boolean {\n    const pools = this.opts.pools;\n    if (!pools || pools.length === 0) return true;\n    const eventPool = event.metadata?.['pool'];\n    return typeof eventPool === 'string' && pools.includes(eventPool);\n  }\n\n  /**\n   * Mirror the `domain_events_tier_routing_check` DB CHECK at the memory\n   * backend (AUDIT-1). Audit-tier events MUST have null/undefined\n   * `pool` and `direction` in metadata; the bridge dispatcher relies on\n   * this invariant.\n   */\n  private assertTierRouting(event: DomainEvent): void {\n    const tier = event.metadata?.['tier'];\n    if (tier !== 'audit') return;\n    const pool = event.metadata?.['pool'];\n    const direction = event.metadata?.['direction'];\n    const poolIsNull = pool === null || pool === undefined;\n    const directionIsNull = direction === null || direction === undefined;\n    if (!poolIsNull || !directionIsNull) {\n      throw new Error(\n        `MemoryEventBus: tier='audit' events must have null pool and direction ` +\n          `(got pool=${String(pool)}, direction=${String(direction)}). ` +\n          `This mirrors the domain_events CHECK constraint.`,\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"],"mappings":"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","names":[]}