@moonsjs/vite 0.1.5 → 0.1.6

package/src/server/node-server.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer, type Server } from "node:http";
 import { extname, join, resolve, sep } from "node:path";
+import { revalidatePrerendered, shouldRevalidate } from "./isr";
 import { sendNodeResponse, toWebRequest } from "./node";
 import type { PluginRuntime } from "./plugins";
 import { installGracefulShutdown } from "./shutdown";
@@ -36,6 +37,8 @@ export interface NodeServerOptions {
   shutdownTimeoutMs?: number;
   /** Lifecycle plugin (Addendum B.4) — onStart/onReady/onShutdown. */
   plugins?: PluginRuntime;
+  /** Canary `leakTest.canary` untuk guard ISR (Addendum E.1). */
+  canary?: string;
 }
 
 /**
@@ -57,6 +60,7 @@ export function startNodeServer(
         if (req.method === "GET" || req.method === "HEAD") {
           const staticFile = resolveStaticFile(clientDir, url.pathname);
           if (staticFile !== null) {
+            scheduleRevalidation(staticFile, url.pathname, handler, options, clientDir);
             const body = readFileSync(staticFile);
             res.statusCode = 200;
             res.setHeader("content-type", MIME_TYPES[extname(staticFile).toLowerCase()] ?? "application/octet-stream");
@@ -125,7 +129,7 @@ export function resolveStaticFile(clientDir: string, pathname: string): string |
   //    statis — bukan shell `index.html` biasa (yang berarti bypass SSR).
   const normalized = decoded.length > 1 ? decoded.replace(/\/+$/, "") : decoded;
   const manifest = readPrerenderManifest(clientDir);
-  if (manifest.has(normalized)) {
+  if (manifest.paths.has(normalized)) {
     const target = normalized === "/" ? "index.html" : `${normalized.slice(1)}/index.html`;
     const candidate = safeWithin(clientDir, `./${target}`);
     if (candidate !== null && isFile(candidate)) {
@@ -148,22 +152,91 @@ function isFile(path: string): boolean {
   return existsSync(path) && statSync(path).isFile();
 }
 
-let prerenderManifestCache: { file: string; mtimeMs: number; paths: Set<string> } | null = null;
+export interface PrerenderManifestInfo {
+  paths: Set<string>;
+  revalidate: Map<string, number>;
+}
+
+let prerenderManifestCache:
+  | { file: string; mtimeMs: number; info: PrerenderManifestInfo }
+  | null = null;
 
-function readPrerenderManifest(clientDir: string): Set<string> {
+function readPrerenderManifest(clientDir: string): PrerenderManifestInfo {
   const file = join(clientDir, "_moons_prerender.json");
+  const empty: PrerenderManifestInfo = { paths: new Set(), revalidate: new Map() };
   try {
     const mtimeMs = statSync(file).mtimeMs;
-    if (prerenderManifestCache !== null && prerenderManifestCache.file === file && prerenderManifestCache.mtimeMs === mtimeMs) {
-      return prerenderManifestCache.paths;
+    if (
+      prerenderManifestCache !== null &&
+      prerenderManifestCache.file === file &&
+      prerenderManifestCache.mtimeMs === mtimeMs
+    ) {
+      return prerenderManifestCache.info;
+    }
+    const json = JSON.parse(readFileSync(file, "utf8")) as {
+      paths?: unknown;
+      version?: unknown;
+      entries?: unknown;
+    };
+    const paths = new Set<string>();
+    const revalidate = new Map<string, number>();
+    if (Array.isArray(json.paths)) {
+      // Manifest v1 (D.5) — tanpa revalidate.
+      for (const path of json.paths) {
+        if (typeof path === "string") {
+          paths.add(path);
+        }
+      }
     }
-    const json = JSON.parse(readFileSync(file, "utf8")) as { paths?: unknown };
-    const paths = new Set(
-      Array.isArray(json.paths) ? json.paths.filter((path): path is string => typeof path === "string") : [],
-    );
-    prerenderManifestCache = { file, mtimeMs, paths };
-    return paths;
+    if (Array.isArray(json.entries)) {
+      // Manifest v2 (E.1).
+      for (const entry of json.entries as Array<Record<string, unknown>>) {
+        if (entry === null || typeof entry !== "object" || typeof entry["path"] !== "string") {
+          continue;
+        }
+        const path = entry["path"] as string;
+        paths.add(path);
+        const seconds = entry["revalidate"];
+        if (typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0) {
+          revalidate.set(path, seconds);
+        }
+      }
+    }
+    const info = { paths, revalidate };
+    prerenderManifestCache = { file, mtimeMs, info };
+    return info;
   } catch {
-    return new Set();
+    return empty;
   }
 }
+
+/** ISR: jika file prerender kedaluwarsa, regenerasi background (SWR). */
+function scheduleRevalidation(
+  staticFile: string,
+  pathname: string,
+  handler: (request: Request) => Promise<Response>,
+  options: NodeServerOptions,
+  clientDir: string,
+): void {
+  const normalized = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+  const seconds = readPrerenderManifest(clientDir).revalidate.get(normalized);
+  if (seconds === undefined || seconds < 0) {
+    return;
+  }
+  let mtimeMs: number;
+  try {
+    mtimeMs = statSync(staticFile).mtimeMs;
+  } catch {
+    return;
+  }
+  if (!shouldRevalidate({ mtimeMs, revalidateSeconds: seconds })) {
+    return;
+  }
+  void revalidatePrerendered({
+    pathname: normalized,
+    file: staticFile,
+    handler,
+    ...(options.canary === undefined ? {} : { canary: options.canary }),
+  });
+}
+

package/src/server/prerender.ts

@@ -36,7 +36,7 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
   const env = options.env ?? process.env;
   let written = 0;
   let skipped = 0;
-  const writtenPaths: string[] = [];
+  const entries: Array<{ path: string; revalidate?: number }> = [];
 
   const pages = options.routes.filter((route) => route.kind === "page");
   for (const route of pages) {
@@ -47,6 +47,28 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
     }
     const module = (await load()) as RouteModule;
     const prerender = module.prerender;
+    const revalidate = module.revalidate;
+
+    // Addendum E.1: `revalidate` hanya sah bersama `prerender`.
+    if (revalidate !== undefined) {
+      if (
+        typeof revalidate !== "number" ||
+        !Number.isFinite(revalidate) ||
+        revalidate < 0 ||
+        prerender !== true
+      ) {
+        throw new MoonsError({
+          code: "E_ISR_INVALID",
+          file: route.file,
+          message: "`revalidate` tidak valid atau dipakai tanpa `prerender = true`",
+          details: "ISR berbasis file: `revalidate` (detik, number >= 0) + `prerender` (PRD Addendum E.1).",
+          suggestions: [
+            "Gunakan angka detik, mis. `export const revalidate = 60`",
+            "Tambahkan `export const prerender = true` pada page yang sama",
+          ],
+        });
+      }
+    }
 
     if (prerender !== true) {
       if (prerender !== undefined && prerender !== false) {
@@ -101,15 +123,19 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
       const file = outputFile(options.clientDir, pathname);
       mkdirSync(dirname(file), { recursive: true });
       writeFileSync(file, html);
-      writtenPaths.push(pathname);
+      entries.push(
+        typeof revalidate === "number" && revalidate >= 0
+          ? { path: pathname, revalidate }
+          : { path: pathname },
+      );
       written += 1;
     }
   }
 
-  // Manifest agar static server tahu path mana yang boleh dilayani statis.
+  // Manifest v2 (Addendum E.1): entries + revalidate; reader tetap menerima v1.
   writeFileSync(
     join(options.clientDir, PRERENDER_MANIFEST_FILE),
-    `${JSON.stringify({ paths: writtenPaths }, null, 2)}\n`,
+    `${JSON.stringify({ version: 2, entries }, null, 2)}\n`,
   );
 
   log(`[moons] prerender selesai: ${written} file (${skipped} dilewati)`);

package/src/transform.ts

@@ -1196,7 +1196,7 @@ export function checkRouteModuleExports(context: RouteExportCheckContext): void
       ? ["default", "loader"]
       : base === "_error.tsx" || base === "_404.tsx"
         ? ["default"]
-        : ["default", "loader", "meta", "prerender", "paths"];
+        : ["default", "loader", "meta", "prerender", "paths", "revalidate"];
   const allowedText = `Hanya ${allowed.map((name) => `\`${name}\``).join(", ")} yang boleh di-export.`;
   const relativeFile = toRelative(projectRoot, file);
   const ast = parseModule(code, file);