Initial Commit

packages/networking/network/websocket-gateway/tests/setup/real-ws-adapter.ts

@@ -0,0 +1,142 @@
+import { createServer, type Server as HttpServer } from "node:http";
+import { type WebSocket, WebSocketServer } from "ws";
+import { handleHealth } from "../../src/health/health.js";
+import type {
+    Handshake,
+    WsServerFactory,
+    WsServerLike,
+    WsServerStartOptions,
+    WsServerStartResult,
+    WsSocketLike,
+} from "../../src/types/types.js";
+
+/**
+ * Production-grade `WsServerLike` implementation backed by the real
+ * `ws` package and a Node `http.Server`. The HTTP server also routes
+ * `/health` / `/ready` / `/live` probes through the daemon's snapshot
+ * so the integration test can hit those endpoints from the same port.
+ */
+export class RealWsServer implements WsServerLike {
+    #http: HttpServer | undefined;
+    #wss: WebSocketServer | undefined;
+    readonly #sockets = new Map<
+        string,
+        { socket: WebSocket; like: WsSocketLike }
+    >();
+    readonly #snapshot: () => {
+        running: boolean;
+        disposed: boolean;
+        clientCount: number;
+        roomCount: number;
+        startedAt: number | undefined;
+    };
+    #nextId = 0;
+
+    public constructor(
+        snapshot: () => {
+            running: boolean;
+            disposed: boolean;
+            clientCount: number;
+            roomCount: number;
+            startedAt: number | undefined;
+        }
+    ) {
+        this.#snapshot = snapshot;
+    }
+
+    public async start(
+        opts: WsServerStartOptions
+    ): Promise<WsServerStartResult> {
+        const http = createServer((req, res) => {
+            const handled = handleHealth(req.url, this.#snapshot());
+            if (handled) {
+                res.writeHead(handled.status, {
+                    "content-type": "application/json",
+                });
+                res.end(handled.body);
+                return;
+            }
+            res.writeHead(404, { "content-type": "text/plain" });
+            res.end("not found");
+        });
+        const wss = new WebSocketServer({ server: http });
+        wss.on("connection", (socket, request) => {
+            const id = `wsc-${++this.#nextId}`;
+            const url = request.url ?? "/";
+            const q = new URL(url, "http://x").searchParams;
+            const handshake: Handshake = {
+                headers: Object.fromEntries(
+                    Object.entries(request.headers).map(([k, v]) => [
+                        k,
+                        Array.isArray(v) ? v.join(",") : v,
+                    ])
+                ),
+                remoteAddress: request.socket.remoteAddress,
+                url,
+                query: Object.fromEntries(q.entries()),
+            };
+            const like: WsSocketLike = {
+                id,
+                remoteAddress: request.socket.remoteAddress,
+                send: (payload) => {
+                    if (socket.readyState === socket.OPEN) socket.send(payload);
+                },
+                close: (code, reason) => socket.close(code, reason),
+            };
+            this.#sockets.set(id, { socket, like });
+            opts.callbacks.onConnection(like, handshake);
+            socket.on("message", (data) =>
+                opts.callbacks.onMessage(id, data.toString())
+            );
+            socket.on("close", (code, reason) => {
+                this.#sockets.delete(id);
+                opts.callbacks.onClose(id, code, reason.toString());
+            });
+            socket.on("error", (err) => opts.callbacks.onError(id, err));
+        });
+        await new Promise<void>((resolve, reject) => {
+            const onErr = (err: Error): void => reject(err);
+            http.once("error", onErr);
+            http.listen(opts.port, opts.host, () => {
+                http.removeListener("error", onErr);
+                resolve();
+            });
+        });
+        this.#http = http;
+        this.#wss = wss;
+        const addr = http.address() as { address: string; port: number };
+        return { address: addr.address, port: addr.port };
+    }
+
+    public async stop(): Promise<void> {
+        await new Promise<void>((resolve) => {
+            this.#wss?.close(() => resolve());
+        });
+        await new Promise<void>((resolve) => {
+            const http = this.#http;
+            if (!http) {
+                resolve();
+                return;
+            }
+            http.close(() => resolve());
+        });
+    }
+
+    public async closeAll(code = 1001, reason = "shutdown"): Promise<void> {
+        for (const { socket } of this.#sockets.values())
+            socket.close(code, reason);
+    }
+}
+
+/** Build a real-ws factory bound to a snapshot accessor. */
+export function makeRealWsServerFactory(
+    snapshot: () => {
+        running: boolean;
+        disposed: boolean;
+        clientCount: number;
+        roomCount: number;
+        startedAt: number | undefined;
+    }
+): WsServerFactory {
+    return () => new RealWsServer(snapshot);
+}