@torpor/build 0.0.6 → 0.1.1

package/src/site/serverEntry.ts

@@ -1,45 +1,42 @@
+import manifest from "@torpor/build/manifest";
 import { type ServerComponent, type ServerSlotRender } from "@torpor/view";
-import fs from "node:fs";
-import { IncomingMessage } from "node:http";
-import path from "node:path";
-import { deleteCookie, eventHandler, getCookie, setCookie } from "vinxi/http";
-import { type CookieSerializeOptions, type EventHandlerRequest, H3Event } from "vinxi/http";
-import { getManifest } from "vinxi/manifest";
-import notFound from "../response/notFound";
-import ok from "../response/ok";
-import seeOther from "../response/seeOther";
-import serverError from "../response/serverError";
-import $page from "../state/$page";
-import type PageEndPoint from "../types/PageEndPoint";
-import type PageServerEndPoint from "../types/PageServerEndPoint";
-import type RouteHandler from "../types/RouteHandler";
-import type ServerEndPoint from "../types/ServerEndPoint";
-import type ServerEvent from "../types/ServerEvent";
-import type ServerHook from "../types/ServerHook";
-import routeHandlers from "./routeHandlers";
-
-let printedRoutes = false;
-
-export default eventHandler(async (event) => {
-	const url = new URL(`http://${process.env.HOST ?? "localhost"}${event.node.req.url}`);
+import notFound from "../response/notFound.ts";
+import ok from "../response/ok.ts";
+import seeOther from "../response/seeOther.ts";
+import ServerEvent from "../server/ServerEvent.ts";
+import $page from "../state/$page.ts";
+import type PageEndPoint from "../types/PageEndPoint.ts";
+import type PageServerEndPoint from "../types/PageServerEndPoint.ts";
+import RouteHandler from "../types/RouteHandler.ts";
+import {
+	HOOK_ROUTE,
+	HOOK_SERVER_ROUTE,
+	LAYOUT_ROUTE,
+	LAYOUT_SERVER_ROUTE,
+	PAGE_ROUTE,
+	PAGE_SERVER_ROUTE,
+	SERVER_ROUTE,
+} from "../types/RouteType";
+import type ServerEndPoint from "../types/ServerEndPoint.ts";
+import type ServerHook from "../types/ServerHook.ts";
+import type ServerLoadEvent from "../types/ServerLoadEvent.ts";
+import Router from "./Router.ts";
+
+// Build the router from the Site object created by the user
+const router = new Router();
+router.addPages(manifest.routes);
+
+console.log(`routes:\n  ${router.routes.map((r) => r.path).join("\n  ")}`);
+
+export async function load(ev: ServerEvent, template: string) {
+	//const url = new URL(`http://${process.env.HOST ?? "localhost"}${ev.request.url}`);
+	const url = new URL(ev.request.url);
 	const path = url.pathname;
+	const query = url.searchParams;
 
-	const searchParams = url.searchParams;
-
-	console.log(
-		"handling server",
-		event.method,
-		"for",
-		path,
-		searchParams.size ? `with ${searchParams}` : "",
-	);
-
-	if (!printedRoutes) {
-		printedRoutes = true;
-		console.log("routes:\n  " + routeHandlers.handlers.map((h) => h.path).join("\n  "));
-	}
+	console.log(`handling ${ev.request.method} for '${path}'${query.size ? ` with ${query}` : ""}`);
 
-	const route = routeHandlers.match(path, searchParams);
+	const route = router.match(path, query);
 	if (!route) {
 		return notFound();
 	}
@@ -49,121 +46,93 @@ export default eventHandler(async (event) => {
 	$page.url = url;
 
 	const handler = route.handler;
-	const params = route.routeParams || {};
+	const params = route.params || {};
 
 	// TODO: Hit the server hook out here
-
-	// HACK: Support any +server location??
-	if (path.startsWith("/api/")) {
-		return await loadData(event, url, handler, params);
-	} else if (path.endsWith("~server")) {
-		// HACK: Is this the best way to signal that we want server data??
-		// And can we maybe combine this with the above method, or are they too different?
-		if (event.method === "GET") {
-			return await loadServerData(event, url, handler, params);
+	// We could maybe set data loading up as middleware on a route??????
+
+	switch (handler.type) {
+		case PAGE_ROUTE:
+		case LAYOUT_ROUTE: {
+			// It's a /+page.ts or /_layout.ts endpoint
+			if (ev.request.method === "GET") {
+				return await loadView(ev, url, handler, params, template);
+			} else if (ev.request.method === "POST") {
+				return await runAction(ev, url, handler, params, query);
+			}
+			break;
 		}
-	} else {
-		if (event.method === "GET") {
-			return await loadView(event, url, handler, params);
-		} else if (event.method === "POST") {
-			return await runAction(event, url, handler, params, searchParams);
+		case PAGE_SERVER_ROUTE:
+		case LAYOUT_SERVER_ROUTE: {
+			// It's a /+page.server.ts or /_layout.server.ts endpoint
+			if (ev.request.method === "GET") {
+				return await loadData(ev, url, handler, "load", params);
+			}
+			break;
+		}
+		case SERVER_ROUTE: {
+			// It's a /+server.ts endpoint
+			const functionName = ev.request.method.toLowerCase().replace("delete", "del");
+			return await loadData(ev, url, handler, functionName, params);
+		}
+		case HOOK_ROUTE:
+		case HOOK_SERVER_ROUTE: {
+			break;
 		}
 	}
-});
+
+	return notFound();
+}
 
 async function loadData(
-	event: H3Event<EventHandlerRequest>,
+	ev: ServerEvent,
 	url: URL,
 	handler: RouteHandler,
+	functionName: string,
 	params: Record<string, string>,
 ) {
-	const functionName = event.method.toLowerCase().replace("delete", "del");
-
-	const serverEndPoint: ServerEndPoint | undefined = (await handler.endPoint).default;
+	const serverEndPoint: ServerEndPoint | undefined = (await handler.endPoint()).default;
 	if (serverEndPoint && serverEndPoint[functionName]) {
-		const serverParams = await buildServerParams(event, url, params);
+		const serverParams = buildServerParams(ev, url, params);
 
 		if (handler.serverHook) {
-			const serverHook: ServerHook | undefined = (await handler.serverHook).default;
+			const serverHook: ServerHook | undefined = (await handler.serverHook()).default;
 			if (serverHook?.handle) {
 				await serverHook.handle(serverParams);
 			}
 		}
 
 		const result = await serverEndPoint[functionName](serverParams);
-		// If there was no response returned from load (such as errors or a
-		// redirect), send an ok response
-		return result || ok();
-	}
-}
-
-async function loadServerData(
-	event: H3Event<EventHandlerRequest>,
-	url: URL,
-	handler: RouteHandler,
-	params: Record<string, string>,
-) {
-	const serverEndPoint: PageServerEndPoint | undefined = (await handler.endPoint).default;
-	if (serverEndPoint?.load) {
-		const serverParams = await buildServerParams(event, url, params);
 
-		if (handler.serverHook) {
-			const serverHook: ServerHook | undefined = (await handler.serverHook).default;
-			if (serverHook?.handle) {
-				await serverHook.handle(serverParams);
-			}
-		}
-
-		const result = await serverEndPoint.load(serverParams);
 		// If there was no response returned from load (such as errors or a
 		// redirect), send an ok response
 		return result || ok();
 	}
 
-	// It's ok if there's no load method -- we can't tell whether there will be
-	// when loading routes
-	//return ok();
+	return notFound();
 }
 
 async function loadView(
-	event: H3Event<EventHandlerRequest>,
+	ev: ServerEvent,
 	url: URL,
 	handler: RouteHandler,
 	params: Record<string, string>,
+	template: string,
 ) {
 	// There must be a client endpoint with a component
-	const clientEndPoint: PageEndPoint | undefined = (await handler.endPoint).default;
+	const clientEndPoint: PageEndPoint | undefined = (await handler.endPoint()).default;
 	if (!clientEndPoint?.component) {
 		return notFound();
 	}
 
 	// There may be a server endpoint
-	const serverEndPoint: PageServerEndPoint | undefined = (await handler.serverEndPoint)?.default;
-
-	// HACK: wrangle the view into app.html
-	// We could instead have an App.torp component with a slot, but you can run
-	// into hydration problems that way e.g. if there is a browser plugin that
-	// injects elements into <head> or <body>
-	const appHtml = loadAppHtml();
-	let contentStart = regexIndexOf(appHtml, /\<div\s+id=("app"|'app'|app)\s+/);
-	contentStart = appHtml.indexOf(">", contentStart) + 1;
-	let contentEnd = appHtml.indexOf("</div>", contentStart);
-	if (contentStart === -1 || contentEnd === -1) {
-		return serverError;
-	}
-
-	// Build client scripts
-	const clientManifest = getManifest("client");
-	const clientHandler = clientManifest.inputs[clientManifest.handler];
-	const clientScript = clientHandler.output.path;
-	const hasClientScript = !!clientScript;
-	const manifestJson = JSON.stringify(clientManifest.json());
-	const hasManifestJson = manifestJson !== "{}";
+	const serverEndPoint: PageServerEndPoint | undefined =
+		handler.serverEndPoint && (await handler.serverEndPoint())?.default;
 
 	// Maybe hit the server hook
-	const serverParams = await buildServerParams(event, url, params);
+	const serverParams = buildServerParams(ev, url, params);
 	if (handler.serverHook) {
-		const serverHook: ServerHook | undefined = (await handler.serverHook).default;
+		const serverHook: ServerHook | undefined = (await handler.serverHook()).default;
 		if (serverHook?.handle) {
 			await serverHook.handle(serverParams);
 		}
@@ -175,9 +144,9 @@ async function loadView(
 	let data = {};
 	if (handler.layouts) {
 		for (let layout of handler.layouts) {
-			const layoutEndPoint: PageEndPoint | undefined = (await layout.endPoint)?.default;
-			const layoutServerEndPoint: PageServerEndPoint | undefined = (await layout.serverEndPoint)
-				?.default;
+			const layoutEndPoint: PageEndPoint | undefined = (await layout.endPoint())?.default;
+			const layoutServerEndPoint: PageServerEndPoint | undefined =
+				layout.serverEndPoint && (await layout.serverEndPoint())?.default;
 			const layoutData = await loadClientAndServerData(
 				url,
 				params,
@@ -212,7 +181,8 @@ async function loadView(
 		slotFunctions[handler.layouts.length] = (_, context) =>
 			(clientEndPoint.component as ServerComponent)($props, context);
 		for (let i = handler.layouts.length - 1; i >= 0; i--) {
-			const layoutEndPoint: PageEndPoint | undefined = (await handler.layouts[i].endPoint)?.default;
+			const layoutEndPoint: PageEndPoint | undefined = (await handler.layouts[i].endPoint())
+				?.default;
 			if (layoutEndPoint?.component) {
 				if (i === 0) {
 					component = layoutEndPoint.component as ServerComponent;
@@ -227,64 +197,62 @@ async function loadView(
 		}
 	}
 
-	event.node.res.setHeader("content-type", "text/html");
-
-	let componentCode = "";
+	let html;
 	try {
-		componentCode = component($props, undefined, slots);
+		html = component($props, undefined, slots);
+		html = template.replace("%COMPONENT_HTML%", html);
 	} catch (error) {
 		// TODO: Show a proper Error component
-		componentCode = '<span style="color: red">Script syntax error</span><p>' + error + "</p>";
+		html = '<span style="color: red">Script syntax error</span><p>' + error + "</p>";
 		console.log(error);
 	}
 
-	// Put it all together
-	let html =
-		appHtml.substring(0, contentStart) +
-		componentCode +
-		appHtml.substring(contentEnd) +
-		(hasClientScript ? `<script type="module" src="${clientScript}"></script>` : "") +
-		(hasManifestJson ? `<script>window.manifest = ${manifestJson}</script>` : "");
-
-	//console.log(html);
-
-	return html;
+	return new Response(html, {
+		status: 200,
+		headers: {
+			"Content-Type": "text/html",
+		},
+	});
 }
 
 async function runAction(
-	event: H3Event<EventHandlerRequest>,
+	ev: ServerEvent,
 	url: URL,
 	handler: RouteHandler,
 	params: Record<string, string>,
-	searchParams: URLSearchParams,
+	query: URLSearchParams,
 ) {
-	const actionName = (Array.from(searchParams.keys())[0] || "default").replace(/^\//, "");
-	const serverEndPoint: PageServerEndPoint | undefined = (await handler.serverEndPoint).default;
+	const actionName = (Array.from(query.keys())[0] || "default").replace(/^\//, "");
+	const serverEndPoint: PageServerEndPoint | undefined =
+		handler.serverEndPoint && (await handler.serverEndPoint()).default;
 	if (serverEndPoint?.actions) {
 		const action = serverEndPoint.actions[actionName];
 		if (action) {
 			// TODO: form.errors etc
-			const serverParams = await buildServerParams(event, url, params);
+			const serverParams = buildServerParams(ev, url, params);
 
 			if (handler.serverHook) {
-				const serverHook: ServerHook | undefined = (await handler.serverHook).default;
+				const serverHook: ServerHook | undefined = (await handler.serverHook()).default;
 				if (serverHook?.handle) {
 					await serverHook.handle(serverParams);
 				}
 			}
 
-			const result = await action(serverParams);
+			const result = await action(serverParams); // <--
+
 			// If there was no response returned from the action (such as errors
 			// or a redirect), reload the page by redirecting
 			return result || seeOther(url.pathname);
 		}
 	}
+
+	return notFound();
 }
 
 async function loadClientAndServerData(
 	url: URL,
 	params: Record<string, string>,
-	serverParams: ServerEvent,
+	serverParams: ServerLoadEvent,
 	data: Record<string, any>,
 	clientEndPoint?: PageEndPoint,
 	serverEndPoint?: PageServerEndPoint,
@@ -314,72 +282,17 @@ function buildClientParams(url: URL, params: Record<string, string>, data: Recor
 	};
 }
 
-async function buildServerParams(
-	event: H3Event<EventHandlerRequest>,
+function buildServerParams(
+	ev: ServerEvent,
 	url: URL,
 	params: Record<string, string>,
-): Promise<ServerEvent> {
+): ServerLoadEvent {
 	return {
 		url,
 		params,
 		appData: {},
-		request: await incomingMessageToRequest(event.node.req, url),
-		response: event.node.res,
-		cookies: {
-			get: (name: string) => getCookie(event, name),
-			set: (name: string, value: string, options?: CookieSerializeOptions) =>
-				setCookie(event, name, value, options),
-			delete: (name: string, options?: CookieSerializeOptions) =>
-				deleteCookie(event, name, options),
-		},
+		request: ev.request,
+		cookies: ev.cookies,
+		headers: ev.headers,
 	};
 }
-
-// From https://stackoverflow.com/a/78849544
-async function incomingMessageToRequest(req: IncomingMessage, url: URL): Promise<Request> {
-	const headers = new Headers();
-	for (const [key, value] of Object.entries(req.headers)) {
-		if (Array.isArray(value)) {
-			value.forEach((v) => headers.append(key, v));
-		} else if (value !== undefined) {
-			headers.set(key, value);
-		}
-	}
-	// Convert body to Buffer if applicable
-	const body = req.method !== "GET" && req.method !== "HEAD" ? await getRequestBody(req) : null;
-	return new Request(url, {
-		method: req.method,
-		headers: headers,
-		body: body,
-	});
-}
-
-function getRequestBody(req: IncomingMessage): 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);
-		});
-	});
-}
-
-let loadedAppHtml = "";
-function loadAppHtml() {
-	if (!loadedAppHtml) {
-		let file = path.resolve("src/app.html");
-		loadedAppHtml = fs.readFileSync(file).toString();
-	}
-	return loadedAppHtml;
-}
-
-// From https://stackoverflow.com/a/274094
-function regexIndexOf(string: string, regex: RegExp, position?: number) {
-	var indexOf = string.substring(position || 0).search(regex);
-	return indexOf >= 0 ? indexOf + (position || 0) : indexOf;
-}

package/src/types/Adapter.ts

@@ -0,0 +1,10 @@
+import Server from "../server/Server";
+import Site from "../site/Site";
+
+type Adapter = {
+	prebuild?: (site: Site) => Promise<void> | void;
+	postbuild?: (site: Site) => Promise<void> | void;
+	serve: (server: Server, site: Site) => void;
+};
+
+export default Adapter;

package/src/types/HttpMethod.ts

@@ -0,0 +1,12 @@
+type HttpMethod =
+	| "GET"
+	| "HEAD"
+	| "PATCH"
+	| "POST"
+	| "PUT"
+	| "DELETE"
+	| "OPTIONS"
+	| "CONNECT"
+	| "TRACE";
+
+export default HttpMethod;

package/src/types/LayoutHandler.ts

@@ -0,0 +1,7 @@
+type LayoutHandler = {
+	path: string;
+	endPoint: () => Promise<any>;
+	serverEndPoint?: () => Promise<any>;
+};
+
+export default LayoutHandler;

package/src/types/ManifestRoute.ts

@@ -0,0 +1,8 @@
+type ManifestRoute = {
+	path: string;
+	type: number;
+	file: string;
+	endPoint: () => Promise<any>;
+};
+
+export default ManifestRoute;

package/src/types/MiddlewareFunction.ts

@@ -0,0 +1,8 @@
+import ServerEvent from "../server/ServerEvent";
+
+type MiddlewareFunction = (
+	ev: ServerEvent,
+	next: () => void | Promise<void>,
+) => void | Promise<void>;
+
+export default MiddlewareFunction;

package/src/types/PageEndPoint.ts

@@ -1,5 +1,5 @@
 import { type Component } from "@torpor/view";
-import type PageEvent from "./PageEvent";
+import type PageLoadEvent from "./PageLoadEvent";
 
 /**
  * For +page.
@@ -13,7 +13,7 @@ type PageEndPoint = {
 	/**
 	 * Loads data for the page.
 	 */
-	load?: (event: PageEvent) => any;
+	load?: (event: PageLoadEvent) => any;
 	/**
 	 * The component that is displayed for the page.
 	 */
@@ -22,8 +22,9 @@ type PageEndPoint = {
 	/**
 	 * The head element data for the page, which may include a <title> and <meta> elements.
 	 */
-	head?: HeadElement[] | ((event: PageEvent) => HeadElement[]);
+	head?: HeadElement[] | ((event: PageLoadEvent) => HeadElement[]);
 };
+
 export default PageEndPoint;
 
 type HeadElement = TitleElement | MetaElement;

package/src/types/{PageEvent.ts → PageLoadEvent.ts}

@@ -1,4 +1,4 @@
-type PageEvent = {
+type PageLoadEvent = {
 	/**
 	 * The URL for the server function.
 	 */
@@ -12,4 +12,5 @@ type PageEvent = {
 	 */
 	data: Record<string, any>;
 };
-export default PageEvent;
+
+export default PageLoadEvent;

package/src/types/PageServerAction.ts

@@ -1,4 +1,7 @@
-import type ServerEvent from "./ServerEvent";
+import type ServerLoadEvent from "./ServerLoadEvent";
+
+type PageServerAction = (
+	event: ServerLoadEvent,
+) => Response | Promise<Response | undefined> | Promise<void> | void;
 
-type PageServerAction = (event: ServerEvent) => Response | Promise<Response | undefined> | void;
 export default PageServerAction;

package/src/types/PageServerEndPoint.ts

@@ -14,4 +14,5 @@ type PageServerEndPoint = {
 	 */
 	actions?: Record<string, PageServerAction>;
 };
+
 export default PageServerEndPoint;

package/src/types/PageServerLoad.ts

@@ -1,4 +1,7 @@
-import type ServerEvent from "./ServerEvent";
+import type ServerLoadEvent from "./ServerLoadEvent";
+
+type PageServerLoad = (
+	event: ServerLoadEvent,
+) => Response | Promise<Response | undefined> | Promise<void> | void;
 
-type PageServerLoad = (event: ServerEvent) => Response | Promise<Response | undefined> | void;
 export default PageServerLoad;

package/src/types/RouteHandler.ts

@@ -2,12 +2,13 @@ import type RouteLayoutHandler from "./RouteLayoutHandler";
 
 type RouteHandler = {
 	path: string;
-	regex: RegExp;
-	endPoint: Promise<any>;
+	type: number;
+	endPoint: () => Promise<any>;
 
-	loaded: boolean;
+	loaded?: boolean;
 	layouts?: RouteLayoutHandler[];
-	serverEndPoint?: Promise<any>;
-	serverHook?: Promise<any>;
+	serverEndPoint?: () => Promise<any>;
+	serverHook?: () => Promise<any>;
 };
+
 export default RouteHandler;

package/src/types/RouteHandlerCollection.ts

@@ -5,4 +5,5 @@ type RouteHandlerCollection = {
 	handlers: RouteHandler[];
 	match(path: string, urlParams?: URLSearchParams): RouteMatchResult | undefined;
 };
+
 export default RouteHandlerCollection;

package/src/types/RouteLayoutHandler.ts

@@ -1,6 +1,7 @@
 type RouteLayoutHandler = {
 	path: string;
-	endPoint: Promise<any>;
-	serverEndPoint?: Promise<any>;
+	endPoint: () => Promise<any>;
+	serverEndPoint?: () => Promise<any>;
 };
+
 export default RouteLayoutHandler;

package/src/types/RouteMatchResult.ts

@@ -2,7 +2,8 @@ import type RouteHandler from "./RouteHandler";
 
 type RouteMatchResult = {
 	handler: RouteHandler;
-	routeParams?: Record<string, string>;
-	urlParams?: Record<string, string>;
+	params?: Record<string, string>;
+	query?: Record<string, string>;
 };
+
 export default RouteMatchResult;

package/src/types/RouteType.ts

@@ -0,0 +1,7 @@
+export const PAGE_ROUTE = 0;
+export const PAGE_SERVER_ROUTE = 1;
+export const SERVER_ROUTE = 3;
+export const LAYOUT_ROUTE = 4;
+export const LAYOUT_SERVER_ROUTE = 5;
+export const HOOK_ROUTE = 6;
+export const HOOK_SERVER_ROUTE = 7;

package/src/types/ServerEndPoint.ts

@@ -33,4 +33,5 @@ type ServerEndPoint = { [key: string]: ServerRequest } & {
 	 */
 	head?: ServerRequest;
 };
+
 export default ServerEndPoint;

package/src/types/ServerHook.ts

@@ -1,4 +1,4 @@
-import type ServerEvent from "./ServerEvent";
+import type ServerLoadEvent from "./ServerLoadEvent";
 
 /**
  * For _hook.server.
@@ -9,6 +9,7 @@ type ServerHook = {
 	 */
 	handle?: ServerLoad;
 };
+
 export default ServerHook;
 
-type ServerLoad = (event: ServerEvent) => Promise<void> | void;
+type ServerLoad = (event: ServerLoadEvent) => Promise<void> | void;