blumenjs 0.2.1 → 0.2.3

package/dist/templates/go-server/ssg.go

@@ -0,0 +1,230 @@
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// ─── Static Site Generation (SSG) Server ───────────────────────
+// Serves pre-rendered HTML pages directly from disk.
+// Supports Incremental Static Regeneration (ISR) — pages can be
+// revalidated in the background on a configurable timer.
+
+// SSGPage tracks a pre-rendered page with ISR metadata.
+type SSGPage struct {
+	FilePath   string
+	Route      string
+	Revalidate int       // TTL in seconds; 0 = never revalidate
+	LastRender time.Time // When the page was last rendered
+	IsStale    bool      // Set true when revalidation is in progress
+}
+
+// SSGServer manages pre-rendered static pages with ISR.
+type SSGServer struct {
+	pages     map[string]*SSGPage
+	staticDir string
+	mu        sync.RWMutex
+}
+
+// SSGManifest matches the format written by ssg-prerender.ts
+type SSGManifest struct {
+	Pages []SSGManifestPage `json:"pages"`
+}
+
+type SSGManifestPage struct {
+	Route             string `json:"route"`
+	ComponentId       string `json:"componentId"`
+	HasGetServerProps bool   `json:"hasGetServerProps"`
+	HasGetStaticProps bool   `json:"hasGetStaticProps"`
+	HasGetStaticPaths bool   `json:"hasGetStaticPaths"`
+	Revalidate        int    `json:"revalidate"`
+}
+
+// NewSSGServer loads the SSG manifest and maps routes to HTML files.
+func NewSSGServer(staticDir string) *SSGServer {
+	server := &SSGServer{
+		pages:     make(map[string]*SSGPage),
+		staticDir: staticDir,
+	}
+
+	manifestPath := filepath.Join(staticDir, "manifest.json")
+	data, err := os.ReadFile(manifestPath)
+	if err != nil {
+		return server // No manifest — return empty server
+	}
+
+	// Try the new format (SSGManifest with full metadata)
+	var manifest SSGManifest
+	if err := json.Unmarshal(data, &manifest); err == nil && len(manifest.Pages) > 0 {
+		for _, page := range manifest.Pages {
+			filePath := server.routeToFilePath(page.Route)
+			if _, err := os.Stat(filePath); err == nil {
+				server.pages[page.Route] = &SSGPage{
+					FilePath:   filePath,
+					Route:      page.Route,
+					Revalidate: page.Revalidate,
+					LastRender: time.Now(),
+				}
+			}
+		}
+	} else {
+		// Fall back to the old format (simple string array)
+		var routes []string
+		if err := json.Unmarshal(data, &routes); err != nil {
+			log.Printf("⚠ SSG manifest parse error: %v", err)
+			return server
+		}
+		for _, route := range routes {
+			filePath := server.routeToFilePath(route)
+			if _, err := os.Stat(filePath); err == nil {
+				server.pages[route] = &SSGPage{
+					FilePath:   filePath,
+					Route:      route,
+					Revalidate: 0,
+					LastRender: time.Now(),
+				}
+			}
+		}
+	}
+
+	if len(server.pages) > 0 {
+		isrCount := 0
+		for _, p := range server.pages {
+			if p.Revalidate > 0 {
+				isrCount++
+			}
+		}
+		log.Printf("📄 SSG: %d pre-rendered page(s) loaded", len(server.pages))
+		if isrCount > 0 {
+			log.Printf("🔄 ISR: %d page(s) with revalidation enabled", isrCount)
+		}
+	}
+
+	return server
+}
+
+func (s *SSGServer) routeToFilePath(route string) string {
+	if route == "/" {
+		return filepath.Join(s.staticDir, "index.html")
+	}
+	return filepath.Join(s.staticDir, strings.TrimPrefix(route, "/"), "index.html")
+}
+
+// HasPage checks if a route has a pre-rendered page.
+func (s *SSGServer) HasPage(route string) bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	_, ok := s.pages[route]
+	return ok
+}
+
+// ServePage serves a pre-rendered HTML page with ISR support.
+// Returns true if the page was served, false if not found.
+func (s *SSGServer) ServePage(w http.ResponseWriter, r *http.Request) bool {
+	s.mu.RLock()
+	page, ok := s.pages[r.URL.Path]
+	s.mu.RUnlock()
+
+	if !ok {
+		return false
+	}
+
+	// Read the pre-rendered HTML
+	html, err := os.ReadFile(page.FilePath)
+	if err != nil {
+		return false
+	}
+
+	// Check if ISR revalidation is needed
+	if page.Revalidate > 0 {
+		age := time.Since(page.LastRender)
+		ttl := time.Duration(page.Revalidate) * time.Second
+
+		if age > ttl && !page.IsStale {
+			// Mark as stale and trigger background revalidation
+			s.mu.Lock()
+			page.IsStale = true
+			s.mu.Unlock()
+
+			go s.revalidatePage(page)
+			w.Header().Set("X-Blumen-Cache", "STALE")
+		} else {
+			w.Header().Set("X-Blumen-Cache", "SSG")
+		}
+		w.Header().Set("X-Blumen-Revalidate", string(rune(page.Revalidate)))
+	} else {
+		w.Header().Set("X-Blumen-Cache", "SSG")
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("Cache-Control", "public, max-age=3600, stale-while-revalidate=86400")
+	w.WriteHeader(http.StatusOK)
+	w.Write(html)
+	return true
+}
+
+// revalidatePage re-renders a static page in the background via the Node SSR server.
+func (s *SSGServer) revalidatePage(page *SSGPage) {
+	defer func() {
+		s.mu.Lock()
+		page.IsStale = false
+		s.mu.Unlock()
+	}()
+
+	log.Printf("🔄 ISR: Revalidating %s", page.Route)
+
+	// Call the Node SSR server to re-render
+	body := `{"path":"` + page.Route + `","query":{},"params":{}}`
+	resp, err := http.Post("http://localhost:4000/render", "application/json", strings.NewReader(body))
+	if err != nil {
+		log.Printf("⚠ ISR revalidation failed for %s: %v", page.Route, err)
+		return
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("⚠ ISR revalidation read failed for %s: %v", page.Route, err)
+		return
+	}
+
+	var ssrResp struct {
+		HTML string `json:"html"`
+	}
+	if err := json.Unmarshal(respBody, &ssrResp); err != nil || ssrResp.HTML == "" {
+		log.Printf("⚠ ISR revalidation parse failed for %s", page.Route)
+		return
+	}
+
+	// Atomic write: write to temp file, then rename
+	tmpFile := page.FilePath + ".tmp"
+	if err := os.WriteFile(tmpFile, []byte(ssrResp.HTML), 0644); err != nil {
+		log.Printf("⚠ ISR write failed for %s: %v", page.Route, err)
+		return
+	}
+	if err := os.Rename(tmpFile, page.FilePath); err != nil {
+		log.Printf("⚠ ISR rename failed for %s: %v", page.Route, err)
+		return
+	}
+
+	// Update metadata
+	s.mu.Lock()
+	page.LastRender = time.Now()
+	s.mu.Unlock()
+
+	log.Printf("✅ ISR: Revalidated %s", page.Route)
+}
+
+// PageCount returns the number of pre-rendered pages.
+func (s *SSGServer) PageCount() int {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.pages)
+}

package/dist/templates/node-ssr/server.ts

@@ -1,15 +1,66 @@
 import * as http from "http";
-import { renderToString } from "react-dom/server";
+import * as fs from "fs";
+import * as path from "path";
+import { renderToString, renderToPipeableStream } from "react-dom/server";
 import React from "react";
 
 // Auto-generated route map (run `npm run routes` to regenerate)
-import { routes, App, Document, serverPropsMap, metadataMap, generateMetadataMap, layoutMetadataMap, layoutGenerateMetadataMap } from "./generated-routes";
+import { routes, App, Document, serverPropsMap, staticPropsMap, staticPathsMap, metadataMap, generateMetadataMap, layoutMetadataMap, layoutGenerateMetadataMap } from "./generated-routes";
 import { apiRoutes } from "./generated-api-routes";
 import { matchRoute } from "../app/shared/router";
 import { executeAction, getRegisteredActions } from "../app/shared/serverAction";
 import NotFoundPage from "../app/pages/NotFound";
 
 const NotFound = NotFoundPage;
+const isDev = process.env.NODE_ENV === "development";
+
+// ── Chunk Manifest (Production) ────────────────────────────────
+// Maps chunk names (e.g. "runtime", "vendor", "page-home") to their
+// hashed filenames (e.g. "/static/js/runtime.abc12345.js").
+// Generated by `blumen build` after the Webpack step.
+let chunkManifest: Record<string, string> = {};
+if (!isDev) {
+	try {
+		const manifestPath = path.resolve("dist/chunk-manifest.json");
+		if (fs.existsSync(manifestPath)) {
+			chunkManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+			console.log(`Chunk manifest loaded: ${Object.keys(chunkManifest).length} chunks`);
+		}
+	} catch (err) {
+		console.warn("Could not load chunk manifest:", err);
+	}
+}
+
+/**
+ * Resolve the list of <script> src URLs for a given page.
+ * Order: runtime → vendor → framework → main → page chunk
+ */
+function getScriptsForPage(routePath: string): string[] {
+	if (isDev) return []; // Dev mode: DefaultDocument handles its own scripts
+
+	const scripts: string[] = [];
+	// Core chunks in dependency order
+	for (const name of ["runtime", "vendor", "framework", "main"]) {
+		if (chunkManifest[name]) {
+			scripts.push(chunkManifest[name]);
+		}
+	}
+
+	// Page-specific chunk
+	// Convert route path to chunk name: "/docs" → "page-docs", "/users/[id]" → "page-users-id"
+	const chunkName = "page-" + (routePath === "/" ? "home" : routePath
+		.replace(/^\//, "")
+		.replace(/\/index$/, "")
+		.replace(/\[([^\]]+)\]/g, "$1")
+		.replace(/\//g, "-")
+		.toLowerCase());
+
+	if (chunkManifest[chunkName]) {
+		scripts.push(chunkManifest[chunkName]);
+	}
+
+	return scripts;
+}
 
 interface SSRRequest {
 	path: string;
@@ -61,12 +112,16 @@ const server = http.createServer(async (req, res) => {
 	// Route to the correct handler
 	if (req.url === "/data") {
 		return handleData(req, res);
+	} else if (req.url === "/stream-render") {
+		return handleStreamRender(req, res);
 	} else if (req.url === "/render") {
 		return handleRender(req, res);
 	} else if (req.url === "/api") {
 		return handleAPI(req, res);
 	} else if (req.url === "/action") {
 		return handleAction(req, res);
+	} else if (req.url === "/static-paths") {
+		return handleStaticPaths(req, res);
 	} else {
 		res.writeHead(404);
 		res.end(JSON.stringify({ error: "Not Found" }));
@@ -313,6 +368,7 @@ async function handleRender(
 			initialProps: props,
 			children: appElement,
 			metadata,
+			scripts: getScriptsForPage(routeDef?.path || ssrReq.path),
 		});
 
 		const html = "<!doctype html>\n" + renderToString(documentElement);
@@ -337,6 +393,135 @@ async function handleRender(
 	}
 }
 
+/**
+ * POST /stream-render — Streaming SSR
+ *
+ * Uses React 18's renderToPipeableStream to send HTML progressively.
+ * The shell (everything outside <Suspense>) arrives immediately.
+ * Data-dependent sections stream in as they resolve.
+ *
+ * Props are sent via X-Blumen-Props header (JSON-encoded)
+ * so Go can extract them for caching without parsing the HTML stream.
+ *
+ * Go proxies this stream directly to the browser using chunked
+ * transfer encoding for instant Time to First Byte.
+ */
+async function handleStreamRender(
+	req: http.IncomingMessage,
+	res: http.ServerResponse,
+) {
+	try {
+		const body = await readBody(req);
+		const ssrReq: SSRRequest = JSON.parse(body);
+
+		const match = matchRoute(ssrReq.path, routes);
+
+		if (!match) {
+			// No streaming for 404 — just use renderToString
+			const props = {
+				path: ssrReq.path,
+				status: 404,
+				serverRendered: true,
+			};
+			const element = React.createElement(
+				"div",
+				{ className: "page-transition page-transition-active" },
+				React.createElement(NotFound, props),
+			);
+			const html = renderToString(element);
+
+			res.writeHead(200, {
+				"Content-Type": "text/html; charset=utf-8",
+				"X-Blumen-Props": JSON.stringify(props),
+				"X-Blumen-Status": "404",
+			});
+			res.end("<!doctype html>\n" + html);
+			return;
+		}
+
+		// Prepare props
+		const props = {
+			...(ssrReq.data || {}),
+			path: ssrReq.path,
+			query: ssrReq.query,
+			params: { ...ssrReq.params, ...match.params },
+			timestamp: Date.now(),
+			serverRendered: true,
+		};
+
+		// Build the app element
+		const appElement = React.createElement(
+			"div",
+			{ className: "page-transition page-transition-active" },
+			React.createElement(App, {
+				Component: match.component,
+				pageProps: props,
+			}),
+		);
+
+		// Resolve metadata
+		const routeDef = routes.find(r => r.component === match.component);
+		const metadata = routeDef
+			? await resolveMetadata(routeDef.path, {
+					params: props.params || {},
+					query: ssrReq.query || {},
+					path: ssrReq.path,
+					headers: {},
+				})
+			: {};
+
+		// Build the full document element
+		const documentElement = React.createElement(Document, {
+			initialProps: props,
+			children: appElement,
+			metadata,
+			scripts: getScriptsForPage(routeDef?.path || ssrReq.path),
+		});
+
+		// Use renderToPipeableStream for progressive HTML streaming
+		const { pipe, abort } = renderToPipeableStream(documentElement, {
+			onShellReady() {
+				// Shell is ready — send headers and start streaming immediately.
+				// This is the key performance win: TTFB happens NOW,
+				// before data-dependent Suspense boundaries resolve.
+				res.writeHead(200, {
+					"Content-Type": "text/html; charset=utf-8",
+					"Transfer-Encoding": "chunked",
+					"X-Blumen-Props": JSON.stringify(props),
+					"X-Blumen-Streaming": "1",
+				});
+				// Write the doctype before piping React's output
+				res.write("<!doctype html>\n");
+				pipe(res);
+			},
+			onShellError(error) {
+				// Shell failed to render — fall back to error response
+				console.error("Streaming SSR shell error:", error);
+				res.writeHead(500, { "Content-Type": "text/html" });
+				res.end("<!doctype html><html><body><h1>Server Error</h1></body></html>");
+			},
+			onError(error) {
+				// Non-fatal error during streaming (e.g., a Suspense boundary failed)
+				// The stream continues — React will send the fallback UI
+				console.error("Streaming SSR error:", error);
+			},
+		});
+
+		// Safety timeout: abort streaming after 10 seconds
+		setTimeout(() => abort(), 10000);
+
+	} catch (error) {
+		console.error("Stream render error:", error);
+		if (!res.headersSent) {
+			res.writeHead(500);
+			res.end(JSON.stringify({
+				error: "Internal Server Error",
+				message: isDev ? String(error) : undefined,
+			}));
+		}
+	}
+}
+
 function readBody(req: http.IncomingMessage): Promise<string> {
 	return new Promise((resolve, reject) => {
 		let body = "";
@@ -469,6 +654,41 @@ async function handleAction(req: http.IncomingMessage, res: http.ServerResponse)
 	}
 }
 
+/**
+ * POST /static-paths — Resolve dynamic SSG routes.
+ *
+ * Called by the SSG prerender script to get the list of paths
+ * that a page with getStaticPaths should be pre-rendered for.
+ *
+ * Request:  { route: "/blog/[slug]" }
+ * Response: { paths: [{ params: { slug: "hello-world" } }, ...] }
+ */
+async function handleStaticPaths(req: http.IncomingMessage, res: http.ServerResponse) {
+	try {
+		const rawBody = await readBody(req);
+		const { route } = JSON.parse(rawBody) as { route: string };
+
+		const getStaticPaths = staticPathsMap[route];
+		if (!getStaticPaths) {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ paths: [] }));
+			return;
+		}
+
+		const result = await getStaticPaths();
+		const paths = result?.paths || [];
+
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ paths }));
+	} catch (error: any) {
+		console.error("getStaticPaths Error:", error);
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "getStaticPaths failed", message: error.message }));
+	}
+}
+
+// ─── Server Startup ──────────────────────────────────────────────
+
 server.listen(PORT, () => {
 	console.log(`Node SSR server running on http://localhost:${PORT}`);
 	const gspCount = Object.keys(serverPropsMap).length;