@torpor/build 1.0.0 → 1.0.2

package/src/state/client.ts

@@ -1,15 +0,0 @@
-import type ClientState from "../types/ClientState";
-
-const CLIENT_SYMBOL: unique symbol = Symbol.for("torp.Client");
-
-const client: ClientState =
-	// @ts-ignore
-	(globalThis[CLIENT_SYMBOL] ??= {
-		// @ts-ignore This will definitely, 100% get set
-		router: null,
-		layoutStack: [],
-		// TODO: Probably expire after 30 seconds or something?
-		prefetchedData: {},
-	});
-
-export default client;

package/src/state.ts

@@ -1,3 +0,0 @@
-import $page from "./state/$page";
-
-export { $page };

package/src/test/runTest.ts

@@ -1,538 +0,0 @@
-import { type ServerComponent, type ServerSlotRender } from "@torpor/view/ssr";
-import path from "node:path";
-import formDataToRecord from "../form/formDataToRecord.ts";
-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 Router from "../site/Router.ts";
-import Site from "../site/Site";
-import $page from "../state/$serverPage.ts";
-import type PageEndPoint from "../types/PageEndPoint.ts";
-import type PageServerEndPoint from "../types/PageServerEndPoint.ts";
-import type RouteHandler from "../types/RouteHandler.ts";
-import type ServerRequest from "../types/ServerRequest.ts";
-import {
-	ERROR_ROUTE,
-	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 searchParamsToRecord from "../utils/searchParamsToRecord.ts";
-import validate from "../validation/validate.ts";
-import ValidationError from "../validation/ValidationError.ts";
-import {
-	endpointSchema,
-	validateEndpointParams,
-	validateHandlerInput,
-	validationErrorResponse,
-} from "../validation/endpoint.ts";
-
-/**
- * Runs a site route in test mode
- * @param site The site configuration, with routing configured
- * @param route The route path e.g. `/home`
- * @param ev An optional ServerEvent, which you can use to set test cookies and headers
- * @returns An HTTP response containing the requested data, HTML, or error status
- */
-export default async function runTest(
-	site: Site,
-	route: string,
-	ev?: ServerEvent,
-): Promise<Response> {
-	if (!route.startsWith("/")) route += "/";
-	if (!ev) {
-		const req = new Request(`http://localhost${route}`);
-		ev = new ServerEvent(req);
-	}
-
-	// Build the router from the Site object created by the user
-	const router = new Router();
-	router.addPages(
-		site.routes.map((r) => ({
-			path: r.path,
-			type: r.type,
-			endPoint: async () => {
-				if (r.file) {
-					const mod = await import(/* @vite-ignore */ path.join(site.root, r.file));
-					// A .torp file's default export is a component, so wrap it as
-					// a PageEndPoint ({ component }) for the entries
-					if (r.file.endsWith(".torp")) {
-						return { default: { component: mod.default } };
-					}
-					return mod;
-				}
-				// Inline endpoint (no file) — return directly from memory
-				return { default: r.endPoint };
-			},
-			subFolder: r.subFolder,
-		})),
-	);
-
-	return await load(router, ev, "%COMPONENT_BODY%");
-}
-
-// HACK: This is a copy of serverEntry
-// TODO: Make it shared instead!
-async function load(router: Router, ev: ServerEvent, template: string): Promise<Response> {
-	//const url = new URL(`http://${process.env.HOST ?? "localhost"}${ev.request.url}`);
-	const url = ev.url;
-	const path = url.pathname;
-	const query = url.searchParams;
-
-	//console.log(`handling ${ev.request.method} for '${path}'${query.size ? ` with ${query}` : ""}`);
-
-	const route = router.match(path, query);
-	if (!route) {
-		return notFound();
-	}
-
-	// Update $page before building the components
-	// TODO: Find somewhere better to put this
-	$page.url = url;
-	if (path.endsWith("/_error")) {
-		$page.status = parseInt(query.get("status") ?? "404");
-		$page.error = { message: query.get("message") ?? "" };
-	} else {
-		$page.status = 200;
-	}
-
-	const handler = route.handler;
-	const params = route.params || {};
-
-	// TODO: Hit the server hook out here
-	// 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") {
-				const serverEndPoint: PageServerEndPoint | undefined =
-					handler.serverEndPoint && (await handler.serverEndPoint()).default;
-				return await runAction(ev, url, handler, serverEndPoint, params, query);
-			}
-			break;
-		}
-		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);
-			} else if (ev.request.method === "POST") {
-				const serverEndPoint: PageServerEndPoint | undefined =
-					handler.endPoint && (await handler.endPoint()).default;
-				return await runAction(ev, url, handler, serverEndPoint, params, query);
-			}
-			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 ERROR_ROUTE: {
-			return await loadView(ev, url, handler, params, template);
-		}
-		case HOOK_ROUTE:
-		case HOOK_SERVER_ROUTE: {
-			break;
-		}
-	}
-
-	return notFound();
-}
-
-async function loadData(
-	ev: ServerEvent,
-	url: URL,
-	handler: RouteHandler,
-	functionName: string,
-	params: Record<string, any>,
-) {
-	const serverEndPoint: ServerEndPoint | undefined = (await handler.endPoint()).default;
-	// `functionName` is computed from the request method, so the handlers are
-	// accessed through a loose record
-	const handlers = serverEndPoint as unknown as Record<string, ServerRequest | undefined>;
-	const handlerFn: ServerRequest | undefined = handlers?.[functionName];
-	if (serverEndPoint && handlerFn) {
-		// Route params come from the URL, so a failed validation means the
-		// resource doesn't exist
-		try {
-			params = await validateEndpointParams(serverEndPoint, params);
-		} catch (error) {
-			if (error instanceof ValidationError) return notFound();
-			throw error;
-		}
-
-		try {
-			// If the endpoint declares a schema for this handler, validate its
-			// input up front and reject with 422 if it fails. get/head schemas
-			// validate the query string; other schemas validate the json body
-			const schema = endpointSchema(serverEndPoint, functionName);
-			const values = await validateHandlerInput(schema, functionName, url, ev);
-
-			const serverParams = buildServerParams(ev, url, params, values);
-
-			const serverHooks = await loadServerHooks(handler);
-			let entered = 0;
-			let enterResponse: Response | undefined = undefined;
-			try {
-				// Hooks run from the root down; a hook's enter can return a
-				// Response to short-circuit the request
-				for (; entered < serverHooks.length && !enterResponse; entered++) {
-					const hookResult = await serverHooks[entered].enter?.(serverParams);
-					if (hookResult) {
-						enterResponse = hookResult;
-					}
-				}
-
-				const result = enterResponse || (await handlerFn(serverParams));
-
-				// If there was no response returned from load (such as errors or a
-				// redirect), send an ok response
-				return result || ok();
-			} finally {
-				// Run exit hooks in reverse order for hooks that were entered
-				while (entered > 0) {
-					entered--;
-					await serverHooks[entered].exit?.(serverParams);
-				}
-			}
-		} catch (error) {
-			const response = validationErrorResponse(error);
-			if (response) return response;
-			throw error;
-		}
-	}
-
-	return notFound();
-}
-
-async function loadView(
-	ev: ServerEvent,
-	url: URL,
-	handler: RouteHandler,
-	params: Record<string, any>,
-	template: string,
-) {
-	// There must be a client endpoint with a component
-	const clientEndPoint: PageEndPoint | undefined = (await handler.endPoint()).default;
-	if (!clientEndPoint?.component) {
-		return notFound();
-	}
-
-	// There may be a server endpoint
-	const serverEndPoint: PageServerEndPoint | undefined =
-		handler.serverEndPoint && (await handler.serverEndPoint())?.default;
-
-	// Validate the route params and the load query against the server
-	// endpoint's schemas, if it declares any. Params come from the URL, so a
-	// failed validation means the resource doesn't exist; a failed query
-	// returns like any other load failure
-	let query: unknown;
-	if (serverEndPoint) {
-		try {
-			params = await validateEndpointParams(serverEndPoint, params);
-		} catch (error) {
-			if (error instanceof ValidationError) return notFound();
-			throw error;
-		}
-		const loadSchema = endpointSchema(serverEndPoint, "load");
-		if (loadSchema) {
-			try {
-				query = await validate(loadSchema, searchParamsToRecord(url.searchParams));
-			} catch (error) {
-				const response = validationErrorResponse(error);
-				if (response) return response;
-				throw error;
-			}
-		}
-	}
-
-	// Maybe hit the server hooks
-	const serverParams = buildServerParams(ev, url, params, query ? { query } : {});
-	const serverHooks = await loadServerHooks(handler);
-	let entered = 0;
-	let enterResponse: Response | undefined = undefined;
-	try {
-		// Hooks run from the root down; a hook's enter can return a Response
-		// to short-circuit the request
-		for (; entered < serverHooks.length && !enterResponse; entered++) {
-			const hookResult = await serverHooks[entered].enter?.(serverParams);
-			if (hookResult) {
-				enterResponse = hookResult;
-			}
-		}
-		if (enterResponse) {
-			return enterResponse;
-		}
-
-		// Pass the data into $props
-		// TODO: Promise.all
-		// NOTE: We're loading data from top to bottom, overriding as we go, and I'm not sure if this is the best way to go
-		let data = {};
-		if (handler.layouts) {
-			for (let layout of handler.layouts) {
-				const layoutEndPoint: PageEndPoint | undefined = (await layout.endPoint())?.default;
-				const layoutServerEndPoint: PageServerEndPoint | undefined =
-					layout.serverEndPoint && (await layout.serverEndPoint())?.default;
-				const layoutResponse = await loadClientAndServerData(
-					url,
-					params,
-					serverParams,
-					data,
-					layoutEndPoint,
-					layoutServerEndPoint,
-				);
-				if (layoutResponse?.ok === false) {
-					return layoutResponse;
-				}
-			}
-		}
-		let endPointResponse = await loadClientAndServerData(
-			url,
-			params,
-			serverParams,
-			data,
-			clientEndPoint,
-			serverEndPoint,
-		);
-		if (endPointResponse?.ok === false) {
-			return endPointResponse;
-		}
-		let $props: Record<string, any> = { data };
-
-		let styles = "";
-
-		// If there are layouts, work our way upwards, pushing each component into
-		// the default slot of its parent
-		// TODO: Also handle layout server data
-		// TODO: There's probably a nicer way to do this with reducers or something
-		let component = clientEndPoint.component as ServerComponent;
-		let slots: Record<string, ServerSlotRender> | undefined = undefined;
-		if (handler.layouts) {
-			let slotFunctions: ServerSlotRender[] = [];
-			slotFunctions[handler.layouts.length] = (_, $context) => {
-				let { body, head } = (clientEndPoint.component as ServerComponent)($props, $context);
-				styles += head;
-				return body;
-			};
-			for (let i = handler.layouts.length - 1; i >= 0; i--) {
-				const layoutEndPoint: PageEndPoint | undefined = (await handler.layouts[i].endPoint())
-					?.default;
-				if (layoutEndPoint?.component) {
-					if (i === 0) {
-						component = layoutEndPoint.component as ServerComponent;
-						slots = { _: slotFunctions[i + 1] };
-					} else {
-						slotFunctions[i] = (_, $context) => {
-							let { body, head } = (layoutEndPoint.component as ServerComponent)($props, $context, {
-								_: slotFunctions[i + 1],
-							});
-							styles += head;
-							return body;
-						};
-					}
-				}
-			}
-		}
-
-		let html;
-		try {
-			let { body, head } = component($props, undefined, slots);
-			styles += head;
-			html = template.replace("%COMPONENT_BODY%", body).replace("%COMPONENT_HEAD%", styles);
-		} catch (error) {
-			// TODO: Show a proper Error component
-			html = '<span style="color: red">Script syntax error</span><p>' + error + "</p>";
-			console.log(error);
-		}
-
-		return new Response(html, {
-			status: 200,
-			headers: {
-				"Content-Type": "text/html",
-			},
-		});
-	} finally {
-		// Run exit hooks in reverse order for hooks that were entered
-		while (entered > 0) {
-			entered--;
-			await serverHooks[entered].exit?.(serverParams);
-		}
-	}
-}
-
-async function runAction(
-	ev: ServerEvent,
-	url: URL,
-	handler: RouteHandler,
-	serverEndPoint: PageServerEndPoint | undefined,
-	params: Record<string, any>,
-	query: URLSearchParams,
-) {
-	const actionName = (Array.from(query.keys())[0] || "default").replace(/^\//, "");
-	if (serverEndPoint?.actions) {
-		const action = serverEndPoint.actions[actionName];
-		if (action) {
-			if (actionName === "load" || actionName === "params") {
-				// These names are reserved in the endpoint's schema map: `load`
-				// validates the query string and `params` the route params, so
-				// an action with one of these names would get the wrong schema
-				// applied to its form data
-				throw new Error(
-					`The action name "${actionName}" is reserved. ` +
-						`Rename the action (and its schema key, if any), e.g. to "save".`,
-				);
-			}
-			// TODO: form.errors etc
-			// Route params come from the URL, so a failed validation means the
-			// resource doesn't exist
-			try {
-				params = await validateEndpointParams(serverEndPoint, params);
-			} catch (error) {
-				if (error instanceof ValidationError) return notFound();
-				throw error;
-			}
-
-			let result: Response | undefined | void;
-			try {
-				// If the endpoint declares a schema for this action, validate the
-				// submitted form data up front and reject with 422 if it fails
-				const schema = endpointSchema(serverEndPoint, actionName);
-				const form = schema
-					? await validate(schema, await formDataToRecord(ev.request))
-					: undefined;
-
-				const serverParams = buildServerParams(ev, url, params, form ? { form } : {});
-
-				const serverHooks = await loadServerHooks(handler);
-				let entered = 0;
-				let enterResponse: Response | undefined = undefined;
-				try {
-					// Hooks run from the root down; a hook's enter can return a
-					// Response to short-circuit the action
-					for (; entered < serverHooks.length && !enterResponse; entered++) {
-						const hookResult = await serverHooks[entered].enter?.(serverParams);
-						if (hookResult) {
-							enterResponse = hookResult;
-						}
-					}
-
-					result = enterResponse || (await action(serverParams));
-				} finally {
-					// Run exit hooks in reverse order for hooks that were entered
-					while (entered > 0) {
-						entered--;
-						await serverHooks[entered].exit?.(serverParams);
-					}
-				}
-			} catch (error) {
-				const response = validationErrorResponse(error);
-				if (response) return response;
-				throw error;
-			}
-
-			// 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, any>,
-	serverParams: ServerLoadEvent,
-	data: Record<string, any>,
-	clientEndPoint?: PageEndPoint,
-	serverEndPoint?: PageServerEndPoint,
-) {
-	if (clientEndPoint?.load) {
-		const clientParams = buildClientParams(url, params, data);
-		const clientResponse = await clientEndPoint.load(clientParams);
-		if (clientResponse) {
-			if (clientResponse.ok) {
-				if (clientResponse.headers.get("Content-Type")?.includes("application/json")) {
-					Object.assign(data, await clientResponse.json());
-				}
-			} else {
-				return clientResponse;
-			}
-		}
-	}
-	if (serverEndPoint?.load) {
-		const serverResponse = await serverEndPoint.load(serverParams);
-		if (serverResponse) {
-			if (serverResponse.ok) {
-				if (serverResponse.headers.get("Content-Type")?.includes("application/json")) {
-					Object.assign(data, await serverResponse.json());
-				}
-			} else {
-				return serverResponse;
-			}
-		}
-	}
-}
-
-function buildClientParams(url: URL, params: Record<string, any>, data: Record<string, any>) {
-	return {
-		url,
-		params,
-		data,
-	};
-}
-
-/**
- * Loads the route's server hooks, from the root down
- */
-async function loadServerHooks(handler: RouteHandler): Promise<ServerHook[]> {
-	const hooks: ServerHook[] = [];
-	if (handler.serverHooks) {
-		for (let serverHook of handler.serverHooks) {
-			hooks.push((await serverHook()).default);
-		}
-	}
-	return hooks;
-}
-
-function buildServerParams(
-	ev: ServerEvent,
-	url: URL,
-	params: Record<string, any>,
-	values: { json?: unknown; form?: unknown; query?: unknown } = {},
-): ServerLoadEvent {
-	return {
-		url,
-		params,
-		appData: {},
-		request: ev.request,
-		// The inputs may have been validated already, in which case the request
-		// body has been consumed and the parsed values are returned instead.
-		// Their types come from the endpoint's schemas, so they are loosely
-		// typed here
-		json: (): Promise<any> =>
-			values.json !== undefined ? Promise.resolve(values.json) : ev.json(),
-		form: (): Promise<any> =>
-			values.form !== undefined ? Promise.resolve(values.form) : formDataToRecord(ev.request),
-		query: (): Promise<any> =>
-			values.query !== undefined
-				? Promise.resolve(values.query)
-				: Promise.resolve(searchParamsToRecord(url.searchParams)),
-		cookies: ev.cookies,
-		headers: ev.headers,
-		adapter: ev.adapter,
-	};
-}

package/src/test.ts

@@ -1,3 +0,0 @@
-import runTest from "./test/runTest";
-
-export { runTest };

package/src/types/Adapter.ts

@@ -1,20 +0,0 @@
-import type { Plugin } from "vite";
-import Server from "../server/Server";
-import Site from "../site/Site";
-
-export default interface Adapter {
-	prebuild?: (site: Site) => Promise<void> | void;
-	postbuild?: (site: Site) => Promise<void> | void;
-	/**
-	 * Vite plugin(s) used to drive dev mode. The adapter owns where server code
-	 * runs (e.g. the default Node runtime, or workerd via miniflare) and how
-	 * requests reach it. When omitted, the framework's default Node-runtime dev
-	 * plugin is used.
-	 */
-	dev?: (site: Site) => Plugin | Plugin[] | void;
-	/**
-	 * Serve the built output (preview). Receives a torpor Server configured to
-	 * load the built server entry.
-	 */
-	serve: (server: Server, site: Site) => void;
-}

package/src/types/ClientState.ts

@@ -1,8 +0,0 @@
-import Router from "../site/Router";
-import type LayoutPath from "./LayoutPath";
-
-export default interface ClientState {
-	router: Router;
-	layoutStack: LayoutPath[];
-	prefetchedData: Record<string, any>;
-}

package/src/types/InternalState.ts

@@ -1,7 +0,0 @@
-import type ClientState from "./ClientState";
-import type PageState from "./PageState";
-
-export default interface InternalState {
-	$page: PageState;
-	client: ClientState;
-}

package/src/types/Jsonify.ts

@@ -1,20 +0,0 @@
-/**
- * The JSON-serialized form of a type: what a value looks like after a
- * JSON.stringify / JSON.parse round trip. Dates become strings, functions and
- * undefined properties are dropped.
- */
-export type Jsonify<T> = T extends string | number | boolean | null
-	? T
-	: T extends undefined | ((...args: any[]) => any)
-		? never
-		: T extends Date
-			? string
-			: T extends Array<infer Item>
-				? Array<Jsonify<Item>>
-				: T extends object
-					? {
-							[Key in keyof T as T[Key] extends undefined | ((...args: any[]) => any)
-								? never
-								: Key]: Jsonify<T[Key]>;
-						}
-					: T;

package/src/types/LayoutHandler.ts

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

package/src/types/LayoutPath.ts

@@ -1,10 +0,0 @@
-// Store the current layout stack, so that we can re-use parts of it as necessary
-export default interface LayoutPath {
-	path: string;
-	/** Whether to re-use this layout */
-	reuse: boolean;
-	/** Data loaded from endpoints that should be re-used */
-	data: any;
-	/** The range of the UI in this layout's slot */
-	slotRegion: any;
-}

package/src/types/ManifestRoute.ts

@@ -1,6 +0,0 @@
-export default interface ManifestRoute {
-	path: string;
-	type: number;
-	endPoint: () => Promise<any>;
-	subFolder: string | undefined;
-}