@pracht/adapter-node 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,39 @@
+import { ISGManifestEntry, ModuleRegistry, PrachtApp, ResolvedApiRoute } from "@pracht/core";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { PrachtAdapter } from "@pracht/vite-plugin";
+
+//#region src/index.d.ts
+interface NodeAdapterContextArgs {
+  request: Request;
+  req: IncomingMessage;
+  res: ServerResponse;
+}
+interface NodeAdapterOptions<TContext = unknown> {
+  app: PrachtApp;
+  registry?: ModuleRegistry;
+  staticDir?: string;
+  viteManifest?: unknown;
+  isgManifest?: Record<string, ISGManifestEntry>;
+  apiRoutes?: ResolvedApiRoute[];
+  clientEntryUrl?: string;
+  cssUrls?: string[];
+  cssManifest?: Record<string, string[]>;
+  jsManifest?: Record<string, string[]>;
+  createContext?: (args: NodeAdapterContextArgs) => TContext | Promise<TContext>;
+}
+interface NodeServerEntryModuleOptions {
+  port?: number;
+}
+declare function createNodeRequestHandler<TContext = unknown>(options: NodeAdapterOptions<TContext>): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+declare function createNodeServerEntryModule(options?: NodeServerEntryModuleOptions): string;
+/**
+ * Create a pracht adapter for Node.js.
+ *
+ * ```ts
+ * import { nodeAdapter } from "@pracht/adapter-node";
+ * pracht({ adapter: nodeAdapter() })
+ * ```
+ */
+declare function nodeAdapter(options?: NodeServerEntryModuleOptions): PrachtAdapter;
+//#endregion
+export { NodeAdapterContextArgs, NodeAdapterOptions, NodeServerEntryModuleOptions, createNodeRequestHandler, createNodeServerEntryModule, nodeAdapter };

package/dist/index.mjs

@@ -0,0 +1,204 @@
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { applyDefaultSecurityHeaders, handlePrachtRequest } from "@pracht/core";
+//#region src/index.ts
+function createNodeRequestHandler(options) {
+	const isgManifest = options.isgManifest ?? {};
+	const staticDir = options.staticDir;
+	return async (req, res) => {
+		let request;
+		try {
+			request = await createWebRequest(req);
+		} catch (err) {
+			if (err instanceof Error && err.message === "Request body too large") {
+				res.statusCode = 413;
+				res.end("Payload Too Large");
+				return;
+			}
+			throw err;
+		}
+		const url = new URL(request.url);
+		if (staticDir && request.method === "GET" && url.pathname in isgManifest) {
+			const entry = isgManifest[url.pathname];
+			const htmlPath = url.pathname === "/" ? join(staticDir, "index.html") : join(staticDir, url.pathname, "index.html");
+			if (existsSync(htmlPath)) {
+				const stat = statSync(htmlPath);
+				const ageMs = Date.now() - stat.mtimeMs;
+				const isStale = entry.revalidate.kind === "time" && ageMs > entry.revalidate.seconds * 1e3;
+				const html = await readFile(htmlPath, "utf-8");
+				res.statusCode = 200;
+				applyDefaultSecurityHeaders(new Headers({
+					"content-type": "text/html; charset=utf-8",
+					"x-pracht-isg": isStale ? "stale" : "fresh"
+				})).forEach((value, key) => {
+					res.setHeader(key, value);
+				});
+				res.end(html);
+				if (isStale) regenerateISGPage(options, url.pathname, htmlPath).catch((err) => {
+					console.error(`ISG regeneration failed for ${url.pathname}:`, err);
+				});
+				return;
+			}
+		}
+		const context = options.createContext ? await options.createContext({
+			request,
+			req,
+			res
+		}) : void 0;
+		const response = await handlePrachtRequest({
+			app: options.app,
+			context,
+			registry: options.registry,
+			request,
+			apiRoutes: options.apiRoutes,
+			clientEntryUrl: options.clientEntryUrl,
+			cssManifest: options.cssManifest,
+			jsManifest: options.jsManifest
+		});
+		if (staticDir && request.method === "GET" && url.pathname in isgManifest && response.status === 200) {
+			const html = await response.clone().text();
+			const htmlPath = url.pathname === "/" ? join(staticDir, "index.html") : join(staticDir, url.pathname, "index.html");
+			mkdirSync(dirname(htmlPath), { recursive: true });
+			writeFileSync(htmlPath, html, "utf-8");
+		}
+		await writeWebResponse(res, response);
+	};
+}
+async function regenerateISGPage(options, pathname, htmlPath) {
+	const url = new URL(pathname, "http://localhost");
+	const request = new Request(url, { method: "GET" });
+	const response = await handlePrachtRequest({
+		app: options.app,
+		registry: options.registry,
+		request,
+		clientEntryUrl: options.clientEntryUrl,
+		cssManifest: options.cssManifest,
+		jsManifest: options.jsManifest
+	});
+	if (response.status === 200) {
+		const html = await response.text();
+		mkdirSync(dirname(htmlPath), { recursive: true });
+		writeFileSync(htmlPath, html, "utf-8");
+	}
+}
+function createNodeServerEntryModule(options = {}) {
+	return [
+		"import { existsSync, readFileSync } from \"node:fs\";",
+		"import { createServer } from \"node:http\";",
+		"import { dirname, resolve } from \"node:path\";",
+		"import { fileURLToPath, pathToFileURL } from \"node:url\";",
+		"import { createNodeRequestHandler } from \"@pracht/adapter-node\";",
+		"",
+		"const serverDir = dirname(fileURLToPath(import.meta.url));",
+		"const staticDir = resolve(serverDir, \"../client\");",
+		"const isgManifestPath = resolve(serverDir, \"isg-manifest.json\");",
+		"const isgManifest = existsSync(isgManifestPath)",
+		"  ? JSON.parse(readFileSync(isgManifestPath, \"utf-8\"))",
+		"  : {};",
+		"",
+		"export const handler = createNodeRequestHandler({",
+		"  app: resolvedApp,",
+		"  registry,",
+		"  staticDir,",
+		"  isgManifest,",
+		"  apiRoutes,",
+		"  clientEntryUrl: clientEntryUrl ?? undefined,",
+		"  cssManifest,",
+		"  jsManifest,",
+		"});",
+		"",
+		"const entryHref = process.argv[1] ? pathToFileURL(process.argv[1]).href : null;",
+		"if (entryHref && import.meta.url === entryHref) {",
+		"  const server = createServer(handler);",
+		`  const port = Number(process.env.PORT ?? ${options.port ?? 3e3});`,
+		"  server.listen(port, () => {",
+		"    console.log(`pracht node server listening on http://localhost:${port}`);",
+		"  });",
+		"}",
+		""
+	].join("\n");
+}
+async function createWebRequest(req) {
+	const protocol = getFirstHeaderValue(req.headers["x-forwarded-proto"]) ?? "http";
+	const host = getFirstHeaderValue(req.headers.host) ?? "localhost";
+	const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+	const method = req.method ?? "GET";
+	const init = {
+		headers: createHeaders(req.headers),
+		method
+	};
+	if (!BODYLESS_METHODS.has(method.toUpperCase())) {
+		const body = await readRequestBody(req);
+		if (body.byteLength > 0) {
+			const exactBody = new Uint8Array(body.byteLength);
+			exactBody.set(body);
+			init.body = exactBody.buffer;
+		}
+	}
+	return new Request(url, init);
+}
+function createHeaders(headers) {
+	const result = new Headers();
+	for (const [key, value] of Object.entries(headers)) {
+		if (typeof value === "undefined") continue;
+		if (Array.isArray(value)) {
+			for (const entry of value) result.append(key, entry);
+			continue;
+		}
+		result.set(key, value);
+	}
+	return result;
+}
+const MAX_BODY_SIZE = 1024 * 1024;
+async function readRequestBody(req) {
+	const chunks = [];
+	let totalSize = 0;
+	for await (const chunk of req) {
+		const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+		totalSize += buf.byteLength;
+		if (totalSize > MAX_BODY_SIZE) {
+			req.destroy();
+			throw new Error("Request body too large");
+		}
+		chunks.push(buf);
+	}
+	return Buffer.concat(chunks);
+}
+async function writeWebResponse(res, response) {
+	res.statusCode = response.status;
+	res.statusMessage = response.statusText;
+	response.headers.forEach((value, key) => {
+		res.setHeader(key, value);
+	});
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	const body = Buffer.from(await response.arrayBuffer());
+	res.end(body);
+}
+function getFirstHeaderValue(value) {
+	if (Array.isArray(value)) return value[0];
+	return value;
+}
+const BODYLESS_METHODS = new Set(["GET", "HEAD"]);
+/**
+* Create a pracht adapter for Node.js.
+*
+* ```ts
+* import { nodeAdapter } from "@pracht/adapter-node";
+* pracht({ adapter: nodeAdapter() })
+* ```
+*/
+function nodeAdapter(options = {}) {
+	return {
+		id: "node",
+		serverImports: "import { resolveApp, resolveApiRoutes } from \"@pracht/core\";",
+		createServerEntryModule() {
+			return createNodeServerEntryModule(options);
+		}
+	};
+}
+//#endregion
+export { createNodeRequestHandler, createNodeServerEntryModule, nodeAdapter };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pracht/adapter-node",
+  "version": "0.0.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@pracht/core": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}