@torpor/build 0.0.6 → 0.1.1

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();
+	}
+}

package/src/bin/index.ts

@@ -1,42 +1,49 @@
 #! /usr/bin/env node
-//import { existsSync, promises as fs } from "node:fs";
 import fs from "node:fs";
-import path from "path";
-import defineConfig from "../site/defineConfig";
-import type UserConfig from "../types/UserConfig";
+import path from "node:path";
+import { transformWithEsbuild } from "vite";
+import Site from "../site/Site";
+import runBuild from "../site/runBuild";
+import runDev from "../site/runDev";
 
-// Check for a torpor.config.js/ts file in the working directory
-// TODO: Make sure it's valid, try/catch, etc
-// TODO: There has GOT to be an easier way
-let options: UserConfig | undefined;
-const workingDir = process.cwd();
-const jsConfigFile = path.join(workingDir, "torpor.config.js");
-const tsConfigFile = path.join(workingDir, "torpor.config.ts");
-let source: string | undefined;
-if (fs.existsSync(jsConfigFile)) {
-	//const configFile = path.relative(".", tsConfigFile);
-	//options = await import(configFile);
-	source = fs.readFileSync(jsConfigFile, "utf8");
-	source = source
-		.replace(
-			/import\s+\{\s+defineConfig\s+\}\s+from\s+["']@torpor\/build["']/,
-			"const defineConfig = (x) => x",
-		)
-		.replace("export default", "");
-} else if (fs.existsSync(tsConfigFile)) {
-	console.log("TS config file is not supported");
-}
+run();
 
-if (source) {
-	options = eval(source);
-}
+async function run() {
+	// Look for and load a site.config.js/ts file in the working directory
+	const workingDir = process.cwd();
+	let configFile = "";
+	let deleteConfigFile = false;
+	const jsConfigFile = path.join(workingDir, "site.config.js");
+	const tsConfigFile = path.join(workingDir, "site.config.ts");
+	if (fs.existsSync(jsConfigFile)) {
+		// If it's JS, we can just import it straight up
+		configFile = jsConfigFile;
+	} else if (fs.existsSync(tsConfigFile)) {
+		// If it's TS, we need to convert it to JS
+		// TODO: Put the generated file somewhere better (dist?)
+		configFile = path.join(workingDir, "site.config.temp.js");
+		let source = (
+			await transformWithEsbuild(fs.readFileSync(tsConfigFile, "utf-8"), tsConfigFile, {
+				loader: "ts",
+			})
+		).code;
+		fs.writeFileSync(configFile, source);
+		deleteConfigFile = true;
+	} else {
+		throw new Error("site.config file not found");
+	}
 
-defineConfig(options);
+	const site = (await import(configFile)).default as Site;
+	if (!site || !site.root || !site.routes) {
+		throw new Error("Invalid site in config file");
+	}
+	if (deleteConfigFile) {
+		fs.rmSync(configFile);
+	}
 
-// This already gets done in vinxi.createApp so we can't do it twice
-//const app = defineConfig(options);
-//if (process.argv.includes("--dev")) {
-//	await app.dev();
-//} else if (process.argv.includes("--build")) {
-//	await app.build();
-//}
+	if (process.argv.includes("--dev")) {
+		await runDev(site);
+	} else if (process.argv.includes("--build")) {
+		await runBuild(site);
+	}
+}

package/src/index.ts

@@ -1,24 +1,17 @@
-import buildRoutePath from "./site/buildRoutePath";
-import defineConfig from "./site/defineConfig";
-import type CookieHelper from "./types/CookieHelper";
+import Site from "./site/Site";
 import type PageEndPoint from "./types/PageEndPoint";
-import type PageEvent from "./types/PageEvent";
+import type PageLoadEvent from "./types/PageLoadEvent";
 import type PageServerAction from "./types/PageServerAction";
 import type PageServerEndPoint from "./types/PageServerEndPoint";
 import type PageServerLoad from "./types/PageServerLoad";
 import type ServerEndPoint from "./types/ServerEndPoint";
-import type ServerEvent from "./types/ServerEvent";
 import type ServerHook from "./types/ServerHook";
+import type ServerLoadEvent from "./types/ServerLoadEvent";
 import type ServerRequest from "./types/ServerRequest";
-import type UserConfig from "./types/UserConfig";
 
-// NOTE: Do not export anything that relies on vinxi/vite from here, or it will
-// cause problems when they are re-imported when routes are lazily loaded
-
-export { defineConfig, buildRoutePath };
+export { Site };
 
 export type {
-	UserConfig,
 	PageEndPoint,
 	PageServerEndPoint,
 	PageServerLoad,
@@ -26,7 +19,6 @@ export type {
 	ServerEndPoint,
 	ServerRequest,
 	ServerHook,
-	PageEvent,
-	ServerEvent,
-	CookieHelper,
+	PageLoadEvent,
+	ServerLoadEvent,
 };

package/src/server/CookieHelper.ts

@@ -0,0 +1,36 @@
+import { SerializeOptions, parse, serialize } from "cookie";
+
+export default class CookieHelper {
+	request: Request;
+	cookies: Map<string, string> = new Map();
+
+	constructor(request: Request) {
+		this.request = request;
+	}
+
+	get(name: string): string | undefined {
+		// If it's been set, return the updated value
+		if (this.cookies.has(name)) {
+			return this.cookies.get(name);
+		}
+		// Otherwise, return the cookie value from the `Cookie` header
+		const header = this.request.headers.get("cookie");
+		return parse(header ?? "")[name];
+	}
+
+	set(name: string, value: string, options?: SerializeOptions) {
+		// Set a cookie header with some default values for security
+		options ??= {};
+		options.httpOnly ??= true;
+		options.secure ??= true;
+		options.sameSite ??= "lax";
+		this.cookies.set(name, serialize(name, value, options));
+	}
+
+	delete(name: string, options?: SerializeOptions) {
+		// Set a cookie header with an immediate expiry date
+		options ??= {};
+		options.expires = new Date(0);
+		this.cookies.set(name, serialize(name, "", options));
+	}
+}