blumenjs 0.1.7 → 0.2.0

package/dist/templates/app/shared/RouterContext.tsx

@@ -16,6 +16,7 @@ import React, {
 	useRef,
 } from "react";
 import { matchRoute, type RouteDef } from "./router";
+import { BlumenErrorBoundary } from "./ErrorBoundary";
 
 // ── Context types ──────────────────────────────────────────────
 
@@ -169,7 +170,9 @@ export function RouterProvider({
 			<div
 				className={`page-transition ${transitioning ? "page-transition-exit" : "page-transition-active"}`}
 			>
-				<App Component={PageComponent} pageProps={pageProps} />
+				<BlumenErrorBoundary>
+					<App Component={PageComponent} pageProps={pageProps} />
+				</BlumenErrorBoundary>
 			</div>
 		</RouterContext.Provider>
 	);

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

@@ -0,0 +1,147 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"sync"
+	"time"
+)
+
+// CacheEntry represents a single cached page response.
+type CacheEntry struct {
+	HTML       string
+	ETag       string
+	CreatedAt  time.Time
+	Revalidate int // TTL in seconds; 0 = cache forever until evicted
+	Stale      bool
+}
+
+// PageCache is a thread-safe in-memory LRU cache for rendered HTML pages.
+// It uses sync.RWMutex for maximum concurrent read performance —
+// thousands of goroutines can read simultaneously while writes are serialized.
+type PageCache struct {
+	mu       sync.RWMutex
+	entries  map[string]*CacheEntry
+	order    []string // LRU order: most recently used at end
+	maxSize  int
+}
+
+// NewPageCache creates a new cache with the given maximum number of entries.
+func NewPageCache(maxSize int) *PageCache {
+	return &PageCache{
+		entries: make(map[string]*CacheEntry),
+		order:   make([]string, 0, maxSize),
+		maxSize: maxSize,
+	}
+}
+
+// Get retrieves a cached page. Returns the entry and whether it was found.
+// Also returns whether the entry is stale (past its revalidate TTL).
+func (c *PageCache) Get(key string) (entry *CacheEntry, found bool, stale bool) {
+	c.mu.RLock()
+	e, ok := c.entries[key]
+	c.mu.RUnlock()
+
+	if !ok {
+		return nil, false, false
+	}
+
+	// Check if the entry has expired
+	if e.Revalidate > 0 {
+		age := time.Since(e.CreatedAt).Seconds()
+		if age > float64(e.Revalidate) {
+			return e, true, true // Found but stale
+		}
+	}
+
+	// Move to end of LRU order (most recently used)
+	c.mu.Lock()
+	c.moveToEnd(key)
+	c.mu.Unlock()
+
+	return e, true, false
+}
+
+// Set stores a page in the cache with the given revalidation TTL.
+func (c *PageCache) Set(key string, html string, revalidate int) {
+	etag := generateETag(html)
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	// If entry exists, update it
+	if _, exists := c.entries[key]; exists {
+		c.entries[key] = &CacheEntry{
+			HTML:       html,
+			ETag:       etag,
+			CreatedAt:  time.Now(),
+			Revalidate: revalidate,
+		}
+		c.moveToEnd(key)
+		return
+	}
+
+	// Evict LRU entry if at capacity
+	if len(c.entries) >= c.maxSize && len(c.order) > 0 {
+		oldest := c.order[0]
+		c.order = c.order[1:]
+		delete(c.entries, oldest)
+	}
+
+	// Add new entry
+	c.entries[key] = &CacheEntry{
+		HTML:       html,
+		ETag:       etag,
+		CreatedAt:  time.Now(),
+		Revalidate: revalidate,
+	}
+	c.order = append(c.order, key)
+}
+
+// Invalidate removes a specific key from the cache.
+func (c *PageCache) Invalidate(key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	delete(c.entries, key)
+	for i, k := range c.order {
+		if k == key {
+			c.order = append(c.order[:i], c.order[i+1:]...)
+			break
+		}
+	}
+}
+
+// Clear removes all entries from the cache.
+func (c *PageCache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.entries = make(map[string]*CacheEntry)
+	c.order = make([]string, 0, c.maxSize)
+}
+
+// Size returns the current number of cached entries.
+func (c *PageCache) Size() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return len(c.entries)
+}
+
+// moveToEnd moves a key to the end of the LRU order (most recently used).
+// Must be called with the write lock held.
+func (c *PageCache) moveToEnd(key string) {
+	for i, k := range c.order {
+		if k == key {
+			c.order = append(c.order[:i], c.order[i+1:]...)
+			c.order = append(c.order, key)
+			return
+		}
+	}
+}
+
+// generateETag creates an ETag from the HTML content.
+func generateETag(content string) string {
+	hash := sha256.Sum256([]byte(content))
+	return `"` + hex.EncodeToString(hash[:8]) + `"`
+}

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

@@ -0,0 +1,200 @@
+package main
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"image"
+	"image/jpeg"
+	"image/png"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"golang.org/x/image/draw"
+)
+
+const (
+	imageCacheDir  = ".blumen/image-cache"
+	maxImageWidth  = 4096
+	defaultQuality = 80
+)
+
+func init() {
+	// Ensure cache directory exists
+	os.MkdirAll(imageCacheDir, 0755)
+}
+
+// ImageHandler serves optimized images with on-the-fly resizing and caching.
+// URL: /_blumen/image?src=/static/hero.jpg&w=800&q=80&blur=1
+func ImageHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		q := r.URL.Query()
+		src := q.Get("src")
+		widthStr := q.Get("w")
+		qualityStr := q.Get("q")
+		isBlur := q.Get("blur") == "1"
+
+		if src == "" {
+			http.Error(w, "Missing 'src' parameter", http.StatusBadRequest)
+			return
+		}
+
+		// Parse width
+		targetWidth := 0
+		if widthStr != "" {
+			var err error
+			targetWidth, err = strconv.Atoi(widthStr)
+			if err != nil || targetWidth <= 0 || targetWidth > maxImageWidth {
+				http.Error(w, "Invalid 'w' parameter", http.StatusBadRequest)
+				return
+			}
+		}
+
+		// Parse quality
+		quality := defaultQuality
+		if qualityStr != "" {
+			var err error
+			quality, err = strconv.Atoi(qualityStr)
+			if err != nil || quality < 1 || quality > 100 {
+				quality = defaultQuality
+			}
+		}
+
+		// Security: resolve the source path and ensure it's within the project
+		cleanSrc := strings.TrimPrefix(src, "/")
+		absPath, err := filepath.Abs(cleanSrc)
+		if err != nil {
+			http.Error(w, "Invalid path", http.StatusBadRequest)
+			return
+		}
+
+		// Ensure path is within the project directory
+		cwd, _ := os.Getwd()
+		if !strings.HasPrefix(absPath, cwd) {
+			http.Error(w, "Access denied", http.StatusForbidden)
+			return
+		}
+
+		// Check if file exists
+		if _, err := os.Stat(absPath); os.IsNotExist(err) {
+			http.Error(w, "Image not found", http.StatusNotFound)
+			return
+		}
+
+		// Generate cache key
+		cacheKey := generateCacheKey(src, targetWidth, quality, isBlur)
+		cachePath := filepath.Join(imageCacheDir, cacheKey+".jpg")
+
+		// Check disk cache
+		if cachedData, err := os.ReadFile(cachePath); err == nil {
+			serveCachedImage(w, cachedData)
+			return
+		}
+
+		// Process the image
+		processedData, err := processImage(absPath, targetWidth, quality, isBlur)
+		if err != nil {
+			log.Printf("Image processing error: %v", err)
+			http.ServeFile(w, r, absPath)
+			return
+		}
+
+		// Write to disk cache
+		os.WriteFile(cachePath, processedData, 0644)
+
+		// Serve the processed image
+		serveCachedImage(w, processedData)
+	}
+}
+
+func generateCacheKey(src string, width, quality int, blur bool) string {
+	data := fmt.Sprintf("%s-%d-%d-%v", src, width, quality, blur)
+	hash := sha256.Sum256([]byte(data))
+	return hex.EncodeToString(hash[:16])
+}
+
+func serveCachedImage(w http.ResponseWriter, data []byte) {
+	w.Header().Set("Content-Type", "image/jpeg")
+	w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
+	w.Header().Set("X-Blumen-Image", "optimized")
+	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+	w.WriteHeader(http.StatusOK)
+	w.Write(data)
+}
+
+func processImage(filePath string, targetWidth, quality int, blur bool) ([]byte, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("open image: %w", err)
+	}
+	defer file.Close()
+
+	img, format, err := image.Decode(file)
+	if err != nil {
+		return nil, fmt.Errorf("decode image (%s): %w", format, err)
+	}
+
+	bounds := img.Bounds()
+	origWidth := bounds.Dx()
+	origHeight := bounds.Dy()
+
+	// Calculate target dimensions maintaining aspect ratio
+	newWidth := origWidth
+	newHeight := origHeight
+
+	if targetWidth > 0 && targetWidth < origWidth {
+		ratio := float64(targetWidth) / float64(origWidth)
+		newWidth = targetWidth
+		newHeight = int(float64(origHeight) * ratio)
+	}
+
+	// Resize using high-quality bilinear interpolation
+	resized := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
+	draw.BiLinear.Scale(resized, resized.Bounds(), img, bounds, draw.Over, nil)
+
+	// For blur placeholders, downscale aggressively
+	var finalImg image.Image = resized
+	if blur {
+		blurWidth := 20
+		if newWidth < blurWidth {
+			blurWidth = newWidth
+		}
+		blurHeight := int(float64(newHeight) * (float64(blurWidth) / float64(newWidth)))
+		if blurHeight < 1 {
+			blurHeight = 1
+		}
+		blurred := image.NewRGBA(image.Rect(0, 0, blurWidth, blurHeight))
+		draw.BiLinear.Scale(blurred, blurred.Bounds(), resized, resized.Bounds(), draw.Over, nil)
+		finalImg = blurred
+	}
+
+	// Encode to JPEG
+	var buf bytes.Buffer
+
+	jpegQuality := quality
+	if blur {
+		jpegQuality = 30
+	}
+
+	err = jpeg.Encode(&buf, finalImg, &jpeg.Options{Quality: jpegQuality})
+	if err != nil {
+		return nil, fmt.Errorf("encode jpeg: %w", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// Ensure PNG decoder is registered
+func init() {
+	_ = png.Decode
+}

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

@@ -11,9 +11,14 @@ import (
 )
 
 const (
-	nodeSSRURL = "http://localhost:4000/render"
+	nodeSSRURL  = "http://localhost:4000/render"
+	nodeDataURL = "http://localhost:4000/data"
 )
 
+// Global page cache — stores rendered HTML in Go memory for near-instant responses.
+// Max 500 entries with LRU eviction. A single Go server can cache the entire site.
+var pageCache = NewPageCache(500)
+
 // SSRResponse from Node service
 type SSRResponse struct {
 	HTML  string                 `json:"html"`
@@ -28,6 +33,21 @@ type SSRRequest struct {
 	Data   map[string]interface{} `json:"data,omitempty"`
 }
 
+// DataRequest to Node /data endpoint
+type DataRequest struct {
+	Path    string                 `json:"path"`
+	Query   map[string][]string    `json:"query"`
+	Params  map[string]interface{} `json:"params"`
+	Headers map[string]string      `json:"headers,omitempty"`
+}
+
+// DataResponse from Node /data endpoint
+type DataResponse struct {
+	Props          map[string]interface{} `json:"props"`
+	HasServerProps bool                   `json:"hasServerProps"`
+	Revalidate     int                    `json:"revalidate"` // TTL in seconds
+}
+
 var httpClient = &http.Client{
 	Timeout: 10 * time.Second,
 }
@@ -35,8 +55,20 @@ var httpClient = &http.Client{
 func main() {
 	mux := http.NewServeMux()
 
-	// Static files are served directly — must be registered first
-	mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
+	// Static files with immutable cache headers
+	staticHandler := http.StripPrefix("/static/", http.FileServer(http.Dir("static")))
+	mux.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
+		// Set aggressive cache headers for static assets
+		w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
+		w.Header().Set("X-Blumen-Cache", "STATIC")
+		staticHandler.ServeHTTP(w, r)
+	})
+
+	// Image optimization endpoint - processes and caches images on the fly
+	mux.HandleFunc("/_blumen/image", ImageHandler())
+
+	// Cache management endpoint (for development/debugging)
+	mux.HandleFunc("/_blumen/cache", cacheStatusHandler)
 
 	// Specific routes with Go loaders for data fetching
 	mux.HandleFunc("/dashboard/settings", PageHandler(func(r *http.Request) (map[string]interface{}, error) {
@@ -46,16 +78,9 @@ func main() {
 		}, nil
 	}))
 
-	mux.HandleFunc("/users/{id}", PageHandler(func(r *http.Request) (map[string]interface{}, error) {
-		id := r.PathValue("id")
-		return map[string]interface{}{
-			"userId":      id,
-			"userProfile": "Profile data for user " + id + " fetched from Go db",
-		}, nil
-	}))
-
 	// Catch-all: forward every other request to the Node SSR server.
-	// This decouples Go from knowing about specific React page paths.
+	// If the page exports getServerProps, Node will fetch the data first.
+	// If a Go DataLoader is registered above, it takes priority.
 	mux.HandleFunc("/", PageHandler(nil))
 
 	startPort := 3000
@@ -73,6 +98,7 @@ func main() {
 	}
 
 	log.Printf("Go server starting on http://localhost:%d", startPort)
+	log.Printf("Page cache initialized (max %d entries)", 500)
 	if err := http.Serve(listener, mux); err != nil {
 		log.Fatalf("Server error: %v", err)
 	}
@@ -87,33 +113,114 @@ func PageHandler(loader DataLoader) http.HandlerFunc {
 			return
 		}
 
-		var props map[string]interface{}
-		var err error
-		if loader != nil {
-			props, err = loader(r)
-			if err != nil {
-				log.Printf("Loader error: %v", err)
-				http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		// Generate cache key from the full URL (path + query string)
+		cacheKey := r.URL.RequestURI()
+
+		// Check the page cache first
+		if entry, found, stale := pageCache.Get(cacheKey); found {
+			// Handle ETag conditional request
+			if match := r.Header.Get("If-None-Match"); match == entry.ETag {
+				w.Header().Set("X-Blumen-Cache", "HIT")
+				w.WriteHeader(http.StatusNotModified)
 				return
 			}
-		}
 
-		// If this is a SPA data fetch request, return JSON props
-		if r.Header.Get("X-Blumen-Data") == "1" || r.URL.Query().Get("_data") == "1" {
-			w.Header().Set("Content-Type", "application/json")
-			if props == nil {
-				props = make(map[string]interface{})
+			if !stale {
+				// CACHE HIT: serve directly from Go memory (sub-millisecond)
+				serveCachedPage(w, entry, "HIT")
+				return
 			}
-			json.NewEncoder(w).Encode(props)
+
+			// STALE: serve stale content immediately, revalidate in background
+			serveCachedPage(w, entry, "STALE")
+
+			// Background revalidation (fire and forget)
+			go func() {
+				html, revalidate := renderPage(r, loader)
+				if html != "" {
+					pageCache.Set(cacheKey, html, revalidate)
+				}
+			}()
+			return
+		}
+
+		// CACHE MISS: render the page and cache the result
+		html, revalidate := renderPage(r, loader)
+		if html == "" {
+			// renderPage already wrote the error response
 			return
 		}
 
-		handleRouteWithProps(w, r, props)
+		// Cache the rendered page
+		pageCache.Set(cacheKey, html, revalidate)
+
+		// Serve the fresh response
+		entry, _, _ := pageCache.Get(cacheKey)
+		if entry != nil {
+			serveCachedPage(w, entry, "MISS")
+		} else {
+			// Fallback: serve directly without cache metadata
+			writeHTMLResponse(w, html, "MISS", "")
+		}
+	}
+}
+
+// serveCachedPage writes a cached page response with proper headers.
+func serveCachedPage(w http.ResponseWriter, entry *CacheEntry, cacheStatus string) {
+	writeHTMLResponse(w, entry.HTML, cacheStatus, entry.ETag)
+}
+
+// writeHTMLResponse writes an HTML response with cache and security headers.
+func writeHTMLResponse(w http.ResponseWriter, html string, cacheStatus string, etag string) {
+	// Security headers
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.Header().Set("X-Frame-Options", "DENY")
+	w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
+
+	// Cache headers
+	w.Header().Set("X-Blumen-Cache", cacheStatus)
+	if etag != "" {
+		w.Header().Set("ETag", etag)
 	}
+	// Tell browsers and CDNs they can cache for 10s, serve stale for 60s while revalidating
+	w.Header().Set("Cache-Control", "public, s-maxage=10, stale-while-revalidate=60")
+
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(html))
 }
 
-func handleRouteWithProps(w http.ResponseWriter, r *http.Request, props map[string]interface{}) {
-	// Prepare SSR request
+// renderPage performs the full SSR pipeline: fetch data + render HTML.
+// Returns the HTML string and the revalidation TTL in seconds.
+func renderPage(r *http.Request, loader DataLoader) (string, int) {
+	var props map[string]interface{}
+	var err error
+	revalidate := 0
+
+	if loader != nil {
+		// Use Go DataLoader (takes priority over getServerProps)
+		props, err = loader(r)
+		if err != nil {
+			log.Printf("Loader error: %v", err)
+			return "", 0
+		}
+	} else {
+		// No Go DataLoader - check if the page has getServerProps
+		tsProps, tsRevalidate, tsErr := fetchServerProps(r)
+		if tsErr != nil {
+			log.Printf("getServerProps error: %v", tsErr)
+			// Non-fatal: render the page without server props
+		} else if tsProps != nil {
+			props = tsProps
+			revalidate = tsRevalidate
+		}
+	}
+
+	// If this is a SPA data fetch request, return JSON props (don't cache)
+	// This check shouldn't happen in renderPage since it's called from the handler,
+	// but the handler already handles this case before reaching here.
+
+	// Call Node SSR to render the HTML
 	ssrReq := SSRRequest{
 		Path:  r.URL.Path,
 		Query: r.URL.Query(),
@@ -124,24 +231,64 @@ func handleRouteWithProps(w http.ResponseWriter, r *http.Request, props map[stri
 		Data: props,
 	}
 
-	// Call Node SSR service
 	ssrResp, err := callNodeSSR(ssrReq)
 	if err != nil {
 		log.Printf("SSR error: %v", err)
-		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		return
+		return "", 0
 	}
 
+	return ssrResp.HTML, revalidate
+}
 
+// fetchServerProps calls the Node SSR /data endpoint to run getServerProps.
+// Returns nil if the page doesn't export getServerProps.
+// Also returns the revalidate TTL (0 = no caching from getServerProps).
+func fetchServerProps(r *http.Request) (map[string]interface{}, int, error) {
+	// Build a subset of headers to forward
+	headers := make(map[string]string)
+	for _, key := range []string{"Authorization", "Cookie", "Accept-Language", "User-Agent"} {
+		if val := r.Header.Get(key); val != "" {
+			headers[key] = val
+		}
+	}
 
-	// Security headers
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	w.Header().Set("X-Content-Type-Options", "nosniff")
-	w.Header().Set("X-Frame-Options", "DENY")
-	w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
+	dataReq := DataRequest{
+		Path:    r.URL.Path,
+		Query:   r.URL.Query(),
+		Params:  map[string]interface{}{},
+		Headers: headers,
+	}
 
-	w.WriteHeader(http.StatusOK)
-	w.Write([]byte(ssrResp.HTML))
+	reqBody, err := json.Marshal(dataReq)
+	if err != nil {
+		return nil, 0, fmt.Errorf("marshal data request: %w", err)
+	}
+
+	resp, err := httpClient.Post(
+		nodeDataURL,
+		"application/json",
+		bytes.NewReader(reqBody),
+	)
+	if err != nil {
+		return nil, 0, fmt.Errorf("http post /data: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, 0, fmt.Errorf("node /data returned %d", resp.StatusCode)
+	}
+
+	var dataResp DataResponse
+	if err := json.NewDecoder(resp.Body).Decode(&dataResp); err != nil {
+		return nil, 0, fmt.Errorf("decode data response: %w", err)
+	}
+
+	if !dataResp.HasServerProps {
+		// Page doesn't export getServerProps, skip
+		return nil, 0, nil
+	}
+
+	return dataResp.Props, dataResp.Revalidate, nil
 }
 
 func callNodeSSR(req SSRRequest) (*SSRResponse, error) {
@@ -172,4 +319,25 @@ func callNodeSSR(req SSRRequest) (*SSRResponse, error) {
 	return &ssrResp, nil
 }
 
-
+// cacheStatusHandler provides cache introspection for debugging.
+// GET /_blumen/cache — returns current cache size and status
+// DELETE /_blumen/cache — clears the entire cache
+func cacheStatusHandler(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"size":    pageCache.Size(),
+			"maxSize": 500,
+			"status":  "active",
+		})
+	case http.MethodDelete:
+		pageCache.Clear()
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"message": "Cache cleared",
+		})
+	default:
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+	}
+}