@ayepi/node 0.1.0

package/dist/index.js

@@ -0,0 +1,188 @@
+import http from "node:http";
+import { Readable } from "node:stream";
+import { WebSocketServer } from "ws";
+//#region src/index.ts
+/**
+* # ayepi-node
+*
+* Node.js adapter for an ayepi {@link Server}. Bridges the `node:http`
+* `IncomingMessage`/`ServerResponse` world to the web-standard
+* `Request`/`Response` the ayepi core speaks, and serves WebSocket upgrades via
+* the [`ws`](https://github.com/websockets/ws) package wired to
+* `app.ws.open`/`message`/`close`.
+*
+* Bodies stream in both directions without buffering, response writes respect
+* backpressure (`res.write` / `'drain'`), and a client disconnect aborts the
+* per-request `AbortSignal` (the `signal` your handlers receive).
+*
+* ```ts
+* import { serve } from 'ayepi-node'
+* const close = serve(app, { port: 3000, path: '/ws' })
+* // …later
+* await close()
+* ```
+*
+* HTTP/1.1 only for v0.
+*
+* @module
+*/
+/** Build a fetch `Request` from a Node `IncomingMessage`, wiring an abort `signal`. */
+function toRequest(req, signal) {
+	const url = `${req.socket.encrypted ? "https" : "http"}://${req.headers.host ?? "localhost"}${req.url ?? "/"}`;
+	const method = req.method ?? "GET";
+	const headers = new Headers();
+	for (const [k, v] of Object.entries(req.headers)) {
+		if (v === void 0) continue;
+		if (Array.isArray(v)) for (const vv of v) headers.append(k, vv);
+		else headers.set(k, v);
+	}
+	const hasBody = method !== "GET" && method !== "HEAD";
+	const init = {
+		method,
+		headers,
+		signal
+	};
+	if (hasBody) {
+		init.body = Readable.toWeb(req);
+		init.duplex = "half";
+	}
+	return new Request(url, init);
+}
+/** Resolve once the response can accept more writes, or the socket closes. */
+function whenWritable(res) {
+	return new Promise((resolve) => {
+		const done = () => {
+			res.off("drain", done);
+			res.off("close", done);
+			resolve();
+		};
+		res.once("drain", done);
+		res.once("close", done);
+	});
+}
+/** Stream a fetch `Response` out through a Node `ServerResponse`, honoring backpressure. */
+async function sendResponse(res, response) {
+	res.statusCode = response.status;
+	const setCookies = response.headers.getSetCookie?.() ?? [];
+	response.headers.forEach((value, key) => {
+		if (key.toLowerCase() === "set-cookie") return;
+		res.setHeader(key, value);
+	});
+	if (setCookies.length > 0) res.setHeader("set-cookie", setCookies);
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	const reader = response.body.getReader();
+	res.once("close", () => void reader.cancel().catch(() => {}));
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (res.writableEnded || res.destroyed) break;
+			if (!res.write(value)) await whenWritable(res);
+		}
+	} catch {} finally {
+		if (!res.writableEnded) res.end();
+	}
+}
+/**
+* Create a `node:http` request listener for an ayepi app — useful for mounting on
+* an existing server, behind a proxy, or alongside other routes.
+*
+* Each request gets an `AbortController` whose signal aborts when the client
+* disconnects before the response finishes; that signal is the `signal` your
+* handlers receive.
+*
+* @example
+* ```ts
+* http.createServer(createRequestListener(app)).listen(3000)
+* ```
+*/
+function createRequestListener(app) {
+	return (req, res) => {
+		const ac = new AbortController();
+		res.on("close", () => {
+			if (!res.writableFinished) ac.abort();
+		});
+		app.fetch(toRequest(req, ac.signal)).then((response) => sendResponse(res, response)).catch((err) => {
+			if (!res.headersSent) {
+				res.statusCode = 500;
+				res.setHeader("content-type", "application/json");
+				res.end(JSON.stringify({ error: {
+					code: "INTERNAL",
+					message: err instanceof Error ? err.message : "internal error"
+				} }));
+			} else if (!res.writableEnded) res.end();
+		});
+	};
+}
+/**
+* Attach an ayepi app's WebSocket handling to an `http.Server`'s `upgrade` event.
+*
+* Each upgraded socket becomes a {@link WsConn} via `app.ws.open`; inbound text
+* frames are forwarded to `app.ws.message`, and a socket close calls
+* `app.ws.close`. The upgrade `Request` (with its headers) is handed to
+* `app.ws.open`, so subscription guards can authenticate from it.
+*
+* @param app    - the ayepi app.
+* @param server - the HTTP server to listen for upgrades on.
+* @param path   - when set, only upgrades on this pathname are accepted.
+* @returns the underlying {@link WebSocketServer} (call `.close()` to stop).
+*/
+function handleUpgrade(app, server, path) {
+	const wss = new WebSocketServer({ noServer: true });
+	server.on("upgrade", (req, socket, head) => {
+		if (path !== void 0) {
+			if (new URL(req.url ?? "/", "http://localhost").pathname !== path) {
+				socket.destroy();
+				return;
+			}
+		}
+		wss.handleUpgrade(req, socket, head, (ws) => {
+			const request = toRequest(req, new AbortController().signal);
+			const conn = app.ws.open((frame) => {
+				if (ws.readyState === ws.OPEN) ws.send(frame);
+			}, request);
+			ws.on("message", (data) => {
+				app.ws.message(conn, String(data));
+			});
+			ws.on("close", () => app.ws.close(conn));
+			ws.on("error", () => app.ws.close(conn));
+		});
+	});
+	return wss;
+}
+/**
+* Boot an ayepi app on a real HTTP + WebSocket port.
+*
+* @returns a `close()` function that stops accepting connections, terminates
+* live WebSockets, and resolves once the server has shut down.
+*
+* @example
+* ```ts
+* const close = serve(app, { port: 3000, path: '/ws', onListen: ({ port }) => console.log(`:${port}`) })
+* process.on('SIGTERM', () => void close())
+* ```
+*/
+function serve(app, opts) {
+	const server = http.createServer(createRequestListener(app));
+	const wss = handleUpgrade(app, server, opts.path);
+	const hostname = opts.hostname ?? "0.0.0.0";
+	server.listen(opts.port, hostname, () => {
+		const addr = server.address();
+		const port = typeof addr === "object" && addr ? addr.port : opts.port;
+		opts.onListen?.({
+			port,
+			hostname
+		});
+	});
+	return () => new Promise((resolve, reject) => {
+		for (const ws of wss.clients) ws.terminate();
+		wss.close(() => {
+			server.close((err) => err ? reject(err) : resolve());
+		});
+	});
+}
+//#endregion
+export { createRequestListener, handleUpgrade, serve };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@ayepi/node",
+  "version": "0.1.0",
+  "description": "Node.js (node:http + ws) adapter for @ayepi/core — bridges IncomingMessage ⇄ fetch Request/Response and serves WebSocket upgrades",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ClickerMonkey/ayepi.git",
+    "directory": "packages/node"
+  },
+  "homepage": "https://github.com/ClickerMonkey/ayepi/tree/main/packages/node#readme",
+  "bugs": {
+    "url": "https://github.com/ClickerMonkey/ayepi/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@ayepi/core": "^0.1.0"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.0",
+    "@types/ws": "^8.5.13",
+    "@vitest/coverage-v8": "^2.1.8",
+    "publint": "^0.3.0",
+    "tsdown": "^0.12.0",
+    "vitest": "^2.1.8",
+    "zod": "^4.4.3",
+    "@ayepi/core": "0.1.0"
+  },
+  "keywords": [
+    "ayepi",
+    "@ayepi/core",
+    "node",
+    "http",
+    "websocket",
+    "ws",
+    "adapter",
+    "server"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage",
+    "attw": "attw --pack .",
+    "publint": "publint"
+  }
+}