first commit

2026-10-03 13:40:26 +02:00
parent 732a5b5a16
commit 566f415fa7
555 changed files with 62704 additions and 0 deletions
--- a/libs/api/shared/infrastructure/src/lib/event-store/events-bridge.ts
+++ b/libs/api/shared/infrastructure/src/lib/event-store/events-bridge.ts
@@ -0,0 +1,100 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnApplicationBootstrap,
+  OnApplicationShutdown,
+  Type,
+} from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import { IEventHandler } from '@nestjs/cqrs';
+import { SerializableEvent } from '@task-stream/api/shared/domain';
+import { hostname } from 'node:os';
+import { EventStreamConsumer } from '../event-stream/event-stream.consumer';
+import {
+  EVENT_STREAM_OPTIONS,
+  EventStreamOptions,
+} from '../event-stream/event-stream.options';
+import { RedisConnectionFactory } from '../redis/redis-connection.factory';
+import { EventDeserializer } from './deserializers/event.deserializer';
+
+export const EVENTS_BRIDGE_ENABLED = Symbol('EVENTS_BRIDGE_ENABLED');
+
+/** Metadata written by @EventsHandler(...events) (@nestjs/cqrs). */
+const EVENTS_HANDLER_METADATA = '__eventsHandler__';
+
+/**
+ * Redis stream → @EventsHandler. Plays the role of the event-store change
+ * stream: every stored event is deserialized and handed to the event
+ * handlers registered for its class (read-model projections, realtime...).
+ *
+ * Unlike `eventBus.subject$.next()`, handlers are awaited one event at a
+ * time, so events of an aggregate are projected in order, and the entry is
+ * acknowledged in Redis only once every handler succeeded (otherwise it
+ * stays pending and is retried).
+ */
+@Injectable()
+export class EventsBridge
+  implements OnApplicationBootstrap, OnApplicationShutdown
+{
+  private readonly logger = new Logger(EventsBridge.name);
+  private consumer?: EventStreamConsumer;
+  private readonly handlers = new Map<Type, IEventHandler[]>();
+
+  constructor(
+    private readonly connections: RedisConnectionFactory,
+    @Inject(EVENT_STREAM_OPTIONS) private readonly stream: EventStreamOptions,
+    @Inject(EVENTS_BRIDGE_ENABLED) private readonly enabled: boolean,
+    private readonly eventDeserializer: EventDeserializer,
+    private readonly discovery: DiscoveryService,
+  ) {}
+
+  async onApplicationBootstrap(): Promise<void> {
+    if (!this.enabled) {
+      this.logger.log('Events bridge disabled on this instance');
+      return;
+    }
+    this.registerEventHandlers();
+    this.consumer = new EventStreamConsumer(
+      this.connections.create('events-bridge'),
+      {
+        streamKey: this.stream.streamKey,
+        group: 'events-bridge',
+        consumer: hostname(),
+      },
+      (event) => this.handleEvent(event),
+    );
+    await this.consumer.start();
+    this.logger.log(
+      `Bridging ${this.stream.streamKey} to ${this.handlers.size} event type(s)`,
+    );
+  }
+
+  async onApplicationShutdown(): Promise<void> {
+    await this.consumer?.stop();
+  }
+
+  private registerEventHandlers(): void {
+    for (const wrapper of this.discovery.getProviders()) {
+      if (!wrapper.metatype || !wrapper.instance) continue;
+      const events: Type[] | undefined = Reflect.getMetadata(
+        EVENTS_HANDLER_METADATA,
+        wrapper.metatype,
+      );
+      for (const eventCls of events ?? []) {
+        this.handlers.set(eventCls, [
+          ...(this.handlers.get(eventCls) ?? []),
+          wrapper.instance as IEventHandler,
+        ]);
+      }
+    }
+  }
+
+  private async handleEvent(stored: SerializableEvent): Promise<void> {
+    const { data: event } = this.eventDeserializer.deserialize(stored);
+    const eventCls = Object.getPrototypeOf(event).constructor as Type;
+    for (const handler of this.handlers.get(eventCls) ?? []) {
+      await handler.handle(event);
+    }
+  }
+}