@pattern-stack/codegen 0.10.0 → 0.10.1

package/dist/runtime/subsystems/events/index.js

@@ -359,13 +359,12 @@ var BRIDGE_OUTBOX_DRAIN_HOOK = "BRIDGE_OUTBOX_DRAIN_HOOK";
 // runtime/subsystems/events/event-bus.drizzle-backend.ts
 var POLL_INTERVAL_MS = 1e3;
 var POLL_BATCH_SIZE = 50;
-function toInsertValues(event) {
+function toInsertValues(event, multiTenant) {
   const metadata = event.metadata ?? void 0;
   const pool = metadata?.["pool"] ?? null;
   const direction = metadata?.["direction"] ?? null;
-  const tenantId = metadata?.["tenantId"] ?? null;
   const tier = metadata?.["tier"] ?? "domain";
-  return {
+  const base = {
     id: event.id,
     type: event.type,
     aggregateId: event.aggregateId,
@@ -377,9 +376,11 @@ function toInsertValues(event) {
     metadata: event.metadata,
     pool,
     direction,
-    tier,
-    tenantId
+    tier
   };
+  if (!multiTenant) return base;
+  const tenantId = metadata?.["tenantId"] ?? null;
+  return { ...base, tenantId };
 }
 function toEventSummary(r) {
   const metadata = r.metadata ?? void 0;
@@ -394,7 +395,11 @@ function toEventSummary(r) {
     direction: r.direction,
     tier: r.tier,
     rootRunId: typeof rootRunId === "string" ? rootRunId : null,
-    tenantId: r.tenantId,
+    // EVT-8: `tenant_id` is a scaffold-time conditional column. Read it
+    // structurally so this projection typechecks against both the
+    // multi-tenant schema (column present) and the single-tenant schema
+    // (column absent → undefined → null).
+    tenantId: r.tenantId ?? null,
     occurredAt: r.occurredAt instanceof Date ? r.occurredAt : new Date(r.occurredAt),
     processedAt: r.processedAt == null ? null : r.processedAt instanceof Date ? r.processedAt : new Date(r.processedAt)
   };
@@ -431,12 +436,14 @@ var DrizzleEventBus = class {
   // ============================================================================
   async publish(event, tx) {
     const client = tx ?? this.db;
-    await client.insert(domainEvents).values(toInsertValues(event));
+    const multiTenant = this.opts.multiTenant ?? false;
+    await client.insert(domainEvents).values(toInsertValues(event, multiTenant));
   }
   async publishMany(events, tx) {
     if (events.length === 0) return;
     const client = tx ?? this.db;
-    await client.insert(domainEvents).values(events.map(toInsertValues));
+    const multiTenant = this.opts.multiTenant ?? false;
+    await client.insert(domainEvents).values(events.map((e) => toInsertValues(e, multiTenant)));
   }
   async findById(eventId) {
     const rows = await this.db.select().from(domainEvents).where(eq(domainEvents.id, eventId)).limit(1);
@@ -478,9 +485,10 @@ var DrizzleEventBus = class {
         sql2`${domainEvents.metadata}->>'rootRunId' = ${query.rootRunId}`
       );
     }
-    if (query.tenantId !== void 0) {
+    if (this.opts.multiTenant && query.tenantId !== void 0) {
+      const tenantIdColumn = domainEvents.tenantId;
       conditions.push(
-        query.tenantId === null ? sql2`${domainEvents.tenantId} is null` : eq(domainEvents.tenantId, query.tenantId)
+        query.tenantId === null ? sql2`${tenantIdColumn} is null` : eq(tenantIdColumn, query.tenantId)
       );
     }
     if (query.cursor) {
@@ -811,233 +819,12 @@ MemoryEventBus = __decorateClass([
   __decorateParam(0, Inject3(EVENTS_MODULE_OPTIONS))
 ], MemoryEventBus);
 
-// runtime/subsystems/events/event-bus.redis-backend.ts
-import { Injectable as Injectable4, Inject as Inject4, Logger as Logger3 } from "@nestjs/common";
-var CHANNEL_PREFIX = "events:";
-async function createRedisClient(url) {
-  let Redis;
-  try {
-    const mod = await import("ioredis");
-    Redis = mod.default ?? mod;
-  } catch {
-    throw new Error(
-      'RedisEventBus requires the "ioredis" package. Install it with: npm install ioredis'
-    );
-  }
-  return new Redis(url);
-}
-var RedisEventBus = class {
-  constructor(redisUrl) {
-    this.redisUrl = redisUrl;
-  }
-  redisUrl;
-  logger = new Logger3(RedisEventBus.name);
-  publisher = null;
-  subscriber = null;
-  connected = false;
-  /**
-   * In-process subscriber registry. Handlers registered here are called when
-   * a message arrives on the subscriber client — keeping fan-out within the
-   * same process without an extra round-trip through Redis.
-   */
-  handlers = /* @__PURE__ */ new Map();
-  /**
-   * Track which event types have active Redis subscriptions.
-   * Used to avoid subscribing multiple times to the same type channel.
-   */
-  subscribedTypes = /* @__PURE__ */ new Set();
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  async onModuleInit() {
-    this.publisher = await createRedisClient(this.redisUrl);
-    this.subscriber = await createRedisClient(this.redisUrl);
-    this.publisher.on(
-      "error",
-      (err) => this.logger.error(`Redis publisher error: ${err.message}`, err.stack)
-    );
-    this.subscriber.on(
-      "error",
-      (err) => this.logger.error(`Redis subscriber error: ${err.message}`, err.stack)
-    );
-    this.subscriber.on("message", (channel, message) => {
-      void this.handleMessage(channel, message);
-    });
-    this.connected = true;
-    this.logger.log(`RedisEventBus connected to ${this.redisUrl}`);
-  }
-  async onModuleDestroy() {
-    this.connected = false;
-    if (this.subscriber) {
-      await this.subscriber.unsubscribe();
-      this.subscriber.disconnect();
-      this.subscriber = null;
-    }
-    if (this.publisher) {
-      this.publisher.disconnect();
-      this.publisher = null;
-    }
-    this.subscribedTypes.clear();
-    this.logger.log("RedisEventBus disconnected");
-  }
-  // ============================================================================
-  // IEventBus
-  // ============================================================================
-  /**
-   * Publish a single event.
-   *
-   * `tx` is accepted but ignored — see module-level JSDoc for details.
-   */
-  async publish(event, tx) {
-    void tx;
-    this.assertConnected();
-    const payload = this.serialize(event);
-    const channel = `${CHANNEL_PREFIX}${event.type}`;
-    await this.publisher.publish(channel, payload);
-  }
-  /**
-   * Publish multiple events using a pipeline so all PUBLISH commands are sent
-   * in a single round-trip.
-   *
-   * `tx` is accepted but ignored — see module-level JSDoc for details.
-   */
-  async publishMany(events, tx) {
-    void tx;
-    if (events.length === 0) return;
-    this.assertConnected();
-    const pipeline = this.publisher.pipeline();
-    for (const event of events) {
-      const payload = this.serialize(event);
-      const channel = `${CHANNEL_PREFIX}${event.type}`;
-      pipeline.publish(channel, payload);
-    }
-    await pipeline.exec();
-  }
-  /**
-   * Register a handler for a specific event type.
-   * Returns an unsubscribe function — call it to remove the handler.
-   *
-   * On first handler for a type, subscribes to the per-type Redis channel.
-   * On removal of the last handler for a type, unsubscribes from the channel.
-   */
-  /**
-   * Lookup by id is unsupported on the Redis Pub/Sub backend — Pub/Sub
-   * does not retain history. Always returns `null`. Logs a warning the
-   * first time it's called so a misconfiguration surfaces visibly. Using
-   * the bridge with the Redis backend is unsupported (the bridge requires
-   * a durable event store).
-   */
-  warnedFindById = false;
-  async findById(_eventId) {
-    if (!this.warnedFindById) {
-      this.warnedFindById = true;
-      this.logger.warn(
-        "RedisEventBus.findById is unsupported (Pub/Sub has no history). The bridge subsystem requires a durable event store; switch to DrizzleEventBus if you need bridge fanout."
-      );
-    }
-    return null;
-  }
-  subscribe(eventType, handler) {
-    if (!this.handlers.has(eventType)) {
-      this.handlers.set(eventType, /* @__PURE__ */ new Set());
-      void this.subscribeToType(eventType);
-    }
-    const set = this.handlers.get(eventType);
-    const h = handler;
-    set.add(h);
-    return () => {
-      set.delete(h);
-      if (set.size === 0) {
-        this.handlers.delete(eventType);
-        void this.unsubscribeFromType(eventType);
-      }
-    };
-  }
-  // ============================================================================
-  // Internal helpers
-  // ============================================================================
-  assertConnected() {
-    if (!this.connected || !this.publisher) {
-      throw new Error(
-        "RedisEventBus is not connected. Ensure the module has been initialised before publishing."
-      );
-    }
-  }
-  serialize(event) {
-    return JSON.stringify({
-      ...event,
-      occurredAt: event.occurredAt.toISOString()
-    });
-  }
-  deserialize(raw) {
-    const parsed = JSON.parse(raw);
-    return {
-      ...parsed,
-      occurredAt: new Date(parsed.occurredAt)
-    };
-  }
-  async handleMessage(channel, message) {
-    let event;
-    try {
-      event = this.deserialize(message);
-    } catch (err) {
-      this.logger.warn(`Failed to deserialize event on channel "${channel}": ${err}`);
-      return;
-    }
-    await this.dispatch(event);
-  }
-  async dispatch(event) {
-    const set = this.handlers.get(event.type);
-    if (!set) return;
-    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}`
-        );
-      }
-    }
-  }
-  /**
-   * Subscribe to a per-type Redis channel.
-   * Called lazily when the first handler is registered for a type.
-   */
-  async subscribeToType(eventType) {
-    if (this.subscribedTypes.has(eventType)) {
-      return;
-    }
-    const channel = `${CHANNEL_PREFIX}${eventType}`;
-    try {
-      await this.subscriber.subscribe(channel);
-      this.subscribedTypes.add(eventType);
-    } catch (err) {
-      this.logger.error(`Failed to subscribe to channel "${channel}": ${err}`);
-    }
-  }
-  /**
-   * Unsubscribe from a per-type Redis channel.
-   * Called when the last handler for a type is removed.
-   */
-  async unsubscribeFromType(eventType) {
-    if (!this.subscribedTypes.has(eventType)) {
-      return;
-    }
-    const channel = `${CHANNEL_PREFIX}${eventType}`;
-    try {
-      await this.subscriber.unsubscribe(channel);
-      this.subscribedTypes.delete(eventType);
-    } catch (err) {
-      this.logger.error(`Failed to unsubscribe from channel "${channel}": ${err}`);
-    }
-  }
-};
-RedisEventBus = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject4(REDIS_URL))
-], RedisEventBus);
-
 // runtime/subsystems/events/events.module.ts
+async function loadRedisEventBus() {
+  const specifier = "./event-bus.redis-backend";
+  const mod = await import(specifier);
+  return mod.RedisEventBus;
+}
 function buildTypedBusProviders(multiTenant) {
   return [
     TypedEventBus,
@@ -1045,7 +832,7 @@ function buildTypedBusProviders(multiTenant) {
     { provide: EVENTS_MULTI_TENANT, useValue: multiTenant }
   ];
 }
-function buildEventBusAsync(options, db, redisUrl) {
+async function buildEventBusAsync(options, db, redisUrl) {
   if (options.backend === "drizzle") {
     if (!db) {
       throw new Error(
@@ -1055,6 +842,7 @@ function buildEventBusAsync(options, db, redisUrl) {
     return new DrizzleEventBus(db, options);
   }
   if (options.backend === "redis") {
+    const RedisEventBus = await loadRedisEventBus();
     return new RedisEventBus(redisUrl);
   }
   return new MemoryEventBus(options);
@@ -1116,9 +904,20 @@ var EventsModule = class {
         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,
+          {
+            // #6: useFactory + dynamic import so the consumer's tsc never
+            // needs to resolve `event-bus.redis-backend.ts` for drizzle/
+            // memory installs (the file is filtered out by
+            // `backendFileFilter`). Nest awaits async factories + manages
+            // lifecycle on the returned instance, so we drop the old bare
+            // `RedisEventBus` provider entry.
+            provide: EVENT_BUS,
+            useFactory: async (url) => {
+              const RedisEventBus = await loadRedisEventBus();
+              return new RedisEventBus(url);
+            },
+            inject: [REDIS_URL]
+          },
           ...buildTypedBusProviders(multiTenant)
         ],
         exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
@@ -1153,7 +952,6 @@ export {
   EventsModule,
   MemoryEventBus,
   MissingTenantIdError,
-  RedisEventBus,
   TYPED_EVENT_BUS,
   TypedEventBus,
   domainEvents