@moonsjs/vite 0.0.0-stage → 0.1.0

package/src/plugin.ts

@@ -0,0 +1,471 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { resolve as resolvePath } from "node:path";
+import {
+  MoonsError,
+  fnRegistryKey,
+  generateTypes,
+  scanRoutes,
+  validateConfig,
+  type RouteDefinition,
+} from "@moonsjs/core";
+import { loadConfigFromFile, type Plugin, type ViteDevServer } from "vite";
+import { findLeak } from "./leak-check";
+import { renderRoutesModule, rootSpecifier } from "./manifest";
+import { installDevMiddleware } from "./server/dev";
+import {
+  analyzeServerFile,
+  checkClientModuleImports,
+  checkRouteModuleExports,
+  injectServerFnMeta,
+  isNonContractServerFile,
+  isServerFilePath,
+  nonContractServerFileError,
+  renderServerFnStub,
+  resolveServerSpecifierSync,
+  scanServerFiles,
+  stripQuery,
+  type ServerFileAnalysis,
+} from "./transform";
+import { fromNullPrefixed, VIRTUAL_MODULES } from "./virtual-modules";
+
+export interface MoonsVitePluginOptions {
+  /** Default: "moons.config.ts". */
+  configPath?: string;
+  /** Hanya dipakai di CI (M2 §21). */
+  leakTest?: { canary?: string };
+  /** Default: root Vite. */
+  projectRoot?: string;
+}
+
+/**
+ * Plugin `@moonsjs/vite` (PRD §9): scan route, typegen, virtual module,
+ * dev SSR middleware, build client + server.
+ */
+const CODE_FILE_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/;
+
+export default function moons(options: MoonsVitePluginOptions = {}): Plugin {
+  let root = options.projectRoot ?? process.cwd();
+  let isSsrBuild = false;
+  let configFilePath = "";
+  let routesDir = "";
+  let routes: RouteDefinition[] = [];
+  let analysisCache = new Map<string, ServerFileAnalysis>();
+  const stubTransformed = new Set<string>();
+
+  function analyzeFile(absoluteFile: string): ServerFileAnalysis | null {
+    const cached = analysisCache.get(absoluteFile);
+    if (cached !== undefined) {
+      return cached;
+    }
+    let source: string;
+    try {
+      source = readFileSync(absoluteFile, "utf8");
+    } catch {
+      return null;
+    }
+    const analysis = analyzeServerFile(source, absoluteFile, root);
+    analysisCache.set(absoluteFile, analysis);
+    return analysis;
+  }
+
+  function refreshServerFns(): void {
+    const next = new Map<string, ServerFileAnalysis>();
+    const registry: Record<string, string> = {};
+
+    for (const file of scanServerFiles(root)) {
+      let source: string;
+      try {
+        source = readFileSync(file, "utf8");
+      } catch {
+        continue;
+      }
+      const analysis = analyzeServerFile(source, file, root);
+      next.set(file, analysis);
+      for (const fn of analysis.serverFns) {
+        registry[fnRegistryKey(root, file, fn.name)] = fn.hash;
+      }
+    }
+
+    analysisCache = next;
+    const outDir = resolvePath(root, ".moons");
+    mkdirSync(outDir, { recursive: true });
+    writeFileSync(
+      resolvePath(outDir, "fn-registry.json"),
+      `${JSON.stringify(registry, null, 2)}\n`,
+      "utf8",
+    );
+  }
+
+  /** Semua specifier file `.server.ts` yang punya serverFn (untuk eager import di entry server). */
+  function serverFnFileSpecifiers(): string[] {
+    const specifiers: string[] = [];
+    for (const [file, analysis] of analysisCache) {
+      if (analysis.serverFns.length > 0) {
+        specifiers.push(rootSpecifier(root, file));
+      }
+    }
+    return specifiers.sort();
+  }
+
+  /** Stub client §12.2 + cache §12.2.5. */
+  function transformServerFileClient(code: string, id: string): string {
+    const relativePath = id.startsWith(root)
+      ? id.slice(root.length).split("\\").join("/")
+      : id;
+    const cacheKey = createHash("sha256").update(`${relativePath}\0${code}`).digest("hex");
+    const cacheFile = resolvePath(root, ".moons/cache", `${cacheKey}.js`);
+
+    if (existsSync(cacheFile)) {
+      stubTransformed.add(id);
+      return readFileSync(cacheFile, "utf8");
+    }
+
+    const analysis = analyzeFile(id);
+    if (analysis === null) {
+      throw new MoonsError({
+        code: "E_INTERNAL",
+        file: id,
+        message: "gagal membaca file server untuk transform",
+        details: "File `.server.ts` harus bisa dibaca saat transform (PRD §12.2).",
+        suggestions: ["Periksa path dan izin file"],
+      });
+    }
+
+    const stub = renderServerFnStub(code, id, analysis, {
+      analyzeSpecifier: (sourceFile, specifier) => {
+        const resolved = resolveServerSpecifierSync(sourceFile, specifier);
+        return resolved === null ? null : analyzeFile(resolved);
+      },
+    });
+
+    mkdirSync(resolvePath(root, ".moons/cache"), { recursive: true });
+    writeFileSync(cacheFile, stub.code, "utf8");
+    stubTransformed.add(id);
+    return stub.code;
+  }
+
+  return {
+    name: "moons",
+    enforce: "pre",
+
+    config(_config, env) {
+      isSsrBuild = env.isSsrBuild === true;
+      const common = {
+        appType: "custom" as const,
+      };
+
+      if (isSsrBuild) {
+        return {
+          ...common,
+          build: {
+            outDir: "dist/server",
+            emptyOutDir: true,
+            // Entry nyata yang di-generate saat buildStart (Rolldown butuh file,
+            // entry virtual tidak di-resolve lewat plugin container).
+            ssr: ".moons/server-entry.ts",
+            rollupOptions: { output: { entryFileNames: "index.js", codeSplitting: false } },
+          },
+          ssr: { noExternal: true, target: "node" as const },
+        };
+      }
+
+      return {
+        ...common,
+        build: { outDir: "dist/client", emptyOutDir: true },
+      };
+    },
+
+    async configResolved(resolved) {
+      root = options.projectRoot ?? resolved.root;
+      configFilePath = resolvePath(root, options.configPath ?? "moons.config.ts");
+
+      if (!existsSync(configFilePath)) {
+        throw new MoonsError({
+          code: "E_CONFIG_INVALID",
+          file: configFilePath,
+          message: "`moons.config.ts` tidak ditemukan",
+          details: "Framework membutuhkan file config di root project (PRD §14.3).",
+          suggestions: [
+            "Buat `moons.config.ts` dengan `export default defineConfig({ context: async (req) => ({}) })`",
+          ],
+        });
+      }
+
+      let raw: unknown;
+      try {
+        const loaded = await loadConfigFromFile(
+          { command: resolved.command, mode: resolved.mode },
+          configFilePath,
+          root,
+        );
+        raw = loaded?.config;
+      } catch (error) {
+        if (error instanceof MoonsError) {
+          throw error;
+        }
+        throw new MoonsError({
+          code: "E_CONFIG_INVALID",
+          file: configFilePath,
+          message: "gagal memuat `moons.config.ts`",
+          details: error instanceof Error ? error.message : String(error),
+          suggestions: ["Periksa sintaks dan import di `moons.config.ts`"],
+        });
+      }
+
+      const config = validateConfig(raw, { file: configFilePath, projectRoot: root });
+      routesDir = resolvePath(root, config.routesDir);
+    },
+
+    async buildStart() {
+      routes = scanRoutes(routesDir);
+      await generateTypes({
+        routesDir,
+        configPath: configFilePath,
+        outDir: resolvePath(root, ".moons"),
+      });
+      refreshServerFns();
+      if (isSsrBuild) {
+        writeFileSync(
+          resolvePath(root, ".moons/server-entry.ts"),
+          renderServerEntryBuild(routesDir, serverFnFileSpecifiers()),
+          "utf8",
+        );
+      }
+    },
+
+    resolveId(id) {
+      const clean = id.startsWith("\0") ? id.slice(1) : id;
+      if ((Object.values(VIRTUAL_MODULES) as string[]).includes(clean)) {
+        return `\0${clean}`;
+      }
+      return undefined;
+    },
+
+    load(id) {
+      const name = fromNullPrefixed(id);
+      if (name === null) {
+        return undefined;
+      }
+      switch (name) {
+        case VIRTUAL_MODULES.routes:
+          return renderRoutesModule(routes, routesDir, root);
+        case VIRTUAL_MODULES.clientEntry:
+          return '// Generated by @moons. Jangan diubah manual.\nexport { clientManifest, loadRoute } from "virtual:moons/routes";\n';
+        case VIRTUAL_MODULES.config:
+          return renderConfigModule(root, configFilePath);
+        case VIRTUAL_MODULES.serverEntry:
+          // Hanya dipakai dev (ssrLoadModule); build memakai .moons/server-entry.ts.
+          return renderServerEntryDev(routesDir, serverFnFileSpecifiers());
+      }
+    },
+
+    async transform(code, id) {
+      const cleanId = stripQuery(id);
+      if (cleanId.startsWith("\0") || cleanId.includes("/node_modules/")) {
+        return undefined;
+      }
+
+      const environment = environmentName(this);
+
+      if (isServerFilePath(cleanId)) {
+        if (environment === "ssr") {
+          const analysis = analysisCache.get(cleanId) ?? analyzeFile(cleanId);
+          if (analysis === null || analysis.serverFns.length === 0) {
+            return undefined;
+          }
+          return injectServerFnMeta(code, analysis, root);
+        }
+        return transformServerFileClient(code, cleanId);
+      }
+
+      // Audit ronde 2: file server di luar kontrak §12 tidak bisa di-stub —
+      // jangan pernah biarkan masuk graph client.
+      if (environment !== "ssr" && isNonContractServerFile(cleanId)) {
+        throw nonContractServerFileError(cleanId, root);
+      }
+
+      if (environment !== "ssr" && CODE_FILE_PATTERN.test(cleanId)) {
+        if (cleanId.startsWith(routesDir) && cleanId.endsWith(".tsx")) {
+          checkRouteModuleExports({
+            file: cleanId,
+            code,
+            routesDir,
+            projectRoot: root,
+          });
+        }
+        await checkClientModuleImports({
+          file: cleanId,
+          code,
+          projectRoot: root,
+          // Resolusi penuh (alias Vite, tsconfig paths, symlink) — audit ronde 2.
+          resolve: async (specifier, importer) => {
+            try {
+              const resolved = await this.resolve(specifier, importer);
+              return resolved === null ? null : stripQuery(resolved.id);
+            } catch {
+              return null;
+            }
+          },
+          analyze: (absoluteFile) => analysisCache.get(absoluteFile) ?? analyzeFile(absoluteFile),
+        });
+      }
+
+      return undefined;
+    },
+
+    generateBundle(_options, bundle) {
+      if (environmentName(this) === "ssr") {
+        return;
+      }
+
+      const canary = options.leakTest?.canary;
+      if (canary !== undefined && canary.length > 0) {
+        const leak = findLeak(Object.values(bundle), canary);
+        if (leak !== null) {
+          throw new MoonsError({
+            code: "E_INTERNAL",
+            message: `canary \`${canary}\` ditemukan di bundle client (${leak.fileName})`,
+            details:
+              "Verifikasi kebocoran §2/§9.2.8 gagal: kode server bocor ke output client. Build dihentikan.",
+            suggestions: [
+              "Periksa transform `*.server.ts` (§12)",
+              "Jalankan `./scripts/m2/test-leak.sh` untuk audit",
+            ],
+          });
+        }
+      }
+
+      for (const output of Object.values(bundle)) {
+        if (output.type !== "chunk") {
+          continue;
+        }
+        for (const moduleId of Object.keys(output.modules)) {
+          const cleanId = stripQuery(moduleId);
+          if (!isServerFilePath(cleanId) || stubTransformed.has(cleanId)) {
+            continue;
+          }
+          throw new MoonsError({
+            code: "E_FORBIDDEN_SERVER_IMPORT",
+            file: cleanId,
+            message: "modul server ikut ter-bundle di client tanpa melewati transform",
+            details:
+              "Verifikasi build §9.2: setiap `*.server.ts` di bundle client wajib berupa stub RPC hasil transform.",
+            suggestions: [
+              "Pastikan transform zero-trust (§12) berjalan untuk modul ini",
+              "Laporkan ini sebagai bug framework jika berulang",
+            ],
+          });
+        }
+      }
+    },
+
+    configureServer(server) {
+      installDevMiddleware(server, { templatePath: resolvePath(root, "index.html") });
+    },
+
+    async handleHotUpdate(context) {
+      if (isServerFilePath(context.file)) {
+        refreshServerFns();
+        context.server.ws.send({ type: "full-reload" });
+        return;
+      }
+
+      if (!context.file.startsWith(routesDir)) {
+        return;
+      }
+
+      try {
+        routes = scanRoutes(routesDir);
+        await generateTypes({
+          routesDir,
+          configPath: configFilePath,
+          outDir: resolvePath(root, ".moons"),
+        });
+      } catch (error) {
+        context.server.config.logger.error(String(error));
+        return;
+      }
+
+      invalidateVirtualModules(context.server);
+      context.server.ws.send({ type: "full-reload" });
+    },
+  };
+}
+
+function renderConfigModule(root: string, configFilePath: string): string {
+  return [
+    "// Generated by @moons. Jangan diubah manual.",
+    `import raw from ${JSON.stringify(rootSpecifier(root, configFilePath))};`,
+    'import { validateConfig } from "@moonsjs/core";',
+    `export default validateConfig(raw, { file: ${JSON.stringify(configFilePath)} });`,
+    "",
+  ].join("\n");
+}
+
+function renderServerEntryDev(routesDir: string, eagerImports: string[]): string {
+  return [
+    "// Generated by @moons. Jangan diubah manual.",
+    'import { createRequestHandler } from "@moonsjs/vite/server";',
+    'import config from "virtual:moons/config";',
+    'import { routes, loadRoute } from "virtual:moons/routes";',
+    ...eagerImports.map((specifier) => `import ${JSON.stringify(specifier)};`),
+    "",
+    "export function createDevHandler(shell) {",
+    `  return createRequestHandler({ routes, config, routesDir: ${JSON.stringify(routesDir)}, loadRoute, shell });`,
+    "}",
+    "",
+  ].join("\n");
+}
+
+function renderServerEntryBuild(routesDir: string, eagerImports: string[]): string {
+  return [
+    "// Generated by @moons. Jangan diubah manual.",
+    'import { createFileShell, createRequestHandler, startNodeServer } from "@moonsjs/vite/server";',
+    'import config from "virtual:moons/config";',
+    'import { routes, loadRoute } from "virtual:moons/routes";',
+    ...eagerImports.map((specifier) => `import ${JSON.stringify(specifier)};`),
+    "",
+    "const handler = createRequestHandler({",
+    "  routes,",
+    "  config,",
+    `  routesDir: ${JSON.stringify(routesDir)},`,
+    "  loadRoute,",
+    "  shell: createFileShell(),",
+    "});",
+    "",
+    "startNodeServer(handler);",
+    "",
+  ].join("\n");
+}
+
+interface ModuleGraphLike {
+  getModulesByFile(file: string): Iterable<{ id?: string | null }> | undefined;
+  invalidateModule(module: unknown): void;
+}
+
+function environmentName(context: unknown): string {
+  const environment = (context as { environment?: { name?: string } } | undefined)?.environment;
+  return environment?.name ?? "client";
+}
+
+function invalidateVirtualModules(server: ViteDevServer): void {
+  const graphs: ModuleGraphLike[] = [server.moduleGraph as unknown as ModuleGraphLike];
+  const environments = (server as unknown as { environments?: Record<string, { moduleGraph?: unknown }> })
+    .environments;
+  if (environments !== undefined) {
+    for (const environment of Object.values(environments)) {
+      if (environment.moduleGraph !== undefined) {
+        graphs.push(environment.moduleGraph as ModuleGraphLike);
+      }
+    }
+  }
+
+  for (const graph of graphs) {
+    for (const name of Object.values(VIRTUAL_MODULES)) {
+      for (const module of graph.getModulesByFile(`\0${name}`) ?? []) {
+        graph.invalidateModule(module);
+      }
+    }
+  }
+}

package/src/server/dev.ts

@@ -0,0 +1,54 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ViteDevServer } from "vite";
+import { VIRTUAL_MODULES } from "../virtual-modules";
+import type { Shell } from "./shell";
+import { createDevShell } from "./shell";
+import { sendNodeResponse, toWebRequest } from "./node";
+
+type DevServerEntry = {
+  createDevHandler: (shell: Shell) => (request: Request) => Promise<Response>;
+};
+
+/**
+ * Middleware SSR dev: dipasang sebelum middleware internal Vite, hanya
+ * menangani request HTML (modul/aset tetap dilayani Vite).
+ */
+export function installDevMiddleware(
+  server: ViteDevServer,
+  options: { templatePath: string },
+): void {
+  server.middlewares.use((req, res, next) => {
+    if (!isHtmlRequest(req)) {
+      next();
+      return;
+    }
+    void handleRequest(server, options)(req, res).catch((error: unknown) => {
+      next(error as Error);
+    });
+  });
+}
+
+function handleRequest(server: ViteDevServer, options: { templatePath: string }) {
+  return async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    const entry = (await server.ssrLoadModule(VIRTUAL_MODULES.serverEntry)) as DevServerEntry;
+    const handler = entry.createDevHandler(createDevShell(server, options));
+    const response = await handler(await toWebRequest(req));
+    await sendNodeResponse(res, response);
+  };
+}
+
+function isHtmlRequest(req: IncomingMessage): boolean {
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    return false;
+  }
+  const path = new URL(req.url ?? "/", "http://localhost").pathname;
+  if (path.startsWith("/@") || path.startsWith("/node_modules/") || path.startsWith("/__")) {
+    return false;
+  }
+  const lastSegment = path.split("/").pop() ?? "";
+  if (lastSegment.includes(".")) {
+    return false;
+  }
+  const accept = req.headers.accept ?? "";
+  return accept.includes("text/html") || accept.includes("*/*");
+}