@torpor/build 0.0.5 → 0.1.0

package/dist/response.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/response/response.ts","../src/response/badRequest.ts","../src/response/created.ts","../src/response/forbidden.ts","../src/response/methodNotAllowed.ts","../src/response/transfer.ts","../src/response/moved.ts","../src/response/notFound.ts","../src/response/notModified.ts","../src/response/ok.ts","../src/response/redirect.ts","../src/response/seeOther.ts","../src/response/serverError.ts","../src/response/unauthorized.ts","../src/response/unprocessable.ts"],"sourcesContent":["/**\n * Creates a response with the supplied status code and optional body.\n *\n * If the body is an object, it will be converted to JSON and the content-type\n * header set to \"application/json\". Otherwise, if the body is a string, the\n * content-type header will be set to \"text/plain\".\n */\nexport default function response(status: number, body?: object | string) {\n\tlet headers: Record<string, string> | undefined = undefined;\n\tif (body) {\n\t\tif (typeof body === \"object\") {\n\t\t\theaders = { \"content-type\": \"application/json\" };\n\t\t\tbody = JSON.stringify(body);\n\t\t} else {\n\t\t\theaders = { \"content-type\": \"text/plain\" };\n\t\t}\n\t}\n\treturn new Response(body, {\n\t\tstatus,\n\t\theaders,\n\t});\n}\n","import response from \"./response\";\n\n/**\n * 400 Bad Request\n *\n * The server cannot or will not process the request due to something that is\n * perceived to be a client error (e.g., malformed request syntax, invalid\n * request message framing, or deceptive request routing).\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400\n */\nexport default function badRequest(body?: object | string): Response {\n\treturn response(400, body);\n}\n","import response from \"./response\";\n\n/**\n * 201 Created\n *\n * The request succeeded, and a new resource was created as a result. This is\n * typically the response sent after POST requests, or some PUT requests.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/201\n */\nexport default function created(body?: object | string): Response {\n\treturn response(201, body);\n}\n","import response from \"./response\";\n\n/**\n * 403 Forbidden\n *\n * The client does not have access rights to the content; that is, it is\n * unauthorized, so the server is refusing to give the requested resource.\n * Unlike 401 Unauthorized, the client's identity is known to the server.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403\n */\nexport default function forbidden(body?: object | string): Response {\n\treturn response(403, body);\n}\n","import response from \"./response\";\n\n/**\n * 405 Method Not Allowed\n *\n * The request method is known by the server but is not supported by the target\n * resource. For example, an API may not allow calling DELETE to remove a\n * resource.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405\n */\nexport default function methodNotAllowed(body?: object | string): Response {\n\treturn response(405, body);\n}\n","/**\n * Creates a redirect response with the supplied status code.\n */\nexport default function transfer(\n\tstatus: 300 | 301 | 302 | 303 | 304 | 307 | 308,\n\tlocation: string,\n): Response {\n\treturn new Response(null, {\n\t\tstatus,\n\t\theaders: {\n\t\t\tlocation,\n\t\t},\n\t});\n}\n","import transfer from \"./transfer\";\n\n/**\n * 308 Permanent Redirect\n *\n * This means that the resource is now permanently located at another URI,\n * specified by the Location: HTTP Response header. This has the same semantics\n * as the 301 Moved Permanently HTTP response code, with the exception that the\n * user agent must not change the HTTP method used: if a POST was used in the\n * first request, a POST must be used in the second request.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/308\n */\nexport default function moved(location: string): Response {\n\treturn transfer(308, location);\n}\n","import response from \"./response\";\n\n/**\n * 404 Not Found\n *\n * The server cannot find the requested resource. In the browser, this means the\n * URL is not recognized. In an API, this can also mean that the endpoint is\n * valid but the resource itself does not exist. Servers may also send this\n * response instead of 403 Forbidden to hide the existence of a resource from an\n * unauthorized client. This response code is probably the most well known due\n * to its frequent occurrence on the web.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404\n */\nexport default function notFound(body?: object | string): Response {\n\treturn response(404, body);\n}\n","import transfer from \"./transfer\";\n\n/**\n * 304 Not Modified\n *\n * This is used for caching purposes. It tells the client that the response has\n * not been modified, so the client can continue to use the same cached version\n * of the response.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/304\n */\nexport default function notModified(location: string): Response {\n\treturn transfer(304, location);\n}\n","import response from \"./response\";\n\n/**\n * 200 OK\n *\n * The request succeeded. The result meaning of \"success\" depends on the HTTP\n * method:\n * - GET: The resource has been fetched and transmitted in the message body.\n * - HEAD: The representation headers are included in the response without any\n *   message body.\n * - PUT or POST: The resource describing the result of the action is\n *   transmitted in the message body.\n * - TRACE: The message body contains the request message as received by the\n *   server.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/200\n */\nexport default function ok(body?: object | string): Response {\n\treturn response(200, body);\n}\n","import transfer from \"./transfer\";\n\n/**\n * 307 Temporary Redirect\n *\n * The server sends this response to direct the client to get the requested\n * resource at another URI with the same method that was used in the prior\n * request. This has the same semantics as the 302 Found HTTP response code,\n * with the exception that the user agent must not change the HTTP method used:\n * if a POST was used in the first request, a POST must be used in the second\n * request.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/307\n */\nexport default function redirect(location: string): Response {\n\treturn transfer(307, location);\n}\n","import transfer from \"./transfer\";\n\n/**\n * 303 See Other\n *\n * The server sent this response to direct the client to get the requested\n * resource at another URI with a GET request.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/303\n */\nexport default function seeOther(location: string): Response {\n\treturn transfer(303, location);\n}\n","import response from \"./response\";\n\n/**\n * 500 Server Error\n *\n * The server has encountered a situation it does not know how to handle.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500\n */\nexport default function serverError(body?: object | string): Response {\n\treturn response(500, body);\n}\n","import response from \"./response\";\n\n/**\n * 401 Unauthorized\n *\n * Although the HTTP standard specifies \"unauthorized\", semantically this\n * response means \"unauthenticated\". That is, the client must authenticate\n * itself to get the requested response.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401\n */\nexport default function unauthorized(body?: object | string): Response {\n\treturn response(401, body);\n}\n","import response from \"./response\";\n\n/**\n * 422 Unprocessable Content\n *\n * The request was well-formed but was unable to be followed due to semantic errors.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/422\n */\nexport default function unprocessable(body?: object | string): Response {\n\treturn response(422, body);\n}\n"],"mappings":";AAOe,SAAR,SAA0B,QAAgB,MAAwB;AACxE,MAAI,UAA8C;AAClD,MAAI,MAAM;AACT,QAAI,OAAO,SAAS,UAAU;AAC7B,gBAAU,EAAE,gBAAgB,mBAAmB;AAC/C,aAAO,KAAK,UAAU,IAAI;AAAA,IAC3B,OAAO;AACN,gBAAU,EAAE,gBAAgB,aAAa;AAAA,IAC1C;AAAA,EACD;AACA,SAAO,IAAI,SAAS,MAAM;AAAA,IACzB;AAAA,IACA;AAAA,EACD,CAAC;AACF;;;ACVe,SAAR,WAA4B,MAAkC;AACpE,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACHe,SAAR,QAAyB,MAAkC;AACjE,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACDe,SAAR,UAA2B,MAAkC;AACnE,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACFe,SAAR,iBAAkC,MAAkC;AAC1E,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACVe,SAAR,SACN,QACA,UACW;AACX,SAAO,IAAI,SAAS,MAAM;AAAA,IACzB;AAAA,IACA,SAAS;AAAA,MACR;AAAA,IACD;AAAA,EACD,CAAC;AACF;;;ACAe,SAAR,MAAuB,UAA4B;AACzD,SAAO,SAAS,KAAK,QAAQ;AAC9B;;;ACDe,SAAR,SAA0B,MAAkC;AAClE,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACLe,SAAR,YAA6B,UAA4B;AAC/D,SAAO,SAAS,KAAK,QAAQ;AAC9B;;;ACIe,SAAR,GAAoB,MAAkC;AAC5D,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACLe,SAAR,SAA0B,UAA4B;AAC5D,SAAO,SAAS,KAAK,QAAQ;AAC9B;;;ACNe,SAAR,SAA0B,UAA4B;AAC5D,SAAO,SAAS,KAAK,QAAQ;AAC9B;;;ACHe,SAAR,YAA6B,MAAkC;AACrE,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACAe,SAAR,aAA8B,MAAkC;AACtE,SAAO,SAAS,KAAK,IAAI;AAC1B;;;ACJe,SAAR,cAA+B,MAAkC;AACvE,SAAO,SAAS,KAAK,IAAI;AAC1B;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torpor/build",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "description": "A framework for building sites and apps with Torpor",
   "type": "module",
   "main": "dist/index.cjs",
@@ -21,6 +21,19 @@
       "types": "./dist/state.d.ts",
       "import": "./dist/state.js",
       "require": "./dist/state.cjs"
+    },
+    "./manifest": {
+      "types": "./src/types/manifest.d.ts"
+    },
+    "./adapters/node": {
+      "types": "./dist/adapters/node/index.d.ts",
+      "import": "./dist/adapters/node/index.js",
+      "require": "./dist/adapters/node/index.cjs"
+    },
+    "./adapters/cloudflare": {
+      "types": "./dist/adapters/cloudflare/index.d.ts",
+      "import": "./dist/adapters/cloudflare/index.js",
+      "require": "./dist/adapters/cloudflare/index.cjs"
     }
   },
   "publishConfig": {
@@ -33,20 +46,24 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "vinxi": "^0.5.3",
-    "@torpor/unplugin": "^0.0.5",
-    "@torpor/view": "^0.0.6"
+    "cookie": "^1.0.2",
+    "dotenv": "^16.4.7",
+    "vite": "^6.2.4",
+    "vite-tsconfig-paths": "^5.1.4",
+    "@torpor/view": "^0.0.7",
+    "@torpor/unplugin": "^0.0.6"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "lilconfig": "^3.1.3",
-    "tsup": "^8.3.6",
-    "typescript": "^5.7.3",
-    "vite": "^6.1.0"
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.1"
   },
   "scripts": {
     "build": "tsup",
     "build:watch": "tsup --watch",
-    "check": "tsc -p tsconfig.json --noEmit"
+    "check": "tsc --noEmit",
+    "test": "vitest"
   }
 }

package/src/adapters/cloudflare/_worker.ts

@@ -0,0 +1,38 @@
+// @ts-ignore
+import Server from "%SERVER_CLASS%";
+// @ts-ignore
+import { load } from "%SERVER_SCRIPT%";
+
+// This file has the above imports replaced and is then compiled to create a Cloudflare Pages Worker
+
+const template = `%HTML_TEMPLATE%`;
+
+// Send all requests through Server to handle middleware, cookies, headers, etc
+const server = new Server();
+server.add("*", async (ev: any) => {
+	try {
+		// Render the app HTML (or fetch server data etc) via serverEntry's
+		// exported `load` function
+		return await load(ev, template);
+	} catch (e: any) {
+		// TODO: Message?
+		console.log("ERROR:", e);
+		return new Response(null, {
+			status: 500,
+		});
+	}
+});
+
+export default {
+	async fetch(request: Request, env: any) {
+		const url = new URL(request.url);
+
+		// Serve dist/client/assets statically
+		if (url.pathname.startsWith("/assets/")) {
+			return env.ASSETS.fetch(request);
+		}
+
+		// Every request (GET, POST, etc) goes through loadEndPoint
+		return await server.fetch(request);
+	},
+};

package/src/adapters/cloudflare/index.ts

@@ -0,0 +1,98 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { build, defineConfig } from "vite";
+import Site from "../../site/Site";
+import prepareTemplate from "../../site/prepareTemplate";
+import type Adapter from "../../types/Adapter";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default {
+	postbuild,
+	serve: (/* server: Server, site: Site*/) => {
+		console.log("TODO");
+	},
+} satisfies Adapter;
+
+async function postbuild(site: Site) {
+	// Build _worker.js as per
+	// https://developers.cloudflare.com/pages/functions/advanced-mode/
+
+	const distFolder = path.resolve(site.root, "dist");
+	const clientFolder = path.join(distFolder, "client");
+	const serverFolder = path.join(distFolder, "server");
+	const tempFolder = path.join(distFolder, "temp");
+	const cloudflareFolder = path.join(distFolder, "cloudflare");
+
+	// Compile _worker.ts
+	let workerFile = path.resolve(__dirname, "../../../src/adapters/cloudflare/_worker.ts");
+	let workerSource = await fs.readFile(workerFile, "utf-8");
+
+	// Find the client script file in /assets
+	let clientScript = (await fs.readdir(path.join(clientFolder, "assets"))).find((f) =>
+		f.startsWith("clientEntry-"),
+	);
+	if (!clientScript) {
+		throw new Error("clientEntry.js not found");
+	}
+	clientScript = `/assets/${clientScript}`;
+
+	// Read and prepare site.html so that we can just splice components into it
+	let siteHtml = path.join(clientFolder, "site.html");
+	let template = await fs.readFile(siteHtml, "utf-8");
+	template = prepareTemplate(template, clientScript);
+
+	const serverClass = path.resolve(__dirname, "../../../src/server/Server.ts");
+	const serverScript = path.join(serverFolder, "serverEntry.js");
+
+	// Splice file names into _worker.ts
+	//let workerSource = await fs.readFile(workerFile, "utf-8");
+	workerSource = workerSource
+		.replace("%SERVER_CLASS%", serverClass)
+		.replace("%SERVER_SCRIPT%", serverScript)
+		.replace("%HTML_TEMPLATE%", template);
+
+	workerFile = path.join(tempFolder, "_worker.ts");
+	await fs.mkdir(tempFolder);
+	await fs.writeFile(workerFile, workerSource);
+
+	await build(
+		defineConfig({
+			build: {
+				outDir: cloudflareFolder,
+				rollupOptions: {
+					input: [workerFile],
+					output: {
+						entryFileNames: `[name].js`,
+						chunkFileNames: `[name].js`,
+						assetFileNames: `[name].[ext]`,
+					},
+					preserveEntrySignatures: "strict",
+				},
+				// HACK: We don't need to minify as the worker isn't downloaded?
+				// And it makes debugging easier
+				minify: false,
+				// HACK: Disable preload so that the _worker.js file doesn't end
+				// up with document and window references that are not available
+				modulePreload: false,
+			},
+		}),
+	);
+	workerFile = path.join(distFolder, "cloudflare", "_worker.js");
+
+	// Build a wrangler.json file for running with `wrangler dev`
+	const wranglerConfig = {
+		name: "torpor-miniflare",
+		main: "cloudflare/_worker.js",
+		compatibility_date: "2025-01-01",
+		assets: {
+			directory: "./client",
+			binding: "ASSETS",
+		},
+	};
+	const wranglerFile = path.join(distFolder, "wrangler.json");
+	await fs.writeFile(wranglerFile, JSON.stringify(wranglerConfig, null, 2).replaceAll("  ", "\t"));
+
+	await fs.rm(tempFolder, { recursive: true });
+}

package/src/adapters/node/constants.ts

@@ -0,0 +1 @@
+export const INTERNAL_BODY = Symbol("internal_body");

package/src/adapters/node/createFetchHandler.ts

@@ -0,0 +1,29 @@
+import { type IncomingMessage, ServerResponse } from "node:http";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
+import { INTERNAL_BODY } from "./constants";
+import nodeMessageToRequest from "./nodeMessageToRequest";
+import responseToNodeResponse from "./responseToNodeResponse";
+
+// From https://gist.github.com/marvinhagemeister/cc236ec97235ce0305ae9d48a24a607d
+// Referenced from https://marvinh.dev/blog/modern-way-to-write-javascript-servers/
+
+const GlobalResponse = Response;
+globalThis.Response = class Response extends GlobalResponse {
+	[INTERNAL_BODY]: BodyInit | null | undefined = null;
+
+	constructor(body?: BodyInit | null, init?: ResponseInit) {
+		super(body, init);
+		this[INTERNAL_BODY] = body;
+	}
+};
+
+export function createFetchHandler(handler: (req: Request) => Response | Promise<Response>) {
+	return async (
+		incoming: IncomingMessage | Http2ServerRequest,
+		outgoing: ServerResponse | Http2ServerResponse,
+	) => {
+		const req = await nodeMessageToRequest(incoming);
+		const res = await handler(req);
+		return await responseToNodeResponse(res, outgoing);
+	};
+}

package/src/adapters/node/createMiddlewareHandler.ts

@@ -0,0 +1,79 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import type MiddlewareFunction from "../../types/MiddlewareFunction";
+import flattenHeaders from "./flattenHeaders";
+import nodeMessageToNodeResponse from "./nodeMessageToNodeResponse";
+import readableToBuffer from "./readableToBuffer";
+import requestToNodeMessage from "./requestToNodeMessage";
+
+// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/connectToWeb.ts
+
+/**
+ * Converts a Connect-style middleware to a web-compatible request handler.
+ *
+ * @param handler - The Connect-style middleware function to be converted.
+ * @returns A function that handles web requests and returns a Response or undefined.
+ */
+export default function createMiddlewareHandler(
+	handler: ConnectMiddleware | ConnectMiddlewareBoolean,
+): MiddlewareFunction {
+	return async (ev, next) => {
+		const req = requestToNodeMessage(ev.request);
+		const { res, onReadable } = nodeMessageToNodeResponse(req);
+
+		return new Promise<void>(async (resolve, reject) => {
+			onReadable(async ({ readable, headers, status }) => {
+				const responseBody = statusCodesWithoutBody.includes(status)
+					? null
+					: //(Readable.toWeb(readable) as ReadableStream);
+						// HACK: Chunked bodies are not being
+						// read correctly somewhere...
+						await readableToBuffer(readable);
+				ev.response = new Response(responseBody, {
+					status,
+					headers: flattenHeaders(headers),
+				});
+				resolve();
+			});
+
+			const cnext = async (error?: unknown) => {
+				if (error) {
+					reject(error instanceof Error ? error : new Error(String(error)));
+				} else {
+					// TODO: Can we nest the next functions less? This is a bit weird
+					await next();
+					resolve();
+				}
+			};
+
+			try {
+				const handled = await handler(req, res, cnext);
+				if (handled === false) {
+					res.destroy();
+					resolve();
+				}
+			} catch (e) {
+				cnext(e);
+			}
+		});
+	};
+}
+
+const statusCodesWithoutBody = [
+	100, // Continue
+	101, // Switching Protocols
+	102, // Processing (WebDAV)
+	103, // Early Hints
+	204, // No Content
+	205, // Reset Content
+	304, // Not Modified
+];
+
+type NextFunction = (err?: unknown) => void;
+type ConnectMiddleware<
+	PlatformRequest extends IncomingMessage = IncomingMessage,
+	PlatformResponse extends ServerResponse = ServerResponse,
+> = (req: PlatformRequest, res: PlatformResponse, next: NextFunction) => void | Promise<void>;
+type ConnectMiddlewareBoolean<
+	PlatformRequest extends IncomingMessage = IncomingMessage,
+	PlatformResponse extends ServerResponse = ServerResponse,
+> = (req: PlatformRequest, res: PlatformResponse, next: NextFunction) => boolean | Promise<boolean>;

package/src/adapters/node/createNodeServer.ts

@@ -0,0 +1,8 @@
+import { createServer } from "node:http";
+import { createFetchHandler } from "./createFetchHandler";
+
+export default function createNodeServer(handler: (req: Request) => Response | Promise<Response>) {
+	// Create a server, polyfill it so that it can handle standard fetch methods,
+	// and pass our app fetch method to the handler
+	return createServer(createFetchHandler(handler));
+}

package/src/adapters/node/flattenHeaders.ts

@@ -0,0 +1,44 @@
+import { IncomingHttpHeaders } from "node:http";
+import { OutgoingHttpHeaders } from "node:http2";
+
+export default function flattenHeaders(
+	headers: IncomingHttpHeaders | OutgoingHttpHeaders,
+): HeadersInit {
+	const flatHeaders = new Headers();
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === undefined || value === null) {
+			continue;
+		} else if (Array.isArray(value)) {
+			for (const v of value) {
+				if (v !== undefined && v !== null) {
+					value.forEach((v) => flatHeaders.append(key, v));
+				}
+			}
+		} else {
+			flatHeaders.set(key, String(value));
+		}
+	}
+	return flatHeaders;
+
+	/*
+            const flatHeaders: [string, string][] = [];
+
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === undefined || value === null) {
+			continue;
+		}
+
+		if (Array.isArray(value)) {
+			for (const v of value) {
+				if (v != null) {
+					flatHeaders.push([key, String(v)]);
+				}
+			}
+		} else {
+			flatHeaders.push([key, String(value)]);
+		}
+	}
+
+	return flatHeaders;
+    */
+}

package/src/adapters/node/index.ts

@@ -0,0 +1,18 @@
+import Server from "../../server/Server";
+import type Adapter from "../../types/Adapter";
+import createNodeServer from "./createNodeServer";
+
+export default {
+	serve: (server: Server) => {
+		process.env.PROTOCOL ??= "http:";
+		process.env.HOST ??= "localhost";
+		process.env.PORT ??= "7059";
+
+		// Create the Node server and start listening
+		console.log(`\nConnecting to ${process.env.HOST}:${process.env.PORT}`);
+		const devServer = createNodeServer(server.fetch);
+		devServer.listen(parseInt(process.env.PORT), process.env.HOST, () => {
+			console.log(`Listening on ${process.env.HOST}:${process.env.PORT}\n`);
+		});
+	},
+} satisfies Adapter;

package/src/adapters/node/nodeMessageToNodeResponse.ts

@@ -0,0 +1,89 @@
+import {
+	type IncomingMessage,
+	type OutgoingHttpHeader,
+	type OutgoingHttpHeaders,
+	ServerResponse,
+} from "node:http";
+import { PassThrough, Readable } from "node:stream";
+
+// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/createServerResponse.ts
+
+/**
+ * Creates a custom ServerResponse object that allows for intercepting and
+ * streaming the response.
+ *
+ * @param incomingMessage The incoming HTTP request message.
+ * @returns An object containing the custom ServerResponse and a function that
+ * takes a callback to invoke when the response is readable, providing an object
+ * with the readable stream, headers and status code.
+ */
+export default function nodeMessageToNodeResponse(
+	incomingMessage: IncomingMessage,
+): ServerResponseResponse {
+	const res = new ServerResponse(incomingMessage);
+	const passThrough = new PassThrough();
+	let handled = false;
+
+	const onReadable = (
+		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
+	) => {
+		const handleReadable = () => {
+			if (handled) return;
+			handled = true;
+			cb({
+				readable: Readable.from(passThrough),
+				headers: res.getHeaders(),
+				status: res.statusCode,
+			});
+		};
+
+		passThrough.once("readable", handleReadable);
+		passThrough.once("end", handleReadable);
+	};
+
+	passThrough.once("finish", () => {
+		res.emit("finish");
+	});
+	passThrough.once("close", () => {
+		res.destroy();
+		res.emit("close");
+	});
+	passThrough.on("drain", () => {
+		res.emit("drain");
+	});
+
+	res.write = passThrough.write.bind(passThrough);
+	res.end = passThrough.end.bind(passThrough) as any;
+
+	res.writeHead = function writeHead(
+		statusCode: number,
+		statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeader[],
+		headers?: OutgoingHttpHeaders | OutgoingHttpHeader[],
+	): ServerResponse {
+		res.statusCode = statusCode;
+		if (typeof statusMessage === "object") {
+			headers = statusMessage;
+			statusMessage = undefined;
+		}
+		if (headers) {
+			for (const [key, value] of Object.entries(headers)) {
+				if (value !== undefined) {
+					res.setHeader(key, value);
+				}
+			}
+		}
+		return res;
+	};
+
+	return {
+		res,
+		onReadable,
+	};
+}
+
+type ServerResponseResponse = {
+	res: ServerResponse;
+	onReadable: (
+		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
+	) => void;
+};

package/src/adapters/node/nodeMessageToRequest.ts

@@ -0,0 +1,43 @@
+import { type IncomingMessage } from "node:http";
+import { Http2ServerRequest } from "node:http2";
+import { Readable } from "node:stream";
+import flattenHeaders from "./flattenHeaders";
+
+// From https://stackoverflow.com/a/78849544
+// and https://gist.github.com/marvinhagemeister/cc236ec97235ce0305ae9d48a24a607d
+
+export default async function nodeMessageToRequest(
+	req: IncomingMessage | Http2ServerRequest,
+): Promise<Request> {
+	// Build the full url
+	let path = req.url;
+	if (path === undefined) {
+		throw new Error(`Empty request URL`);
+	}
+	if (!path.startsWith("/")) {
+		path = "/" + path;
+	}
+	const { host } = req.headers;
+	if (host == undefined) {
+		throw new Error(`Missing "Host" header`);
+	}
+	const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https" : "http";
+	const url = `${protocol}://${host}${path}`;
+
+	// Flatten the headers
+	const headers = flattenHeaders(req.headers);
+
+	// Convert body to Buffer if applicable
+	const body =
+		req.method !== "GET" && req.method !== "HEAD"
+			? (Readable.toWeb(req) as ReadableStream) // await readableToBuffer(req)
+			: null;
+
+	return new Request(url, {
+		method: req.method,
+		headers: headers,
+		body: body,
+		// @ts-ignore this is needed for using a Readable for some reason
+		duplex: "half",
+	});
+}

package/src/adapters/node/readableToBuffer.ts

@@ -0,0 +1,16 @@
+import { Readable } from "node:stream";
+
+export default function readableToBuffer(req: Readable): Promise<Buffer> {
+	return new Promise<Buffer>((resolve, reject) => {
+		const chunks: Buffer[] = [];
+		req.on("data", (chunk: Buffer) => {
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			resolve(Buffer.concat(chunks));
+		});
+		req.on("error", (err) => {
+			reject(err);
+		});
+	});
+}

package/src/adapters/node/requestToNodeMessage.ts

@@ -0,0 +1,26 @@
+import { type IncomingMessage } from "node:http";
+import { Readable } from "node:stream";
+
+// From https://github.com/vikejs/vike-node/blob/main/packages/vike-node/src/runtime/adapters/connectToWeb.ts
+
+const DUMMY_BASE_URL = "http://localhost";
+
+/**
+ * Creates an IncomingMessage object from a web Request.
+ *
+ * @param {Request} request - The web Request object.
+ * @returns {IncomingMessage} An IncomingMessage-like object compatible with Node.js HTTP module.
+ */
+export default function requestToNodeMessage(request: Request): IncomingMessage {
+	const parsedUrl = new URL(request.url, DUMMY_BASE_URL);
+	const pathAndQuery = (parsedUrl.pathname || "") + (parsedUrl.search || "");
+	// HACK: Using Readable.fromWeb locks request.body so that the request cannot be used again
+	// As we're only using this for Vite middlewares, it's safe to discard the body for now?
+	const body = /*request.body ? Readable.fromWeb(request.body as any) :*/ Readable.from([]);
+
+	return Object.assign(body, {
+		url: pathAndQuery,
+		method: request.method,
+		headers: Object.fromEntries(request.headers),
+	}) as IncomingMessage;
+}

package/src/adapters/node/responseToNodeResponse.ts

@@ -0,0 +1,44 @@
+import { ServerResponse } from "node:http";
+import { Http2ServerResponse } from "node:http2";
+import { isArrayBufferView } from "node:util/types";
+import { INTERNAL_BODY } from "./constants";
+
+export default async function responseToNodeResponse(
+	res: Response,
+	outgoing: ServerResponse | Http2ServerResponse,
+) {
+	outgoing.statusCode = res.status;
+	outgoing.statusMessage = res.statusText;
+
+	res.headers.forEach((value, key) => {
+		outgoing.setHeader(key, value);
+	});
+
+	const body = (res as any)[INTERNAL_BODY];
+
+	if (body === null || body === undefined) {
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end();
+	} else if (typeof body === "string" || body instanceof Uint8Array) {
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end(body);
+	} else if (body instanceof Blob) {
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end(new Uint8Array(await body.arrayBuffer()));
+	} else if (body instanceof ArrayBuffer) {
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end(new Uint8Array(body));
+	} else if (isArrayBufferView(body)) {
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end(new Uint8Array(body.buffer));
+	} else if (body instanceof FormData) {
+		// TODO
+		outgoing.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
+
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end();
+	} else {
+		outgoing.writeHead(res.status, res.statusText);
+		outgoing.end();
+	}
+}