@torpor/build 0.4.14 → 1.0.0

package/src/site/manifest.ts

@@ -1,10 +1,20 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { Plugin } from "vite";
+import type { ResolvedOpenApiOptions } from "../openapi/types";
+import { OPEN_API_STATE_KEY } from "../openapi/plugin";
 import Site from "./Site";
+import { SERVER_ROUTE } from "../types/RouteType";
 
 const moduleId = "@torpor/build/manifest";
 
+const LOAD_EXPORT_RE =
+	/[{,]\s*load\s*[:(]|\bexport\s+(?:async\s+)?(?:function|const|let|var)\s+load\b|\bexport\s*\{[^}]*\bload\b/;
+
+export function hasLoadExport(source: string): boolean {
+	return LOAD_EXPORT_RE.test(source);
+}
+
 /**
  * A Vite plugin that provides information about the app to both clientEntry and
  * serverEntry.
@@ -24,27 +34,95 @@ export default function manifest(site: Site, server = false): Plugin {
 		load(id, viteOptions) {
 			if (id === moduleId) {
 				let serverRequest = server && !!viteOptions?.ssr;
+
+				// If there are inline endpoints, site plugins or an OpenAPI
+				// document, and we're building for the server, we need to import
+				// the config file to access them. On the client, the config file
+				// is never imported, keeping server code out of the client bundle.
+				const hasInline = site.routes.some((r) => r.endPoint && !r.file);
+				const hasPlugins = site.plugins.length > 0;
+				const hasOpenApi = site.pluginState.has(OPEN_API_STATE_KEY);
+				const configImport =
+					hasInline || hasPlugins || hasOpenApi
+						? serverRequest && site.configFile
+							? `import __site from ${JSON.stringify(site.configFile)};`
+							: ""
+						: "";
+
+				// Site plugins are run when the server starts up (in dev and in
+				// production), so that routes they register are available at
+				// runtime. Top-level await is fine here: this module is only
+				// loaded through Vite's SSR pipeline
+				const pluginLoop =
+					serverRequest && hasPlugins
+						? `for (const __plugin of __site.plugins ?? []) { await __plugin(__site); }`
+						: "";
+
+				// The OpenAPI document endpoint is generated code (rather than an
+				// inline endpoint) because it must load each route file -- which
+				// only works from module code that Vite processes/bundles. The
+				// options live in `site.pluginState` (set by the plugin), so they
+				// are available both here and in the generated runtime code
+				const openApiOptions = site.pluginState.get(OPEN_API_STATE_KEY) as
+					| ResolvedOpenApiOptions
+					| undefined;
+				const openApiGlue =
+					serverRequest && openApiOptions && site.configFile
+						? openApiGlueCode(site, openApiOptions)
+						: "";
+
+				const openApiRoute =
+					serverRequest && openApiOptions
+						? `{ path: ${JSON.stringify(openApiOptions.path)}, type: ${SERVER_ROUTE}, endPoint: () => Promise.resolve({ default: { get: __openApiGet } }), subFolder: undefined },`
+						: "";
+
 				return `
 ${!serverRequest ? "const load = { default: { load: true } };" : ""}
+${configImport}
+${pluginLoop}
+${openApiGlue}
 export default {
   routes: [
     ${site.routes
 			.map((r) => {
 				let endPoint: string;
-				if (serverRequest || !/server\.(ts|js)$/.test(r.file)) {
-					endPoint = `() => import(/* @vite-ignore */ "${path.join(site.root, r.file)}")`;
+				if (!r.file) {
+					// Inline endpoint (no file)
+					if (serverRequest) {
+						const key = `${r.path}:${r.type}`;
+						endPoint = `() => Promise.resolve({ default: __site.inlineEndPoints[${JSON.stringify(key)}] })`;
+					} else {
+						// Client-side stub: check if the inline
+						// endpoint has a load function
+						const haveLoad =
+							typeof (r.endPoint as Record<string, unknown> | undefined)?.load === "function";
+						endPoint = haveLoad ? "() => load" : "undefined";
+					}
+				} else if (serverRequest || !/server\.(ts|js)$/.test(r.file)) {
+					const filePath = path.join(site.root, r.file);
+					// NOTE: No `@vite-ignore` here, so that Vite processes the import:
+					// in dev the module runner transforms the file on the fly, and in
+					// a production build Rollup bundles the route into a chunk and
+					// rewrites the import -- leaving the raw source path in place
+					// would hand Node/wrangler `.ts`/`.torp` files it can't load
+					const importExpr = `() => import("${filePath}")`;
+					// A .torp file's default export is a component, so wrap it
+					// as a PageEndPoint ({ component }) for the entries
+					endPoint = r.file.endsWith(".torp")
+						? `${importExpr}.then((m) => ({ default: { component: m.default } }))`
+						: importExpr;
 				} else {
 					// On the client, for a server route, we need to check
 					// whether there's a load function and set a dummy endPoint
 					// if so. The correct endpoint will be hit in clientEntry
-					// HACK: Should do this better than checking for `load:` in source...
-					const haveLoad = readFileSync(path.join(site.root, r.file)).includes("load:");
+					const haveLoad = hasLoadExport(readFileSync(path.join(site.root, r.file), "utf8"));
 					endPoint = haveLoad ? "() => load" : "undefined";
 				}
 				const sub = r.subFolder ? `"${r.subFolder}"` : "undefined";
-				return `{ path: "${r.path}", type: ${r.type}, endPoint: ${endPoint}, subFolder: ${sub} }`;
+				return `{ path: "${r.path}", type: ${r.type}, endPoint: ${endPoint}, subFolder: ${sub} },`;
 			})
-			.join(",\n    ")}
+			.join("\n    ")}
+    ${openApiRoute}
   ],
 };
 `;
@@ -52,3 +130,44 @@ export default {
 		},
 	};
 }
+
+/**
+ * Generates the module code for the OpenAPI document endpoint: a map of
+ * route path to endpoint loader, and a cached handler that loads every
+ * endpoint and builds the document on first use.
+ */
+function openApiGlueCode(site: Site, options: ResolvedOpenApiOptions): string {
+	const loaders = site.routes
+		.filter((r) => r.type === SERVER_ROUTE)
+		// Don't document the docs page itself
+		.filter((r) => r.path !== options.docs)
+		.map((r) => {
+			if (!r.file) {
+				const key = `${r.path}:${r.type}`;
+				return `${JSON.stringify(r.path)}: () => Promise.resolve({ default: __site.inlineEndPoints[${JSON.stringify(key)}] })`;
+			}
+			const filePath = path.join(site.root, r.file);
+			return `${JSON.stringify(r.path)}: () => import(${JSON.stringify(filePath)})`;
+		})
+		.join(",\n    ");
+
+	return `
+import { buildOpenApiDocument, OPEN_API_STATE_KEY } from "@torpor/build/openapi";
+let __openApiDoc;
+const __openApiRoutes = {
+    ${loaders}
+};
+async function __openApiGet() {
+    if (!__openApiDoc) {
+        const __entries = [];
+        for (const [__path, __loader] of Object.entries(__openApiRoutes)) {
+            __entries.push({ path: __path, endPoint: (await __loader()).default });
+        }
+        __openApiDoc = buildOpenApiDocument(__entries, __site.pluginState.get(OPEN_API_STATE_KEY));
+    }
+    return new Response(JSON.stringify(__openApiDoc), {
+        headers: { "Content-Type": "application/json" },
+    });
+}
+`;
+}