@torpor/build 0.4.10 → 0.4.12

package/src/run/runPreview.ts

@@ -0,0 +1,93 @@
+import { configDotenv } from "dotenv";
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+import { serverError } from "../response.ts";
+import Server from "../server/Server.ts";
+import contentType from "../server/contentType.ts";
+import Site from "../site/Site";
+import prepareTemplate from "./prepareTemplate.ts";
+import runBuild from "./runBuild";
+
+export default async function runPreview(site: Site): Promise<void> {
+	// Build the site
+	await runBuild(site);
+
+	const distFolder = path.resolve(site.root, "dist");
+	const clientFolder = path.join(distFolder, "client");
+	const serverFolder = path.join(distFolder, "server");
+
+	// 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 site.html
+	// It's called site.html because @torpor/build builds the site (html, routes
+	// etc) while the user builds the app (components etc)
+	let siteHtml = path.join(clientFolder, "site.html");
+	let template = await fs.readFile(siteHtml, "utf-8");
+
+	// Prepare site.html so that we can just splice components into it
+	template = prepareTemplate(template, clientScript);
+
+	// Configure the server
+	const server = new Server();
+
+	// Serve dist/client/assets statically
+	server.add("/assets/*", async (ev) => {
+		try {
+			const url = new URL(ev.request.url);
+			const file = path.join(site.root, "dist", "client", url.pathname);
+			if (existsSync(file)) {
+				// TODO: Stream the data?
+				const body = bufferToArrayBuffer(await fs.readFile(file));
+				return new Response(body, {
+					status: 200,
+					headers: {
+						"Content-Type": contentType(path.extname(file)),
+					},
+				});
+			}
+		} catch (e: any) {
+			return serverError(e);
+		}
+	});
+
+	// Every request (GET, POST, etc) goes through loadEndPoint
+	const serverScript = path.resolve(serverFolder, "serverEntry.js");
+	server.add("*", async (ev) => {
+		try {
+			// Load the server entry
+			const { load } = await import(serverScript);
+
+			// Render the app HTML (or fetch server data etc) via serverEntry's
+			// exported `load` function
+			return await load(ev, template);
+		} catch (e: any) {
+			return serverError(e);
+		}
+	});
+
+	// Load environment variables from a `.env` file, with defaults if not set
+	configDotenv();
+
+	process.env.PROTOCOL ??= "http:";
+	process.env.HOST ??= "localhost";
+	process.env.PORT ??= "7059";
+
+	// Serve the site
+	site.adapter.serve(server, site);
+}
+
+// From https://stackoverflow.com/a/79345620
+// No idea why it is needed
+function bufferToArrayBuffer(buffer: Buffer): ArrayBuffer {
+	return buffer.buffer.slice(
+		buffer.byteOffset,
+		buffer.byteOffset + buffer.byteLength,
+	) as ArrayBuffer;
+}

package/src/run.ts

@@ -0,0 +1,6 @@
+import run from "./run/run";
+import runBuild from "./run/runBuild";
+import runDev from "./run/runDev";
+import runPreview from "./run/runPreview";
+
+export { run, runDev, runBuild, runPreview };

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 value from the map
+		if (this.cookies.has(name)) {
+			return parse(this.cookies.get(name)!)[name];
+		}
+		// Otherwise, return the value from the `cookie` header
+		const header = this.request.headers.get("cookie");
+		return parse(header ?? "")[name];
+	}
+
+	set(name: string, value: string, options?: SerializeOptions): void {
+		// 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): void {
+		// Set a cookie header with an immediate expiry date
+		options ??= {};
+		options.expires = new Date(0);
+		this.cookies.set(name, serialize(name, "", options));
+	}
+}

package/src/server/HeaderHelper.ts

@@ -0,0 +1,25 @@
+export default class HeaderHelper {
+	request: Request;
+	headers: 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.headers.has(name)) {
+			return this.headers.get(name);
+		}
+		// Otherwise, return the value from the header
+		return this.request.headers.get(name) ?? undefined;
+	}
+
+	set(name: string, value: string): void {
+		this.headers.set(name, value);
+	}
+
+	delete(name: string): void {
+		this.headers.delete(name);
+	}
+}

package/src/server/Routerx.ts

@@ -0,0 +1,72 @@
+import pathToRegex from "../utils/pathToRegex";
+import type HttpMethod from "./types/HttpMethod";
+import type MiddlewareFunction from "./types/MiddlewareFunction";
+import type ServerFunction from "./types/ServerFunction";
+
+// This is not actually used anywhere, for now at least
+
+export default class Router {
+	methods: Map<HttpMethod, RouteHandler[]> = new Map<HttpMethod, RouteHandler[]>();
+	middleware: MiddlewareHandler[] = [];
+
+	constructor() {
+		// Create all method handlers up front so we don't have to worry about
+		// checking if they exist. Using a non-standard method will just error
+		this.methods.set("GET", []);
+		this.methods.set("HEAD", []);
+		this.methods.set("PATCH", []);
+		this.methods.set("POST", []);
+		this.methods.set("PUT", []);
+		this.methods.set("DELETE", []);
+		this.methods.set("OPTIONS", []);
+		this.methods.set("CONNECT", []);
+		this.methods.set("TRACE", []);
+	}
+
+	add(method: HttpMethod, path: string, fn: ServerFunction): Router {
+		this.methods.get(method)!.push(new RouteHandler(path, fn));
+		return this;
+	}
+
+	match(method: HttpMethod, path: string): Match | undefined {
+		for (let handler of this.methods.get(method)!) {
+			let match = path.match(handler.regex);
+			if (match) {
+				console.log("found", handler);
+				return {
+					fn: handler.fn,
+					params: match.groups,
+				};
+			}
+		}
+	}
+}
+
+class RouteHandler {
+	path: string;
+	regex: RegExp;
+	fn: ServerFunction;
+
+	constructor(path: string, fn: ServerFunction) {
+		this.path = path;
+		this.regex = pathToRegex(path);
+		this.fn = fn;
+	}
+}
+
+class MiddlewareHandler {
+	path: string;
+	regex: RegExp;
+	fn: MiddlewareFunction;
+
+	constructor(path: string, fn: MiddlewareFunction) {
+		this.path = path;
+		this.regex = pathToRegex(path);
+		this.fn = fn;
+	}
+}
+
+interface Match {
+	fn: ServerFunction;
+	params?: Record<string, string>;
+}

package/src/server/Server.ts

@@ -0,0 +1,144 @@
+import pathToRegex from "../utils/pathToRegex";
+import ServerEvent from "./ServerEvent";
+import type MiddlewareFunction from "./types/MiddlewareFunction";
+import type ServerFunction from "./types/ServerFunction";
+
+const noop = () => {};
+
+/**
+ * A Fetch API Request/Response server.
+ */
+export default class Server {
+	// TODO: We don't use any of the routes, just add("*") in runDev/runBuild...
+	routes: RouteHandler[] = [];
+	// TODO: We only use the Vite middleware here
+	middleware: MiddlewareFunction[] = [];
+
+	constructor() {
+		this.routes = [];
+		this.middleware = [];
+	}
+
+	/**
+	 * The standard Fetch API method that should work in any runtime (including
+	 * Node with polyfills).
+	 * @returns
+	 */
+	fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+		const request = new Request(input, init);
+		const url = new URL(request.url);
+		const match = this.match(url.pathname);
+		let ev = new ServerEvent(request, match?.params);
+
+		if (this.middleware.length) {
+			// TODO: Get middleware that applies to this route only?
+			await this.middleware[0](ev, buildNext(this.middleware, 0));
+			function buildNext(middleware: MiddlewareFunction[], i: number): () => void | Promise<void> {
+				if (ev.response) {
+					return noop;
+				}
+
+				if (i < middleware.length - 1) {
+					let next = middleware[i + 1];
+					return async () => next(ev, buildNext(middleware, i + 1));
+				} else {
+					return match
+						? async () => {
+								ev.response = await match.fn(ev);
+							}
+						: noop;
+				}
+			}
+		} else if (match) {
+			ev.response = await match.fn(ev);
+		} else {
+			return new Response(null, { status: 404 });
+		}
+
+		// TODO: Should I be returning 200 if there's no response? Because it's not an error??
+		ev.response ??= new Response(null, { status: 200 });
+		ev.addHeaders();
+
+		return ev.response;
+	};
+
+	/**
+	 * Adds a server function at a route path.
+	 * @param path The route path pattern.
+	 * @param fn The function to call when the pattern is matched.
+	 * @returns
+	 */
+	add(path: string, fn: ServerFunction): Server {
+		this.routes.push(new RouteHandler(path, fn));
+		this.#sortRoutes();
+		return this;
+	}
+
+	match(path: string): Match | undefined {
+		for (let handler of this.routes) {
+			let match = path.match(handler.regex);
+			if (match) {
+				return {
+					fn: handler.fn,
+					params: match.groups,
+				};
+			}
+		}
+		console.log(`Server path not found: ${path}`);
+	}
+
+	// TODO:
+	//use(path: string, ...fn: MiddlewareFunction[])
+	use(...fn: MiddlewareFunction[]): Server {
+		this.middleware = this.middleware.concat(fn);
+		return this;
+	}
+
+	#sortRoutes() {
+		this.routes = this.routes.sort((a, b) => {
+			// Sort [param]s after paths
+			// There might be a quicker/easier way to do this
+			for (let i = 0; i < Math.min(a.path.length, b.path.length); i++) {
+				if (a.path[i] === "[" && b.path[i] !== "[") {
+					return 1;
+				} else if (b.path[i] === "[" && a.path[i] !== "[") {
+					return -1;
+				} else if (a.path[i] === b.path[i]) {
+					// Keep going...
+				} else {
+					return a.path[i].localeCompare(b.path[i]);
+				}
+			}
+			return a.path.length - b.path.length;
+		});
+	}
+}
+
+class RouteHandler {
+	path: string;
+	regex: RegExp;
+	fn: ServerFunction;
+
+	constructor(path: string, fn: ServerFunction) {
+		this.path = path;
+		this.regex = pathToRegex(path);
+		this.fn = fn;
+	}
+}
+
+//class MiddlewareHandler {
+//	path: string;
+//	regex: RegExp;
+//	fn: MiddlewareFunction;
+//
+//	constructor(path: string, fn: MiddlewareFunction) {
+//		this.path = path;
+//		this.regex = pathToRegex(path);
+//		this.fn = fn;
+//	}
+//}
+
+interface Match {
+	fn: ServerFunction;
+	params?: Record<string, string>;
+}

package/src/server/ServerEvent.ts

@@ -0,0 +1,39 @@
+import CookieHelper from "./CookieHelper";
+import HeaderHelper from "./HeaderHelper";
+
+export default class ServerEvent {
+	request: Request;
+	response: Response | undefined | void;
+	// TODO: Should we cast types??
+	params?: Record<string, string>;
+
+	adapter: any;
+
+	cookies: CookieHelper;
+	headers: HeaderHelper;
+
+	constructor(request: Request, params?: Record<string, string>) {
+		this.request = request;
+		this.params = params;
+		this.cookies = new CookieHelper(request);
+		this.headers = new HeaderHelper(request);
+
+		// Adapters may have added the `adapter` property to globalThis
+		// @ts-ignore
+		this.adapter = globalThis.adapter;
+	}
+
+	addHeaders(): void {
+		if (!this.response) {
+			throw new Error("Response not created yet");
+		}
+
+		for (let cookie of this.cookies.cookies.values()) {
+			this.response.headers.append("set-cookie", cookie);
+		}
+
+		for (let header of this.headers.headers.entries()) {
+			this.response.headers.append(header[0], header[1]);
+		}
+	}
+}

package/src/server/connect/bufferToArrayBuffer.ts

@@ -0,0 +1,8 @@
+// From https://stackoverflow.com/a/79345620
+// No idea why it is needed
+export default function bufferToArrayBuffer(buffer: Buffer): ArrayBuffer {
+	return buffer.buffer.slice(
+		buffer.byteOffset,
+		buffer.byteOffset + buffer.byteLength,
+	) as ArrayBuffer;
+}

package/src/server/connect/connectMiddleware.ts

@@ -0,0 +1,81 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import type MiddlewareFunction from "../types/MiddlewareFunction";
+import bufferToArrayBuffer from "./bufferToArrayBuffer";
+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 connectMiddleware(
+	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...
+						bufferToArrayBuffer(await readableToBuffer(readable));
+				ev.response = new Response(responseBody, {
+					status,
+					headers: flattenHeaders(headers),
+				});
+				resolve();
+			});
+
+			const cnext = async (error?: unknown) => {
+				if (error) {
+					// eslint-disable-next-line no-base-to-string
+					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) {
+				await 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/server/connect/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/server/connect/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,
+	};
+}
+
+interface ServerResponseResponse {
+	res: ServerResponse;
+	onReadable: (
+		cb: (result: { readable: Readable; headers: OutgoingHttpHeaders; status: number }) => void,
+	) => void;
+}

package/src/server/connect/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/server/connect/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;
+}