@torpor/build 0.4.14 → 1.0.0

package/src/server/ServerEvent.ts

@@ -4,6 +4,12 @@ import HeaderHelper from "./HeaderHelper";
 export default class ServerEvent {
 	request: Request;
 	response: Response | undefined | void;
+	/**
+	 * Set when the route handler (or a middleware enter hook) threw an
+	 * error. Exit hooks can return a Response to handle it; if none does,
+	 * the error is rethrown to the caller.
+	 */
+	error: unknown;
 	// TODO: Should we cast types??
 	params?: Record<string, string>;
 
@@ -12,9 +18,19 @@ export default class ServerEvent {
 	cookies: CookieHelper;
 	headers: HeaderHelper;
 
-	constructor(request: Request, params?: Record<string, string>) {
+	// Parsed once per request; Server.fetch passes the URL it already needed
+	// for matching so it isn't parsed twice
+	#url: URL | undefined;
+
+	/** The request URL, parsed lazily. */
+	get url(): URL {
+		return (this.#url ??= new URL(this.request.url));
+	}
+
+	constructor(request: Request, params?: Record<string, string>, url?: URL) {
 		this.request = request;
 		this.params = params;
+		this.#url = url;
 		this.cookies = new CookieHelper(request);
 		this.headers = new HeaderHelper(request);
 
@@ -36,4 +52,11 @@ export default class ServerEvent {
 			this.response.headers.append(header[0], header[1]);
 		}
 	}
+
+	/**
+	 * Reads the request body as JSON.
+	 */
+	json(): Promise<unknown> {
+		return this.request.json();
+	}
 }

package/src/server/connect/connectMiddleware.ts

@@ -1,62 +1,66 @@
 import { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
 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.
+ * Converts a Connect-style middleware to a torpor middleware.
+ *
+ * If the Connect handler writes a response, it is returned from the `enter`
+ * hook and the middleware chain is short-circuited. If the handler calls
+ * `next()`, the rest of the chain runs after this middleware completes.
  *
  * @param handler - The Connect-style middleware function to be converted.
- * @returns A function that handles web requests and returns a Response or undefined.
+ * @returns A middleware whose `enter` hook handles the web request.
  */
 export default function connectMiddleware(
 	handler: ConnectMiddleware | ConnectMiddlewareBoolean,
 ): MiddlewareFunction {
-	return async (ev, next) => {
-		const req = requestToNodeMessage(ev.request);
-		const { res, onReadable } = nodeMessageToNodeResponse(req);
+	return {
+		enter: (ev) =>
+			new Promise<Response | void>((resolve, reject) => {
+				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),
+				onReadable(({ readable, headers, status }) => {
+					const responseBody: ReadableStream | null = statusCodesWithoutBody.includes(status)
+						? null
+						: (Readable.toWeb(readable) as unknown as ReadableStream);
+					resolve(
+						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();
-				}
-			};
+				const cnext = (error?: unknown) => {
+					if (error) {
+						// eslint-disable-next-line no-base-to-string
+						reject(error instanceof Error ? error : new Error(String(error)));
+					} else {
+						// The Connect handler is passing the request on
+						resolve();
+					}
+				};
 
-			try {
-				const handled = await handler(req, res, cnext);
-				if (handled === false) {
-					res.destroy();
-					resolve();
-				}
-			} catch (e) {
-				await cnext(e);
-			}
-		});
+				Promise.resolve(handler(req, res, cnext))
+					.then((handled) => {
+						if (handled === false) {
+							res.destroy();
+							// Returning false signals that the request was handled,
+							// so return an empty response to stop the chain
+							resolve(new Response(null, { status: 200 }));
+						}
+					})
+					.catch((e: unknown) => {
+						cnext(e);
+					});
+			}),
 	};
 }
 

package/src/server/connect/flattenHeaders.ts

@@ -11,7 +11,7 @@ export default function flattenHeaders(
 		} else if (Array.isArray(value)) {
 			for (const v of value) {
 				if (v !== undefined && v !== null) {
-					value.forEach((v) => flatHeaders.append(key, v));
+					flatHeaders.append(key, String(v));
 				}
 			}
 		} else {
@@ -19,26 +19,4 @@ export default function flattenHeaders(
 		}
 	}
 	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/requestToNodeMessage.ts

@@ -8,15 +8,18 @@ const DUMMY_BASE_URL = "http://localhost";
 /**
  * Creates an IncomingMessage object from a web Request.
  *
+ * The request body is intentionally not forwarded: this is only used to wrap
+ * Connect-style middlewares (e.g. Vite's dev middleware), which don't read
+ * the body. The actual route handler later reads `ev.request.body` directly,
+ * and forwarding the body here would consume it and break the handler.
+ *
  * @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([]);
+	const body = Readable.from([]);
 
 	return Object.assign(body, {
 		url: pathAndQuery,

package/src/server/types/MiddlewareFunction.ts

@@ -1,8 +1,22 @@
 import ServerEvent from "../ServerEvent";
 
-type MiddlewareFunction = (
-	ev: ServerEvent,
-	next: () => void | Promise<void>,
-) => void | Promise<void>;
+type MiddlewareFunction = {
+	/**
+	 * Called before the route handler. Middleware are run in the order they
+	 * were added. Return a Response to short-circuit the request; the
+	 * remaining middleware and the route handler are then skipped.
+	 */
+	enter?: (ev: ServerEvent) => Response | void | Promise<Response | void>;
+	/**
+	 * Called after the route handler (even if it threw), in reverse order.
+	 * Return a Response to replace the response. Middleware that were skipped
+	 * by a short-circuit don't get their exit hook run.
+	 *
+	 * If the route handler (or a later enter hook) threw, the error is
+	 * available as `ev.error`; returning a Response handles the error and
+	 * stops it from propagating.
+	 */
+	exit?: (ev: ServerEvent) => Response | void | Promise<Response | void>;
+};
 
 export default MiddlewareFunction;

package/src/site/Router.ts

@@ -1,13 +1,17 @@
 import type LayoutHandler from "../types/LayoutHandler";
 import type ManifestRoute from "../types/ManifestRoute";
 import type RouteHandler from "../types/RouteHandler";
-import pathToRegex from "../utils/pathToRegex";
+import PathTrie from "../utils/pathTrie";
 
 /**
  * A router that handles file routes with layouts, hooks, etc.
  */
 export default class Router {
 	routes: Route[] = [];
+	// Match index for the routes above. The routes list is kept for
+	// introspection (layouts/hooks lookup, client nav, tests); the trie is
+	// what `match` walks.
+	#trie = new PathTrie<Route>();
 
 	constructor() {}
 
@@ -18,29 +22,21 @@ export default class Router {
 
 	addPages(routes: ManifestRoute[]): this {
 		for (let r of routes) {
-			this.routes.push(
-				new Route(r.path, {
-					path: r.path,
-					type: r.type,
-					endPoint: r.endPoint,
-					subFolder: r.subFolder,
-				}),
-			);
+			this.addPage(r.path, r.type, r.endPoint, r.subFolder);
 		}
-		this.#sortRoutes();
 		return this;
 	}
 
 	// TODO: Allow calling with the endpoint itself, so that you can setup an app with no scaffold
 	addPage(path: string, type: number, endPoint: () => Promise<any>, subFolder?: string): this {
-		this.routes.push(
-			new Route(path, {
-				path,
-				type,
-				endPoint,
-				subFolder,
-			}),
-		);
+		let route = new Route(path, {
+			path,
+			type,
+			endPoint,
+			subFolder,
+		});
+		this.routes.push(route);
+		this.#trie.insert(path, route);
 		this.#sortRoutes();
 		return this;
 	}
@@ -56,27 +52,26 @@ export default class Router {
 	*/
 
 	match(path: string, query: URLSearchParams): RouteMatch | undefined {
-		for (let route of this.routes) {
-			let match = path.match(route.regex);
-			if (match) {
-				// Lazy load server endpoints and layouts
-				if (!route.handler.loaded) {
-					this.#loadHandler(route.handler, route.path);
-				}
-
-				return {
-					handler: route.handler,
-					params: match.groups,
-					query,
-				};
+		let found = this.#trie.match(path);
+		if (found) {
+			let route = found.value;
+			// Lazy load server endpoints and layouts
+			if (!route.handler.loaded) {
+				this.#loadHandler(route.handler, route.path);
 			}
+
+			return {
+				handler: route.handler,
+				params: found.params,
+				query,
+			};
 		}
 	}
 
 	#loadHandler(handler: RouteHandler, path: string) {
 		handler.layouts = this.#findLayouts(path, handler);
 		handler.serverEndPoint = this.#findServer(path);
-		handler.serverHook = this.#findServerHook(handler);
+		handler.serverHooks = this.#findServerHooks(handler);
 	}
 
 	#findLayouts(path: string, handler: RouteHandler): LayoutHandler[] | undefined {
@@ -113,14 +108,32 @@ export default class Router {
 		return serverRoute && serverRoute.handler.endPoint;
 	}
 
-	#findServerHook(handler: RouteHandler): (() => Promise<any>) | undefined {
-		// TODO: Should this be a collection, like layouts?
-		let serverHookPath = "/_hook/~server";
-		if (handler.subFolder !== undefined) {
-			serverHookPath = handler.subFolder + serverHookPath;
+	#findServerHooks(handler: RouteHandler): (() => Promise<any>)[] | undefined {
+		// Collect the hooks from the root down to the route path, like
+		// layouts. Only hooks with the same subFolder are included, so that
+		// e.g. an `api` set of routes can have its own hooks
+		const hooks: (() => Promise<any>)[] = [];
+		let parts = handler.path
+			// Strip the trailing `~server` (so we don't look for
+			// `~server/_hook/~server` which will never exist)
+			.replace(/\/~server$/, "")
+			// The path will always start with / so splitting e.g.
+			// `/first/second` will result in ['', 'first', 'second'] and
+			// checks for `/_hook/~server`, `/first/_hook/~server` and
+			// `/second/_hook/~server`
+			.split("/");
+		let basePath = "";
+		for (let i = 0; i < parts.length; i++) {
+			if (i > 0) {
+				basePath += "/" + parts[i];
+			}
+			const hookPath = basePath + "/_hook/~server";
+			const hookRoute = this.routes.find((r) => r.path === hookPath);
+			if (hookRoute && hookRoute.handler.subFolder === handler.subFolder) {
+				hooks.push(hookRoute.handler.endPoint);
+			}
 		}
-		const serverHookRoute = this.routes.find((r) => r.path === serverHookPath);
-		return serverHookRoute && serverHookRoute.handler.endPoint;
+		return hooks.length ? hooks : undefined;
 	}
 
 	// HACK: We're doing this here as well as in Site, so that you can use the
@@ -147,12 +160,10 @@ export default class Router {
 
 class Route {
 	path: string;
-	regex: RegExp;
 	handler: RouteHandler;
 
 	constructor(path: string, handler: RouteHandler) {
 		this.path = path;
-		this.regex = pathToRegex(path);
 		this.handler = handler;
 	}
 }

package/src/site/Site.ts

@@ -1,9 +1,13 @@
 import { promises as fs } from "node:fs";
 import fpath from "node:path";
 import { type Plugin, type UserConfig } from "vite";
-import tsconfigPaths from "vite-tsconfig-paths";
 import type Adapter from "../types/Adapter";
+import type SitePlugin from "../types/SitePlugin";
+import type { InlineEndPoint } from "../types/Route";
+import type PageServerEndPoint from "../types/PageServerEndPoint";
 import type Route from "../types/Route";
+import type ServerEndPoint from "../types/ServerEndPoint";
+import type ServerHook from "../types/ServerHook";
 import {
 	ERROR_ROUTE,
 	HOOK_ROUTE,
@@ -29,11 +33,17 @@ import defaultAdapter from "./defaultAdapter";
 export default class Site {
 	root: string;
 	routes: Route[] = [];
-	// Is default plugins a bad idea?
-	// HACK: Set loose because otherwise it uses a list of allowed extensions
-	// TODO: Should probably just do this ourselves and let the user pass in
-	// tsconfigPaths themselves if they want to do something funky
-	plugins: Plugin[] = [tsconfigPaths({ loose: true })];
+	/**
+	 * Torpor site plugins, run when the site config is loaded (for dev and
+	 * build) and when the server starts up. Use these to register extra
+	 * routes (e.g. `openApi()` from `@torpor/build/openapi`) or add other
+	 * framework-level functionality
+	 */
+	plugins: SitePlugin[] = [];
+	/**
+	 * Vite plugins to add to the client and server builds
+	 */
+	vitePlugins: Plugin[] = [];
 	// Is default adapter a bad idea?
 	adapter: Adapter = defaultAdapter;
 	/**
@@ -45,10 +55,36 @@ export default class Site {
 	/**
 	 * Vite config options to merge with the standard Torpor build options.
 	 * `plugins` and `build.rollupOptions.input` will be overridden, so you
-	 * should set `Site.plugins` and `Site.inputs` instead. Other options may be
+	 * should set `Site.vitePlugins` and `Site.inputs` instead. Other options may be
 	 * overridden or incompatible, so experimentation may be required
 	 */
 	viteConfig?: UserConfig;
+	/**
+	 * The path to the site.config file. Set automatically by the CLI; used by
+	 * the manifest plugin to import inline endpoints for server builds.
+	 */
+	configFile?: string;
+	/**
+	 * A state map for plugins to store their configuration and state on the
+	 * site, so that framework internals (e.g. the manifest plugin) and other
+	 * plugins can read them back:
+	 *
+	 * ```ts
+	 * const myKey = Symbol.for("my-plugin");
+	 * site.pluginState.set(myKey, options);
+	 * ```
+	 *
+	 * Prefer `Symbol.for("...")` keys (or plain strings) over `Symbol()`,
+	 * because the user's config file and framework internals can be loaded as
+	 * separate module instances -- registry symbols are shared across
+	 * instances, `Symbol()` ones are not.
+	 */
+	pluginState: Map<PropertyKey, unknown> = new Map();
+	/**
+	 * Inline endpoints keyed by `"path:type"`. Populated by `addRoute` when
+	 * the user passes an inline endpoint object instead of a file path.
+	 */
+	inlineEndPoints: Record<string, InlineEndPoint> = {};
 
 	constructor() {
 		this.root = process.cwd();
@@ -189,9 +225,147 @@ export default class Site {
 		}
 	}
 
-	// TODO: You could make your site in a single file, like e.g. Hono...
-	//addPage(path: string, endPoint: PageEndPoint, serverEndPoint?: PageServerEndPoint) {}
-	//addEndPoint(path: string, endPoint: ServerEndPoint) {}
+	/**
+	 * Adds a route in code, without needing the standard file naming
+	 * conventions (+page.ts, +page.server.ts, etc). This is useful for small
+	 * sites with one or two pages.
+	 *
+	 * Any combination of options may be provided; each maps to the
+	 * corresponding file-route type:
+	 *
+	 * - `page` — a `+page` (`.torp` component or `.ts`/`.js` `PageEndPoint`)
+	 * - `pageServer` — a `+page.server` (`PageServerEndPoint`, file or inline)
+	 * - `server` — a `+server` HTTP endpoint (`ServerEndPoint`, file or inline)
+	 * - `layout` — a `_layout` (`.torp` component or `.ts`/`.js` `PageEndPoint`)
+	 * - `layoutServer` — a `_layout.server` (`PageServerEndPoint`, file or inline)
+	 * - `hookServer` — a `_hook.server` (`ServerHook`, file or inline)
+	 * - `error` — an `_error` page (`.torp` component or `.ts`/`.js` `PageEndPoint`)
+	 *
+	 * Options that need a component (`page`, `layout`, `error`) must be file
+	 * paths so the component is included in the client bundle. Server-only
+	 * options (`pageServer`, `server`, `layoutServer`, `hookServer`) accept
+	 * either a file path or an inline object; inline server code is kept out
+	 * of the client bundle automatically.
+	 *
+	 * @example
+	 * // A page with an inline server action
+	 * site.addRoute("/", {
+	 *   page: "./src/Counter.torp",
+	 *   pageServer: { actions: { set: async ({ request }) => ok() } },
+	 * });
+	 * @example
+	 * // A JSON API endpoint
+	 * site.addRoute("/api/time", {
+	 *   server: { get: async () => ok({ time: Date.now() }) },
+	 * });
+	 * @example
+	 * // A root layout, server hook, and error page
+	 * site.addRoute("/", {
+	 *   layout: "./src/Layout.torp",
+	 *   hookServer: { enter: async (event) => {} },
+	 *   error: "./src/ErrorPage.torp",
+	 * });
+	 *
+	 * @param path The route path, e.g. `/` or `/about`
+	 * @param options File paths and/or inline endpoints for the route
+	 * @param subFolder An optional subFolder for grouping routes
+	 */
+	addRoute(
+		path: string,
+		options: {
+			page?: string;
+			pageServer?: string | PageServerEndPoint;
+			server?: string | ServerEndPoint;
+			layout?: string;
+			layoutServer?: string | PageServerEndPoint;
+			hookServer?: string | ServerHook;
+			error?: string;
+		},
+		subFolder?: string,
+	): void {
+		let normalizedSubFolder = subFolder;
+		if (normalizedSubFolder !== undefined && !normalizedSubFolder.startsWith("/")) {
+			normalizedSubFolder = "/" + normalizedSubFolder;
+		}
+
+		// The base path with any trailing slash stripped, so that we can
+		// append "/_layout", "/~server" etc. For the root "/" this is "".
+		let base = path.replace(/\/$/, "");
+
+		if (options.page !== undefined) {
+			this.#pushRoute(path, PAGE_ROUTE, options.page, normalizedSubFolder);
+		}
+		if (options.pageServer !== undefined) {
+			this.#pushRoute(
+				`${base}/~server`,
+				PAGE_SERVER_ROUTE,
+				options.pageServer,
+				normalizedSubFolder,
+			);
+		}
+		if (options.server !== undefined) {
+			this.#pushRoute(path, SERVER_ROUTE, options.server, normalizedSubFolder);
+		}
+		if (options.layout !== undefined) {
+			this.#pushRoute(`${base}/_layout`, LAYOUT_ROUTE, options.layout, normalizedSubFolder);
+		}
+		if (options.layoutServer !== undefined) {
+			this.#pushRoute(
+				`${base}/_layout/~server`,
+				LAYOUT_SERVER_ROUTE,
+				options.layoutServer,
+				normalizedSubFolder,
+			);
+		}
+		if (options.hookServer !== undefined) {
+			this.#pushRoute(
+				`${base}/_hook/~server`,
+				HOOK_SERVER_ROUTE,
+				options.hookServer,
+				normalizedSubFolder,
+			);
+		}
+		if (options.error !== undefined) {
+			this.#pushRoute(`${base}/_error`, ERROR_ROUTE, options.error, normalizedSubFolder);
+		}
+
+		this.#sortRoutes();
+	}
+
+	/**
+	 * Pushes a single route entry, handling both file-path and inline-endpoint
+	 * targets. File paths are resolved relative to the site root; inline
+	 * endpoints are also stored in `inlineEndPoints` keyed by `"path:type"`
+	 * so the manifest plugin can resolve them at build time.
+	 *
+	 * If a route with the same path and type was already added, it is
+	 * replaced, so that running a plugin twice (config load and server
+	 * startup) doesn't add duplicate routes.
+	 */
+	#pushRoute(
+		routePath: string,
+		type: RouteType,
+		target: string | InlineEndPoint,
+		subFolder?: string,
+	): void {
+		const index = this.routes.findIndex((r) => r.path === routePath && r.type === type);
+		if (typeof target === "string") {
+			let file = fpath.relative(this.root, fpath.resolve(this.root, target));
+			if (index >= 0) {
+				this.routes[index] = { path: routePath, file, type, subFolder };
+			} else {
+				this.routes.push({ path: routePath, file, type, subFolder });
+			}
+		} else {
+			let key = `${routePath}:${type}`;
+			this.inlineEndPoints[key] = target;
+			if (index >= 0) {
+				this.routes[index] = { path: routePath, endPoint: target, type, subFolder };
+			} else {
+				this.routes.push({ path: routePath, endPoint: target, type, subFolder });
+			}
+		}
+	}
 
 	#sortRoutes() {
 		this.routes = this.routes.sort((a, b) => {