@moonsjs/vite 0.1.10 → 0.1.12

package/src/plugin.ts

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { resolve as resolvePath } from "node:path";
+import { relative as relativePath, resolve as resolvePath } from "node:path";
 import {
+  MOONS_VERSION,
   MoonsError,
   fnRegistryKey,
   generateTypes,
@@ -423,6 +424,30 @@ export default function moons(options: MoonsVitePluginOptions = {}): Plugin {
     configureServer(server) {
       installDevMiddleware(server, {
         templatePath: resolvePath(root, "index.html"),
+        // Addendum I.4 (W4): overlay devtools — data segar per request.
+        devtools: () => {
+          const toRelative = (file: string): string =>
+            file.startsWith(root) ? relativePath(root, file).split("\\").join("/") : file;
+          return {
+            routes: [...routes]
+              .sort((a, b) => a.path.localeCompare(b.path) || a.kind.localeCompare(b.kind))
+              .map((route) => ({ path: route.path, kind: route.kind, file: toRelative(route.file) })),
+            apiRoutes: [...apiRoutes]
+              .sort((a, b) => a.path.localeCompare(b.path))
+              .map((route) => ({ path: route.path, kind: "api", file: toRelative(route.file) })),
+            serverFns: [...analysisCache.values()]
+              .flatMap((analysis) =>
+                analysis.serverFns.map((fn) => ({
+                  file: toRelative(analysis.file),
+                  name: fn.name,
+                  hash: fn.hash,
+                })),
+              )
+              .sort((a, b) => a.file.localeCompare(b.file) || a.name.localeCompare(b.name)),
+            canary: options.leakTest?.canary !== undefined,
+            version: MOONS_VERSION,
+          };
+        },
         // A1: pemindaian payload SSR hanya di dev (warning), tanpa biaya di production.
         payloadScan: {
           ...(options.leakTest?.canary === undefined ? {} : { canary: options.leakTest.canary }),
@@ -433,6 +458,7 @@ export default function moons(options: MoonsVitePluginOptions = {}): Plugin {
           ? {}
           : { apiPrefix: `/${apiDir.split(/[\\/]/).filter((part) => part.length > 0).pop() ?? "api"}` }),
       });
+      server.config.logger.info("[moons] devtools: /__moons/devtools");
     },
 
     async handleHotUpdate(context) {
@@ -541,7 +567,7 @@ function renderServerEntryBuild(
     "  onContext: (ctx) => plugins.applyExtensions(ctx),",
     "});",
     "",
-    `startNodeServer(handler, { plugins, headers: config.headers${canary === undefined ? "" : `, canary: ${JSON.stringify(canary)}`} });`,
+    `startNodeServer(handler, { plugins, headers: config.headers, storage: config.isr?.storage${canary === undefined ? "" : `, canary: ${JSON.stringify(canary)}`} });`,
     "",
   ].join("\n");
 }

package/src/server/dev.ts

@@ -6,6 +6,7 @@ import type { PluginRuntime } from "./plugins";
 import type { Shell } from "./shell";
 import { createDevShell } from "./shell";
 import { sendNodeResponse, toWebRequest } from "./node";
+import { emptyDevtoolsData, renderDevtoolsHtml, type DevtoolsData } from "../devtools";
 
 interface DevApp {
   handler: (request: Request) => Promise<Response>;
@@ -26,7 +27,13 @@ type DevServerEntry = {
  */
 export function installDevMiddleware(
   server: ViteDevServer,
-  options: { templatePath: string; payloadScan?: PayloadScanOptions; apiPrefix?: string },
+  options: {
+    templatePath: string;
+    payloadScan?: PayloadScanOptions;
+    apiPrefix?: string;
+    /** Addendum I.4: datasource devtools overlay (dipanggil per request). */
+    devtools?: () => DevtoolsData;
+  },
 ): void {
   let appPromise: Promise<DevApp> | null = null;
 
@@ -48,6 +55,24 @@ export function installDevMiddleware(
   });
 
   server.middlewares.use((req, res, next) => {
+    // Addendum I.4 (W4): overlay dev-only — selalu data segar per request.
+    if (
+      (req.method === "GET" || req.method === "HEAD") &&
+      new URL(req.url ?? "/", "http://localhost").pathname === "/__moons/devtools"
+    ) {
+      try {
+        const data = options.devtools?.() ?? emptyDevtoolsData();
+        res.statusCode = 200;
+        res.setHeader("content-type", "text/html; charset=utf-8");
+        res.end(req.method === "HEAD" ? undefined : renderDevtoolsHtml(data));
+      } catch (error) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "text/plain; charset=utf-8");
+        res.end(`[moons] devtools gagal dirender: ${String(error)}`);
+      }
+      return;
+    }
+
     if (!shouldHandle(req, options.apiPrefix)) {
       next();
       return;

package/src/server/index.ts

@@ -16,3 +16,4 @@ export { runPrerender } from "./prerender";
 export type { PrerenderOptions, PrerenderResult } from "./prerender";
 export type { PayloadScanOptions } from "../payload-scan";
 export type { ApiHandlerArgs, ApiMethod, ApiRouteDefinition } from "@moonsjs/core";
+export { createFileStorage, contentTypeForPathname } from "./storage";

package/src/server/isr.ts

@@ -1,4 +1,5 @@
 import { renameSync, writeFileSync } from "node:fs";
+import type { PrerenderStorage } from "@moonsjs/core";
 import { scanPayloadForSecrets } from "../payload-scan";
 
 /**
@@ -18,8 +19,13 @@ export function shouldRevalidate(input: {
 export interface RevalidateOptions {
   /** Path URL ternormalisasi (mis. "/blog/hello"). */
   pathname: string;
-  /** File HTML yang akan ditimpa. */
-  file: string;
+  /** File HTML yang akan ditimpa (default file storage). */
+  file?: string;
+  /**
+   * Storage alternatif (Addendum I). Bila diisi, `file` diabaikan dan hasil
+   * regenerasi ditulis lewat `storage.write(pathname, body)`.
+   */
+  storage?: PrerenderStorage;
   handler: (request: Request) => Promise<Response>;
   canary?: string;
   env?: Record<string, string | undefined>;
@@ -67,6 +73,14 @@ async function runRevalidate(options: RevalidateOptions): Promise<void> {
       log(`[moons] isr: TIDAK menulis ${options.pathname} — memuat ${labels}`);
       return;
     }
+    if (options.storage !== undefined) {
+      await options.storage.write(options.pathname, new TextEncoder().encode(html));
+      return;
+    }
+    if (options.file === undefined) {
+      log(`[moons] isr: lewati ${options.pathname} — tanpa file/storage tujuan`);
+      return;
+    }
     const tmp = `${options.file}.tmp-${process.pid}`;
     writeFileSync(tmp, html);
     renameSync(tmp, options.file);

package/src/server/node-server.ts

@@ -1,7 +1,9 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer, type Server } from "node:http";
 import { extname, join, resolve, sep } from "node:path";
+import type { PrerenderStorage } from "@moonsjs/core";
 import { revalidatePrerendered, shouldRevalidate } from "./isr";
+import { contentTypeForPathname } from "./storage";
 import { sendNodeResponse, toWebRequest } from "./node";
 import type { PluginRuntime } from "./plugins";
 import { installGracefulShutdown } from "./shutdown";
@@ -44,6 +46,12 @@ export interface NodeServerOptions {
    * prerender yang disajikan langsung (static host memakai `_headers`).
    */
   headers?: Record<string, string>;
+  /**
+   * Storage bersama untuk file prerender (Addendum I, ISR multi-instance).
+   * Bila diisi, penyajian file prerender dan penulisan hasil regenerasi
+   * memakai storage ini; default: file sistem lokal.
+   */
+  storage?: PrerenderStorage;
 }
 
 /**
@@ -63,19 +71,50 @@ export function startNodeServer(
         const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
 
         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");
-            for (const [name, value] of Object.entries(options.headers ?? {})) {
-              if (!res.hasHeader(name)) {
-                res.setHeader(name, value);
+          // Addendum I: storage bersama (bila dikonfigurasi) menggantikan file lokal.
+          if (options.storage !== undefined) {
+            const entry = await options.storage.read(url.pathname);
+            if (entry !== null) {
+              scheduleRevalidation({
+                pathname: url.pathname,
+                mtimeMs: entry.mtimeMs,
+                storage: options.storage,
+                handler,
+                options,
+                clientDir,
+              });
+              res.statusCode = 200;
+              res.setHeader("content-type", contentTypeForPathname(url.pathname));
+              for (const [name, value] of Object.entries(options.headers ?? {})) {
+                if (!res.hasHeader(name)) {
+                  res.setHeader(name, value);
+                }
+              }
+              res.end(req.method === "HEAD" ? undefined : Buffer.from(entry.body));
+              return;
+            }
+          } else {
+            const staticFile = resolveStaticFile(clientDir, url.pathname);
+            if (staticFile !== null) {
+              scheduleRevalidation({
+                pathname: url.pathname,
+                mtimeMs: statSync(staticFile).mtimeMs,
+                file: staticFile,
+                handler,
+                options,
+                clientDir,
+              });
+              const body = readFileSync(staticFile);
+              res.statusCode = 200;
+              res.setHeader("content-type", MIME_TYPES[extname(staticFile).toLowerCase()] ?? "application/octet-stream");
+              for (const [name, value] of Object.entries(options.headers ?? {})) {
+                if (!res.hasHeader(name)) {
+                  res.setHeader(name, value);
+                }
               }
+              res.end(req.method === "HEAD" ? undefined : body);
+              return;
             }
-            res.end(req.method === "HEAD" ? undefined : body);
-            return;
           }
         }
 
@@ -122,6 +161,15 @@ export function startNodeServer(
 
 /** Resolve file static dengan proteksi path traversal (+ manifest prerender D.5). */
 export function resolveStaticFile(clientDir: string, pathname: string): string | null {
+  const target = staticFileTarget(clientDir, pathname);
+  return target !== null && isFile(target) ? target : null;
+}
+
+/**
+ * Target file untuk `pathname` (tanpa cek keberadaan) — dipakai penyajian,
+ * `createFileStorage().write`, dan test. Proteksi path traversal tetap.
+ */
+export function staticFileTarget(clientDir: string, pathname: string): string | null {
   let decoded: string;
   try {
     decoded = decodeURIComponent(pathname);
@@ -141,10 +189,7 @@ export function resolveStaticFile(clientDir: string, pathname: string): string |
   const manifest = readPrerenderManifest(clientDir);
   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)) {
-      return candidate;
-    }
+    return safeWithin(clientDir, `./${target}`);
   }
 
   return null;
@@ -221,32 +266,30 @@ function readPrerenderManifest(clientDir: string): PrerenderManifestInfo {
 }
 
 /** 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);
+function scheduleRevalidation(input: {
+  pathname: string;
+  mtimeMs: number;
+  file?: string;
+  storage?: PrerenderStorage;
+  handler: (request: Request) => Promise<Response>;
+  options: NodeServerOptions;
+  clientDir: string;
+}): void {
+  const normalized = input.pathname.length > 1 ? input.pathname.replace(/\/+$/, "") : input.pathname;
+  const seconds = readPrerenderManifest(input.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 })) {
+  if (!shouldRevalidate({ mtimeMs: input.mtimeMs, revalidateSeconds: seconds })) {
     return;
   }
   void revalidatePrerendered({
     pathname: normalized,
-    file: staticFile,
-    handler,
-    ...(options.canary === undefined ? {} : { canary: options.canary }),
+    ...(input.file === undefined ? {} : { file: input.file }),
+    ...(input.storage === undefined ? {} : { storage: input.storage }),
+    handler: input.handler,
+    ...(input.options.canary === undefined ? {} : { canary: input.options.canary }),
+    env: process.env,
   });
 }
 

package/src/server/storage.ts

@@ -0,0 +1,53 @@
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname } from "node:path";
+import type { PrerenderStorage, PrerenderStorageEntry } from "@moonsjs/core";
+import { resolveStaticFile, staticFileTarget } from "./node-server";
+
+/**
+ * Addendum I: storage file sistem (default) untuk file prerender/ISR.
+ * Read hanya melayani path yang benar-benar ada (manifest-aware);
+ * write atomik (tmp + rename) dan membuat direktori bila perlu.
+ */
+export function createFileStorage(clientDir: string): PrerenderStorage {
+  return {
+    async read(pathname: string): Promise<PrerenderStorageEntry | null> {
+      const file = resolveStaticFile(clientDir, pathname);
+      if (file === null) {
+        return null;
+      }
+      const stat = statSync(file);
+      return { body: readFileSync(file), mtimeMs: stat.mtimeMs };
+    },
+    async write(pathname: string, body: Uint8Array): Promise<void> {
+      const target = staticFileTarget(clientDir, pathname);
+      if (target === null) {
+        throw new Error(`[moons] isr: path tidak valid untuk ditulis: ${pathname}`);
+      }
+      mkdirSync(dirname(target), { recursive: true });
+      const tmp = `${target}.tmp-${process.pid}`;
+      writeFileSync(tmp, body);
+      renameSync(tmp, target);
+    },
+  };
+}
+
+/** Ekstensi pathname (untuk `content-type`) tanpa membaca storage. */
+export function contentTypeForPathname(pathname: string): string {
+  const ext = extname(pathname.split("?")[0] ?? "").toLowerCase();
+  return MIME[ext] ?? MIME[".html"] ?? "text/html; charset=utf-8";
+}
+
+const MIME: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+};