@bgord/bun 1.12.8 → 1.12.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.12.8",
+  "version": "1.12.9",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -45,7 +45,7 @@
   "dependencies": {
     "@bgord/tools": "1.3.24",
     "emittery": "2.0.0",
-    "hono": "4.12.6",
+    "hono": "4.12.7",
     "node-cache": "5.1.2"
   },
   "peerDependencies": {

package/readme.md

@@ -418,6 +418,16 @@ src/
 ├── smtp-pass.vo.ts
 ├── smtp-port.vo.ts
 ├── smtp-user.vo.ts
+├── sse-connection-hono.adapter.ts
+├── sse-connection-hono.handler.ts
+├── sse-connection-noop.adapter.ts
+├── sse-connection-with-logger.adapter.ts
+├── sse-connection.port.ts
+├── sse-registry-collecting.adapter.ts
+├── sse-registry-noop.adapter.ts
+├── sse-registry-with-logger.adapter.ts
+├── sse-registry.adapter.ts
+├── sse-registry.port.ts
 ├── ssr-bun.service.ts
 ├── ssr.service.ts
 ├── static-files-hono.service.ts

package/src/index.ts

@@ -344,6 +344,17 @@ export * from "./smtp-host.vo";
 export * from "./smtp-pass.vo";
 export * from "./smtp-port.vo";
 export * from "./smtp-user.vo";
+export * from "./sse-connection.port";
+export * from "./sse-connection-hono.adapter";
+export * from "./sse-connection-hono.handler";
+export * from "./sse-connection-hono.handler";
+export * from "./sse-connection-noop.adapter";
+export * from "./sse-connection-with-logger.adapter";
+export * from "./sse-registry.adapter";
+export * from "./sse-registry.port";
+export * from "./sse-registry-collecting.adapter";
+export * from "./sse-registry-noop.adapter";
+export * from "./sse-registry-with-logger.adapter";
 export * from "./ssr.service";
 export * from "./ssr-bun.service";
 export * from "./static-files-hono.service";

package/src/message-bus-with-logger.adapter.ts

@@ -3,15 +3,12 @@ import type { LogCoreType, LoggerPort } from "./logger.port";
 import type { Message, ToMessageMap } from "./message.types";
 import type { MessageBusPort } from "./message-bus.port";
 
-type Dependencies = { Logger: LoggerPort };
+type Dependencies<Messages extends Message> = { inner: MessageBusPort<Messages>; Logger: LoggerPort };
 
 export class MessageBusWithLoggerAdapter<Messages extends Message> implements MessageBusPort<Messages> {
   private readonly base = { component: "infra", operation: "message_bus_emit" };
 
-  constructor(
-    private readonly inner: MessageBusPort<Messages>,
-    private readonly deps: Dependencies,
-  ) {}
+  constructor(private readonly deps: Dependencies<Messages>) {}
 
   async emit<M extends Messages>(message: M): Promise<void> {
     this.deps.Logger.info({
@@ -21,14 +18,14 @@ export class MessageBusWithLoggerAdapter<Messages extends Message> implements Me
       ...this.base,
     });
 
-    return this.inner.emit(message);
+    return this.deps.inner.emit(message);
   }
 
   on<MessageName extends keyof ToMessageMap<Messages>>(
     name: MessageName,
     handler: (message: ToMessageMap<Messages>[MessageName]) => void | Promise<void>,
   ): void {
-    this.inner.on(name, handler);
+    this.deps.inner.on(name, handler);
   }
 }
 

package/src/sse-connection-hono.adapter.ts

@@ -0,0 +1,49 @@
+import type * as tools from "@bgord/tools";
+import type { Context } from "hono";
+import { streamSSE } from "hono/streaming";
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+import type { SseRegistryPort } from "./sse-registry.port";
+
+export type SseConnectionHonoAdapterConfig = { keepalive: tools.Duration };
+
+export class SseConnectionHonoAdapter<Messages extends Message> implements SseConnectionPort<Messages> {
+  private stream: Awaited<Parameters<Parameters<typeof streamSSE>[1]>[0]> | null = null;
+
+  constructor(
+    private readonly registry: SseRegistryPort<Messages>,
+    private readonly userId: string,
+    private readonly config: SseConnectionHonoAdapterConfig,
+  ) {}
+
+  attach(c: Context): Response {
+    return streamSSE(c, async (stream) => {
+      this.stream = stream;
+
+      this.registry.register(this.userId, this);
+
+      // Stryker disable all
+      stream.onAbort(() => this.registry.unregister(this.userId, this));
+      // Stryker restore all
+
+      while (!stream.closed) {
+        await stream.sleep(this.config.keepalive.ms);
+        await stream.writeSSE({ event: "ping", data: "" });
+      }
+    });
+  }
+
+  async send<M extends Messages>(message: M): Promise<void> {
+    // Stryker disable all
+    await this.stream?.writeSSE({ event: message.name, data: JSON.stringify(message) });
+    // Stryker restore all;
+  }
+
+  close(callback: () => void): void {
+    this.registry.unregister(this.userId, this);
+    callback();
+    // Stryker disable all
+    this.stream?.close();
+    // Stryker restore all
+  }
+}

package/src/sse-connection-hono.handler.ts

@@ -0,0 +1,22 @@
+import { createFactory } from "hono/factory";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import type { Message } from "./message.types";
+import { SseConnectionHonoAdapter, type SseConnectionHonoAdapterConfig } from "./sse-connection-hono.adapter";
+import type { SseRegistryPort } from "./sse-registry.port";
+
+const factory = createFactory();
+
+export class SseConnectionHonoHandler<Messages extends Message> implements HandlerHonoPort {
+  constructor(
+    private readonly registry: SseRegistryPort<Messages>,
+    private readonly config: SseConnectionHonoAdapterConfig,
+  ) {}
+
+  handle() {
+    return factory.createHandlers<{}, any, { Variables: { user: { id: string } } }>((c) => {
+      const userId = c.get("user").id;
+      const adapter = new SseConnectionHonoAdapter<Messages>(this.registry, userId, this.config);
+      return adapter.attach(c);
+    });
+  }
+}

package/src/sse-connection-noop.adapter.ts

@@ -0,0 +1,8 @@
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+
+export class SseConnectionNoopAdapter<Messages extends Message> implements SseConnectionPort<Messages> {
+  async send<M extends Messages>(_message: M) {}
+
+  close(_callback: () => void): void {}
+}

package/src/sse-connection-with-logger.adapter.ts

@@ -0,0 +1,34 @@
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { LoggerPort } from "./logger.port";
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+
+type Dependencies<Messages extends Message> = { inner: SseConnectionPort<Messages>; Logger: LoggerPort };
+
+export class SseConnectionWithLoggerAdapter<Messages extends Message> implements SseConnectionPort<Messages> {
+  private readonly base = { component: "infra", operation: "sse_connection" };
+
+  constructor(private readonly deps: Dependencies<Messages>) {}
+
+  async send<M extends Messages>(message: M) {
+    this.deps.Logger.debug({
+      message: `${message.name} sent`,
+      metadata: message,
+      correlationId: CorrelationStorage.get(),
+      ...this.base,
+    });
+
+    await this.deps.inner.send(message);
+  }
+
+  close(callback: () => void): void {
+    this.deps.Logger.debug({
+      message: "SSE connection closed",
+      metadata: {},
+      correlationId: CorrelationStorage.get(),
+      ...this.base,
+    });
+
+    this.deps.inner.close(callback);
+  }
+}

package/src/sse-connection.port.ts

@@ -0,0 +1,7 @@
+import type { Message } from "./message.types";
+
+export interface SseConnectionPort<Messages extends Message> {
+  send<M extends Messages>(message: M): Promise<void>;
+
+  close(callback: () => void): void;
+}

package/src/sse-registry-collecting.adapter.ts

@@ -0,0 +1,15 @@
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+import type { SseRegistryPort } from "./sse-registry.port";
+
+export class SseRegistryCollectingAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
+  public emitted: Array<{ userId: string; message: Messages }> = [];
+
+  register(_userId: string, _connection: SseConnectionPort<Messages>): void {}
+
+  unregister(_userId: string, _connection: SseConnectionPort<Messages>): void {}
+
+  async emit<M extends Messages>(userId: string, message: M): Promise<void> {
+    this.emitted.push({ userId, message });
+  }
+}

package/src/sse-registry-noop.adapter.ts

@@ -0,0 +1,11 @@
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+import type { SseRegistryPort } from "./sse-registry.port";
+
+export class SseRegistryNoopAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
+  register(_userId: string, _connection: SseConnectionPort<Messages>): void {}
+
+  unregister(_userId: string, _connection: SseConnectionPort<Messages>): void {}
+
+  async emit<M extends Messages>(_userId: string, _message: M): Promise<void> {}
+}

package/src/sse-registry-with-logger.adapter.ts

@@ -0,0 +1,46 @@
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { LoggerPort } from "./logger.port";
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+import type { SseRegistryPort } from "./sse-registry.port";
+
+type Dependencies<Messages extends Message> = { inner: SseRegistryPort<Messages>; Logger: LoggerPort };
+
+export class SseRegistryWithLoggerAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
+  private readonly base = { component: "infra", operation: "sse_registry" };
+
+  constructor(private readonly deps: Dependencies<Messages>) {}
+
+  register(userId: string, connection: SseConnectionPort<Messages>): void {
+    this.deps.Logger.info({
+      message: "SSE connection registered",
+      metadata: { userId },
+      correlationId: CorrelationStorage.get(),
+      ...this.base,
+    });
+
+    this.deps.inner.register(userId, connection);
+  }
+
+  unregister(userId: string, connection: SseConnectionPort<Messages>): void {
+    this.deps.Logger.info({
+      message: "SSE connection unregistered",
+      metadata: { userId },
+      correlationId: CorrelationStorage.get(),
+      ...this.base,
+    });
+
+    this.deps.inner.unregister(userId, connection);
+  }
+
+  async emit<M extends Messages>(userId: string, message: M): Promise<void> {
+    this.deps.Logger.info({
+      message: `${message.name} emitted`,
+      metadata: { userId, message },
+      correlationId: CorrelationStorage.get(),
+      ...this.base,
+    });
+
+    return this.deps.inner.emit(userId, message);
+  }
+}

package/src/sse-registry.adapter.ts

@@ -0,0 +1,23 @@
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+import type { SseRegistryPort } from "./sse-registry.port";
+
+export class SseRegistryAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
+  private readonly connections = new Map<string, Set<SseConnectionPort<Messages>>>();
+
+  register(userId: string, connection: SseConnectionPort<Messages>): void {
+    if (!this.connections.has(userId)) this.connections.set(userId, new Set());
+
+    this.connections.get(userId)!.add(connection);
+  }
+
+  unregister(userId: string, connection: SseConnectionPort<Messages>): void {
+    this.connections.get(userId)?.delete(connection);
+  }
+
+  async emit<M extends Messages>(userId: string, message: M): Promise<void> {
+    for (const connection of this.connections.get(userId) ?? []) {
+      await connection.send(message);
+    }
+  }
+}

package/src/sse-registry.port.ts

@@ -0,0 +1,10 @@
+import type { Message } from "./message.types";
+import type { SseConnectionPort } from "./sse-connection.port";
+
+export interface SseRegistryPort<Messages extends Message> {
+  register(userId: string, connection: SseConnectionPort<Messages>): void;
+
+  unregister(userId: string, connection: SseConnectionPort<Messages>): void;
+
+  emit<M extends Messages>(userId: string, message: M): Promise<void>;
+}