@torpor/build 0.0.5 → 0.1.0

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

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) {
+		this.headers.set(name, value);
+	}
+
+	delete(name: string) {
+		this.headers.delete(name);
+	}
+}

package/src/server/Server.ts

@@ -0,0 +1,119 @@
+import pathToRegex from "../site/pathToRegex";
+import type MiddlewareFunction from "../types/MiddlewareFunction";
+import ServerEvent from "./ServerEvent";
+import type ServerFunction from "./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));
+		return this;
+	}
+
+	match(path: string) {
+		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;
+	}
+}
+
+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;
+//	}
+//}

package/src/server/ServerEvent.ts

@@ -0,0 +1,33 @@
+import CookieHelper from "./CookieHelper";
+import HeaderHelper from "./HeaderHelper";
+
+export default class ServerEvent {
+	request: Request;
+	response?: Response;
+	// TODO: Should we cast types??
+	params?: { [key: string]: string };
+
+	cookies: CookieHelper;
+	headers: HeaderHelper;
+
+	constructor(request: Request, params?: { [key: string]: string }) {
+		this.request = request;
+		this.params = params;
+		this.cookies = new CookieHelper(request);
+		this.headers = new HeaderHelper(request);
+	}
+
+	addHeaders() {
+		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/ServerFunction.ts

@@ -0,0 +1,5 @@
+import ServerEvent from "./ServerEvent";
+
+type ServerFunction = (e: ServerEvent) => Response | Promise<Response | undefined> | undefined;
+
+export default ServerFunction;

package/src/server/contentType.ts

@@ -0,0 +1,85 @@
+// From https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types
+
+export default function contentType(extension: string) {
+	return types[extension] || "application/octet-stream";
+}
+
+const types: Record<string, string> = {
+	".aac": "audio/aac",
+	".abw": "application/x-abiword",
+	".apng": "image/apng",
+	".arc": "application/x-freearc",
+	".avif": "image/avif",
+	".avi": "video/x-msvideo",
+	".azw": "application/vnd.amazon.ebook",
+	".bin": "application/octet-stream",
+	".bmp": "image/bmp",
+	".bz": "application/x-bzip",
+	".bz2": "application/x-bzip2",
+	".cda": "application/x-cdf",
+	".csh": "application/x-csh",
+	".css": "text/css",
+	".csv": "text/csv",
+	".doc": "application/msword",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".eot": "application/vnd.ms-fontobject",
+	".epub": "application/epub+zip",
+	".gz": "application/gzip",
+	".gif": "image/gif",
+	".htm": "text/html",
+	".html": "text/html",
+	".ico": "image/vnd.microsoft.icon",
+	".ics": "text/calendar",
+	".jar": "application/java-archive",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".js": "text/javascript",
+	".json": "application/json",
+	".jsonld": "application/ld+json",
+	".mid": "audio/midi",
+	".midi": "audio/midi",
+	".mjs": "text/javascript",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".mpeg": "video/mpeg",
+	".mpkg": "application/vnd.apple.installer+xml",
+	".odp": "application/vnd.oasis.opendocument.presentation",
+	".ods": "application/vnd.oasis.opendocument.spreadsheet",
+	".odt": "application/vnd.oasis.opendocument.text",
+	".oga": "audio/ogg",
+	".ogv": "video/ogg",
+	".ogx": "application/ogg",
+	".opus": "audio/ogg",
+	".otf": "font/otf",
+	".png": "image/png",
+	".pdf": "application/pdf",
+	".php": "application/x-httpd-php",
+	".ppt": "application/vnd.ms-powerpoint",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	".rar": "application/vnd.rar",
+	".rtf": "application/rtf",
+	".sh": "application/x-sh",
+	".svg": "image/svg+xml",
+	".tar": "application/x-tar",
+	".tif": "image/tiff",
+	".tiff": "image/tiff",
+	".ts": "video/mp2t",
+	".ttf": "font/ttf",
+	".txt": "text/plain",
+	".vsd": "application/vnd.visio",
+	".wav": "audio/wav",
+	".weba": "audio/webm",
+	".webm": "video/webm",
+	".webp": "image/webp",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".xhtml": "application/xhtml+xml",
+	".xls": "application/vnd.ms-excel",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	".xml": "application/xml",
+	".xul": "application/vnd.mozilla.xul+xml",
+	".zip": "application/zip",
+	".3gp": "video/3gpp",
+	".3g2": "video/3gpp2",
+	".7z": "application/x-7z-compressed",
+};

package/src/site/Router.ts

@@ -0,0 +1,136 @@
+import type LayoutHandler from "../types/LayoutHandler";
+import type ManifestRoute from "../types/ManifestRoute";
+import type RouteHandler from "../types/RouteHandler";
+import pathToRegex from "./pathToRegex";
+
+export default class Router {
+	routes: Route[] = [];
+	//pages = new Map<string, PageEndPoint>();
+
+	constructor() {}
+
+	//add(path: string, file: string) {
+	//	// TODO: Call the specific addX method based on the file path
+	//	this.addPage(route, file);
+	//}
+
+	addPages(routes: ManifestRoute[]) {
+		for (let r of routes) {
+			this.routes.push(
+				new Route(r.path, {
+					path: r.path,
+					type: r.type,
+					endPoint: r.endPoint,
+				}),
+			);
+		}
+		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>) {
+		//this.server.get(route, (ev) => this.loadPage(ev, file));
+		this.routes.push(
+			new Route(path, {
+				path,
+				type,
+				endPoint,
+			}),
+		);
+		return this;
+	}
+
+	/*
+	loadPage(ev: ServerEvent, file: string): Response {
+		let page = this.pages.get(file);
+		if (!page) {
+			page = {};
+			this.pages.set(file, page);
+		}
+	}
+	*/
+
+	match(path: string, query: URLSearchParams) {
+		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,
+				};
+			}
+		}
+
+		console.log(`not found: '${path}'`);
+	}
+
+	loadHandler(handler: RouteHandler, path: string) {
+		////handler.endPoint = import(handler.path);
+		handler.layouts = this.findLayouts(path);
+		handler.serverEndPoint = this.findServer(path);
+		handler.serverHook = this.findServerHook(path);
+	}
+
+	findLayouts(path: string): LayoutHandler[] | undefined {
+		let layouts: LayoutHandler[] = [];
+		let parts = path
+			// Strip the trailing`~/server` (so we don't look for `~/server/_layout`
+			// 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 `/_layout`,
+			// `/first/_layout` and `/second/_layout`
+			.split("/");
+		let basePath = "";
+		for (let i = 0; i < parts.length; i++) {
+			if (i > 0) {
+				basePath += "/" + parts[i];
+			}
+			const layoutPath = basePath + "/_layout";
+			const layoutRoute = this.routes.find((r) => r.path === layoutPath);
+			if (layoutRoute) {
+				layouts.push({
+					path: layoutPath,
+					endPoint: layoutRoute.handler.endPoint,
+					serverEndPoint: this.findServer(layoutPath),
+				});
+			}
+		}
+		return layouts.length ? layouts : undefined;
+	}
+
+	findServer(path: string): (() => Promise<any>) | undefined {
+		const serverPath = path.replace(/\/$/, "") + "/~server";
+		const serverRoute = this.routes.find((r) => r.path === serverPath);
+		return serverRoute && serverRoute.handler.endPoint;
+	}
+
+	findServerHook(path: string): (() => Promise<any>) | undefined {
+		// TODO: Should this be a collection, like layouts?
+		let serverHookPath = "/_hook/~server";
+		// HACK: Generalise this
+		if (path.startsWith("/api/")) {
+			serverHookPath = "/api" + serverHookPath;
+		}
+		const serverHookRoute = this.routes.find((r) => r.path === serverHookPath);
+		return serverHookRoute && serverHookRoute.handler.endPoint;
+	}
+}
+
+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/Routerx.ts

@@ -0,0 +1,67 @@
+import ServerFunction from "../server/ServerFunction";
+import type HttpMethod from "../types/HttpMethod";
+import type MiddlewareFunction from "../types/MiddlewareFunction";
+import pathToRegex from "./pathToRegex";
+
+// This is not actually used anywhere, for now at least
+
+export default class Router {
+	methods = 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) {
+		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;
+	}
+}