blumenjs 0.2.2 → 0.2.4

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

@@ -0,0 +1,203 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+)
+
+// ─── Redirects & Rewrites Engine ───────────────────────────────
+// Declarative URL routing configured via blumen.routes.json.
+// Processed at the Go layer for zero-overhead URL manipulation.
+
+// RedirectRule defines a URL redirect.
+type RedirectRule struct {
+	Source      string `json:"source"`      // Source path pattern (e.g. "/old", "/blog/:slug")
+	Destination string `json:"destination"` // Destination URL
+	Permanent   bool   `json:"permanent"`   // 301 (permanent) or 307 (temporary)
+}
+
+// RewriteRule defines a URL rewrite (internal, transparent to browser).
+type RewriteRule struct {
+	Source      string `json:"source"`      // Source path pattern
+	Destination string `json:"destination"` // Internal destination path
+}
+
+// RoutesConfig holds all redirect and rewrite rules.
+type RoutesConfig struct {
+	Redirects []RedirectRule `json:"redirects"`
+	Rewrites  []RewriteRule  `json:"rewrites"`
+}
+
+// compiledRedirect is a pre-compiled redirect rule for fast matching.
+type compiledRedirect struct {
+	pattern     *regexp.Regexp
+	paramNames  []string
+	destination string
+	permanent   bool
+}
+
+// compiledRewrite is a pre-compiled rewrite rule for fast matching.
+type compiledRewrite struct {
+	pattern     *regexp.Regexp
+	paramNames  []string
+	destination string
+}
+
+// RoutesEngine processes redirects and rewrites.
+type RoutesEngine struct {
+	redirects []compiledRedirect
+	rewrites  []compiledRewrite
+}
+
+// LoadRoutesConfig reads the routes config from blumen.routes.json.
+func LoadRoutesConfig(path string) (*RoutesConfig, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	var config RoutesConfig
+	if err := json.Unmarshal(data, &config); err != nil {
+		return nil, err
+	}
+
+	return &config, nil
+}
+
+// NewRoutesEngine compiles redirect and rewrite rules for fast matching.
+func NewRoutesEngine(config *RoutesConfig) *RoutesEngine {
+	engine := &RoutesEngine{}
+
+	for _, r := range config.Redirects {
+		pattern, params := compileRoutePattern(r.Source)
+		engine.redirects = append(engine.redirects, compiledRedirect{
+			pattern:     pattern,
+			paramNames:  params,
+			destination: r.Destination,
+			permanent:   r.Permanent,
+		})
+	}
+
+	for _, r := range config.Rewrites {
+		pattern, params := compileRoutePattern(r.Source)
+		engine.rewrites = append(engine.rewrites, compiledRewrite{
+			pattern:     pattern,
+			paramNames:  params,
+			destination: r.Destination,
+		})
+	}
+
+	return engine
+}
+
+// compileRoutePattern converts a route pattern like "/blog/:slug" or "/old/*"
+// into a compiled regex and extracts parameter names.
+func compileRoutePattern(source string) (*regexp.Regexp, []string) {
+	var paramNames []string
+	regexStr := "^"
+
+	parts := strings.Split(source, "/")
+	for _, part := range parts {
+		if part == "" {
+			continue
+		}
+
+		regexStr += "/"
+
+		if part == "*" {
+			// Wildcard: match everything
+			regexStr += "(.*)"
+			paramNames = append(paramNames, "*")
+		} else if strings.HasPrefix(part, ":") {
+			// Named parameter: match path segment
+			paramName := strings.TrimPrefix(part, ":")
+			paramNames = append(paramNames, paramName)
+			regexStr += "([^/]+)"
+		} else {
+			// Literal match
+			regexStr += regexp.QuoteMeta(part)
+		}
+	}
+
+	regexStr += "$"
+	return regexp.MustCompile(regexStr), paramNames
+}
+
+// interpolateDestination replaces :param placeholders in the destination
+// with matched values from the source pattern.
+func interpolateDestination(destination string, paramNames []string, matches []string) string {
+	result := destination
+	for i, name := range paramNames {
+		if i+1 < len(matches) {
+			if name == "*" {
+				result = strings.ReplaceAll(result, ":splat", matches[i+1])
+			} else {
+				result = strings.ReplaceAll(result, ":"+name, matches[i+1])
+			}
+		}
+	}
+	return result
+}
+
+// RedirectsMiddleware creates a middleware that processes redirects and rewrites.
+func RedirectsMiddleware(engine *RoutesEngine) MiddlewareFunc {
+	return func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+		path := r.URL.Path
+
+		// Check redirects first (external, browser follows)
+		for _, redirect := range engine.redirects {
+			matches := redirect.pattern.FindStringSubmatch(path)
+			if matches != nil {
+				dest := interpolateDestination(redirect.destination, redirect.paramNames, matches)
+				status := http.StatusTemporaryRedirect // 307
+				if redirect.permanent {
+					status = http.StatusMovedPermanently // 301
+				}
+				http.Redirect(w, r, dest, status)
+				return
+			}
+		}
+
+		// Check rewrites (internal, transparent to browser)
+		for _, rewrite := range engine.rewrites {
+			matches := rewrite.pattern.FindStringSubmatch(path)
+			if matches != nil {
+				dest := interpolateDestination(rewrite.destination, rewrite.paramNames, matches)
+				r.URL.Path = dest
+				next(w, r)
+				return
+			}
+		}
+
+		// No match — continue to handler
+		next(w, r)
+	}
+}
+
+// SetupRedirects loads the routes config and registers the middleware.
+// Returns the number of rules loaded, or -1 if no config file exists.
+func SetupRedirects(chain *MiddlewareChain, configPath string) int {
+	config, err := LoadRoutesConfig(configPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return -1 // No config file — not an error
+		}
+		log.Printf("⚠ Failed to load routes config: %v", err)
+		return 0
+	}
+
+	total := len(config.Redirects) + len(config.Rewrites)
+	if total == 0 {
+		return 0
+	}
+
+	engine := NewRoutesEngine(config)
+	chain.Use(RedirectsMiddleware(engine))
+
+	log.Printf("🔀 Loaded %d redirect(s) and %d rewrite(s)", len(config.Redirects), len(config.Rewrites))
+	return total
+}

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

@@ -342,8 +342,9 @@ async function handleRender(
 		};
 
 		// Render React to HTML
-		// Wrap in the same page-transition div that the client-side
-		// RouterProvider renders, so hydration trees match exactly.
+		// Must match the client's INITIAL hydration tree exactly:
+		//   div.page-transition > App
+		// (Client adds Suspense/ErrorBoundary AFTER hydration via useEffect)
 		const appElement = React.createElement(
 			"div",
 			{ className: "page-transition page-transition-active" },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blumenjs",
-	"version": "0.2.2",
+	"version": "0.2.4",
 	"description": "The React framework powered by Go. Lightning-fast SSR with the DX you deserve.",
 	"type": "module",
 	"bin": {