@open-nest/node 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,52 @@
+import { FetchAdapter, Fetcher, GatewayClient, WsGateway } from "open-nest";
+import { INestApplication, NestApplicationOptions, Type } from "@nestjs/common";
+//#region src/index.d.ts
+interface NodeSocket extends GatewayClient {
+  data: {
+    path: string;
+  };
+}
+/**
+ * Records Nest gateways during `init`. `node:http` performs the upgrade.
+ */
+export declare class NodeWsAdapter extends WsGateway<NodeSocket> {
+  constructor();
+  dispose(): Promise<void>;
+}
+/**
+ * Fetch adapter plus static files via `node:fs`.
+ */
+export declare class NodeAdapter extends FetchAdapter {
+  useStaticAssets(root?: string, options?: {
+    prefix?: string;
+    index?: string | false;
+  }): this;
+}
+export interface CreateNodeServerOptions {
+  /**
+   * Root Nest module.
+   */
+  module: Type<unknown>;
+  /**
+   * Port passed to `node:http`. `0` asks the OS for a free port.
+   */
+  port?: number;
+  /**
+   * Runs after the app is created and before init.
+   */
+  configure?: (app: INestApplication) => void | Promise<void>;
+  /**
+   * Forwarded to `NestFactory.create`.
+   */
+  opts?: NestApplicationOptions;
+}
+export interface NodeServer {
+  port: number;
+  fetch: Fetcher;
+  close(): Promise<void>;
+}
+/**
+ * Boots a Nest app and serves it with `node:http`, including WebSocket upgrades.
+ */
+export declare function createNodeServer({ module, port, configure, opts }: CreateNodeServerOptions): Promise<NodeServer>;
+//#endregion

package/dist/index.mjs

@@ -0,0 +1,189 @@
+import { openAsBlob } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+import { FetchAdapter, WsGateway, createFetcher, gatewayPath } from "open-nest";
+import { WebSocketServer } from "ws";
+//#region src/index.ts
+const adapters = [];
+/**
+* Records Nest gateways during `init`. `node:http` performs the upgrade.
+*/
+var NodeWsAdapter = class extends WsGateway {
+	constructor() {
+		super();
+		adapters.push(this);
+	}
+	async dispose() {
+		const index = adapters.indexOf(this);
+		if (index !== -1) adapters.splice(index, 1);
+	}
+};
+/**
+* Fetch adapter plus static files via `node:fs`.
+*/
+var NodeAdapter = class extends FetchAdapter {
+	useStaticAssets(root, options) {
+		if (!root) return this;
+		const prefix = options?.prefix ?? "/";
+		const index = options?.index === void 0 ? "index.html" : options.index;
+		const rootResolved = resolve(root);
+		this.router.use(prefix, async (req, res, next) => {
+			if (req.method !== "GET" && req.method !== "HEAD") return next();
+			let relative;
+			try {
+				relative = decodeURIComponent(req.path);
+			} catch {
+				return next();
+			}
+			if (relative === "/") {
+				if (index === false) return next();
+				relative = index;
+			} else relative = relative.replace(/^\//, "");
+			const target = resolve(rootResolved, relative);
+			if (target !== rootResolved && !target.startsWith(rootResolved + sep)) return next();
+			let size;
+			try {
+				const info = await stat(target);
+				if (!info.isFile()) return next();
+				size = info.size;
+			} catch {
+				return next();
+			}
+			const type = contentType(target);
+			const blob = await openAsBlob(target);
+			res.setHeader("content-type", type);
+			res.setHeader("content-length", String(size));
+			if (req.method === "HEAD") {
+				res.end();
+				return;
+			}
+			const reader = blob.stream().getReader();
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				res.write(value);
+			}
+			res.end();
+		});
+		return this;
+	}
+};
+function contentType(file) {
+	switch (extname(file).toLowerCase()) {
+		case ".html": return "text/html; charset=utf-8";
+		case ".txt": return "text/plain; charset=utf-8";
+		case ".json": return "application/json";
+		case ".css": return "text/css; charset=utf-8";
+		case ".js": return "text/javascript; charset=utf-8";
+		case ".svg": return "image/svg+xml";
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".webp": return "image/webp";
+		case ".pdf": return "application/pdf";
+		case ".wasm": return "application/wasm";
+		default: return "application/octet-stream";
+	}
+}
+/**
+* Boots a Nest app and serves it with `node:http`, including WebSocket upgrades.
+*/
+async function createNodeServer({ module, port, configure, opts }) {
+	const fallback = new NodeWsAdapter();
+	const seen = new Set(adapters);
+	const fetcher = createFetcher({
+		module,
+		opts,
+		configure: async (app) => {
+			app.useWebSocketAdapter(fallback);
+			await configure?.(app);
+		}
+	}, new NodeAdapter());
+	await fetcher.app();
+	const active = [...adapters].reverse().find((adapter) => !seen.has(adapter) && adapter.hasGateways()) ?? fallback;
+	const sockets = new WebSocketServer({ noServer: true });
+	const server = createServer((req, res) => {
+		writeFetch(fetcher, req, res);
+	});
+	server.on("upgrade", (req, socket, head) => {
+		const pathname = gatewayPath(new URL(req.url ?? "/", "http://localhost").pathname);
+		if (!active.matches(pathname)) {
+			socket.destroy();
+			return;
+		}
+		sockets.handleUpgrade(req, socket, head, (ws) => {
+			const client = {
+				data: { path: pathname },
+				send(data) {
+					ws.send(data);
+				}
+			};
+			active.open(client);
+			ws.on("message", (data) => {
+				const raw = typeof data === "string" ? data : Array.isArray(data) ? Buffer.concat(data) : data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+				active.receive(client, raw);
+			});
+			ws.on("close", () => {
+				active.closed(client);
+			});
+		});
+	});
+	await new Promise((resolve) => {
+		server.listen(port ?? 3e3, "127.0.0.1", () => resolve());
+	});
+	const address = server.address();
+	return {
+		port: typeof address === "object" && address ? address.port : port ?? 3e3,
+		fetch: fetcher,
+		close: async () => {
+			for (const client of sockets.clients) client.terminate();
+			await new Promise((resolve, reject) => {
+				sockets.close((error) => error ? reject(error) : resolve());
+			});
+			server.closeAllConnections();
+			await new Promise((resolve, reject) => {
+				server.close((error) => error ? reject(error) : resolve());
+			});
+			await fetcher.close();
+		}
+	};
+}
+async function writeFetch(fetcher, req, res) {
+	try {
+		const response = await fetcher(toRequest(req));
+		const headers = Object.fromEntries(response.headers.entries());
+		res.writeHead(response.status, headers);
+		if (!response.body) {
+			res.end();
+			return;
+		}
+		await new Promise((resolve, reject) => {
+			Readable.fromWeb(response.body).pipe(res).on("finish", () => resolve()).on("error", reject);
+		});
+	} catch {
+		if (!res.headersSent) res.writeHead(500);
+		res.end();
+	}
+}
+function toRequest(req) {
+	const host = req.headers.host ?? "127.0.0.1";
+	const url = new URL(req.url ?? "/", `http://${host}`);
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (value == null) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else headers.set(name, value);
+	}
+	const method = req.method ?? "GET";
+	const bodyless = method === "GET" || method === "HEAD";
+	return new Request(url.href, {
+		method,
+		headers,
+		body: bodyless ? void 0 : Readable.toWeb(req),
+		duplex: "half"
+	});
+}
+//#endregion
+export { NodeAdapter, NodeWsAdapter, createNodeServer };

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@open-nest/node",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Run an open-nest application with node:http.",
+  "files": [
+    "package.json",
+    "readme.md",
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown --clean",
+    "dev": "tsdown --watch",
+    "typecheck": "bun check",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "open-nest": "0.1.0",
+    "ws": "8.22.0"
+  },
+  "devDependencies": {
+    "@nestjs/websockets": "12.1.3",
+    "@types/ws": "8.18.2"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/websockets": "^12.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/websockets": {
+      "optional": true
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,12 @@
+# `@open-nest/node`
+
+Serve an [`open-nest`](https://github.com/juriadams/open-nest) handler with `node:http`.
+
+```sh
+bun add @open-nest/node
+```
+
+`createNodeServer` starts an `http.Server`. `NodeWsAdapter` upgrades WebSocket gateways through `ws`. Static files use `node:fs`.
+
+- [HTTP](../../../examples/node)
+- [WebSockets](../../../examples/node-websockets)

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.