@moonsjs/vite 0.1.18 → 0.2.1

package/src/server/dev.ts

@@ -133,6 +133,11 @@ function shouldHandle(req: IncomingMessage, apiPrefix: string | undefined): bool
     return true;
   }
 
+  // Addendum O: health check (semua method) — paritas 405 dengan produksi.
+  if (path === "/_moons/health") {
+    return true;
+  }
+
   // Addendum D.1: endpoint `src/api` (semua method) dirutekan ke runtime.
   if (apiPrefix !== undefined && (path === apiPrefix || path.startsWith(`${apiPrefix}/`))) {
     return true;

package/src/server/handler.ts

@@ -21,7 +21,15 @@ import {
 } from "@moonsjs/core";
 import { encodeSsrPayload, reviveError, serializeError } from "@moonsjs/core/serialize";
 import { API_METHODS, resolveApiRoute } from "@moonsjs/core";
-import { renderToMarkup } from "@moonsjs/react/ssr";
+import type { renderToMarkup as RenderToMarkupFn } from "@moonsjs/react/ssr";
+
+type RenderMarkup = typeof RenderToMarkupFn;
+
+/** Default: bare dynamic import (bundlers keep this resolvable). */
+async function defaultRenderer(): Promise<RenderMarkup> {
+  const mod = (await import("@moonsjs/react/ssr")) as { renderToMarkup: RenderMarkup };
+  return mod.renderToMarkup;
+}
 import type { ClientRouteEntry, RouteModuleShape } from "@moonsjs/react/internal";
 import { createRpcHandler, runWithContext, runWithRequestCache, runWithResponseCollector, takeResponseMutations } from "@moonsjs/server";
 import { NOT_FOUND_ROUTE_KEY } from "../manifest";
@@ -59,6 +67,12 @@ export interface RequestHandlerOptions {
   apiMiddlewares?: ApiMiddlewareDefinition[];
   /** Peta import() `_middleware.ts` pohon api, key = file path. */
   loadApiMiddleware?: Record<string, () => Promise<unknown>>;
+  /**
+   * Addendum O: sumber `renderToMarkup`. Test server memakai loader ini untuk
+   * memuat renderer dari `node_modules` app (Bun meresolusi paket registry dari
+   * cache; peer `react-dom` tidak ditemukan dari sana).
+   */
+  renderer?: () => Promise<RenderMarkup>;
 }
 
 /**
@@ -67,7 +81,15 @@ export interface RequestHandlerOptions {
  */
 export function createRequestHandler(
   options: RequestHandlerOptions,
-): (request: Request) => Promise<Response> {  const { routes, config, routesDir, loadRoute, shell } = options;
+): (request: Request) => Promise<Response> {
+  let renderMarkup: RenderMarkup | null = null;
+  const getRenderMarkup = async (): Promise<RenderMarkup> => {
+    if (renderMarkup === null) {
+      renderMarkup = await (options.renderer ?? defaultRenderer)();
+    }
+    return renderMarkup;
+  };
+  const { routes, config, routesDir, loadRoute, shell } = options;
   const rpc = createRpcHandler(
     config.security === undefined ? {} : { security: config.security },
   );
@@ -98,12 +120,15 @@ export function createRequestHandler(
     // Addendum B.1: eksekusi `meta()` page (data = hasil loader page itu sendiri).
     const meta = await runRouteMeta(pageModule, data[pageKey], resolved.route.file);
 
-    const markup = renderToMarkup(
+    const render = await getRenderMarkup();
+    const markup = render(
       entry,
       { page: pageModule as RouteModuleShape, layouts: modules.slice(0, -1) as RouteModuleShape[] },
       resolved.params,
       data,
       searchParams,
+      undefined,
+      config.trailingSlash,
     );
     const payload = encodeSsrPayload({
       key: pageKey,
@@ -116,7 +141,10 @@ export function createRequestHandler(
     // A1: pindai payload SSR (dev saja — `payloadScan` tidak diisi production).
     warnPayloadFindings(payload, options.payloadScan, warnedPayloadLabels);
 
-    return htmlResponse(await shell(markup, payload, request.url, meta), 200);
+    return htmlResponse(
+      withTrailingSlashMeta(await shell(markup, payload, request.url, meta), config.trailingSlash),
+      200,
+    );
   }
 
   /** Addendum D.1: dispatch endpoint `src/api` (405/HEAD/OPTIONS + error). */
@@ -217,25 +245,28 @@ export function createRequestHandler(
         const key = routeKeyFromFile(routesDir, notFoundRoute.file);
         const [module] = await loadModules([key], loadRoute);
         const payload = encodeSsrPayload({ key: NOT_FOUND_ROUTE_KEY, params: {}, data: {} });
-        const markup = renderToMarkup(
+        const render = await getRenderMarkup();
+        const markup = render(
           { page: key, layouts: [] },
           { page: module as RouteModuleShape, layouts: [] },
           {},
           {},
+          {},
+          undefined,
+          config.trailingSlash,
+        );
+        return htmlResponse(
+          withTrailingSlashMeta(await shell(markup, payload, request.url), config.trailingSlash),
+          404,
         );
-        return htmlResponse(await shell(markup, payload, request.url), 404);
       } catch (error) {
         console.error("[moons] failed to render custom _404:", error);
       }
     }
 
     const payload = encodeSsrPayload({ key: "", params: {}, data: {} });
-    const html = await shell(
-      "<h1>404</h1><p>Page not found.</p>",
-      payload,
-      request.url,
-    );
-    return htmlResponse(html, 404);
+    const html = await shell("<h1>404</h1><p>Page not found.</p>", payload, request.url);
+    return htmlResponse(withTrailingSlashMeta(html, config.trailingSlash), 404);
   }
 
   /**
@@ -265,15 +296,20 @@ export function createRequestHandler(
           data: {},
           ...(serialized === undefined ? {} : { error: serialized }),
         });
-        const markup = renderToMarkup(
+        const render = await getRenderMarkup();
+        const markup = render(
           { page: key, layouts: [] },
           { page: module as RouteModuleShape, layouts: [] },
           {},
           {},
           {},
           serialized === undefined ? undefined : reviveError(serialized),
+          config.trailingSlash,
+        );
+        return htmlResponse(
+          withTrailingSlashMeta(await shell(markup, payload, request.url), config.trailingSlash),
+          500,
         );
-        return htmlResponse(await shell(markup, payload, request.url), 500);
       } catch (renderError) {
         console.error("[moons] failed to render custom _error:", renderError);
       }
@@ -617,6 +653,17 @@ function internalErrorResponse(error: unknown, options: { log?: boolean } = {}):
   );
 }
 
+/** Addendum O: expose the trailing-slash policy to the client runtime. */
+function withTrailingSlashMeta(html: string, policy?: "never" | "always"): string {
+  if (policy === undefined) {
+    return html;
+  }
+  return html.replace(
+    "</head>",
+    `  <meta name="moons:trailing-slash" content="${policy}" />\n</head>`,
+  );
+}
+
 function htmlResponse(html: string, status: number): Response {
   return new Response(html, {
     status,

package/src/server/test-server.ts

@@ -1,12 +1,51 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import type { MoonsConfig, RouteDefinition, RouteModule } from "@moonsjs/core";
-import { createRequestHandler } from "./handler";
+import type { renderToMarkup as RenderToMarkupFn } from "@moonsjs/react/ssr";
+import { createRequestHandler, type RequestHandlerOptions } from "./handler";
 import { DEFAULT_TEMPLATE, injectShell, type Shell } from "./shell";
 
+type RenderMarkup = typeof RenderToMarkupFn;
+
+/**
+ * Addendum O: resolve the SSR renderer from the app's own `node_modules` first.
+ * Bun resolves registry packages through its install cache; peer imports
+ * (`react-dom/server`) are not reachable from there, but they are from the app.
+ */
+async function loadRenderer(candidates: ReadonlyArray<string>): Promise<RenderMarkup> {
+  for (const root of candidates) {
+    for (const relative of [
+      "node_modules/@moonsjs/react/dist/ssr.js",
+      "node_modules/@moonsjs/react/dist/ssr.mjs",
+      "node_modules/@moonsjs/react/src/ssr.ts",
+    ]) {
+      const file = join(root, relative);
+      if (!existsSync(file)) {
+        continue;
+      }
+      const mod = (await import(pathToFileURL(file).href)) as {
+        renderToMarkup?: RenderMarkup;
+      };
+      if (typeof mod.renderToMarkup === "function") {
+        return mod.renderToMarkup;
+      }
+    }
+  }
+  const fallback = (await import("@moonsjs/react/ssr")) as { renderToMarkup: RenderMarkup };
+  return fallback.renderToMarkup;
+}
+
 export interface TestServerOptions {
   routes: RouteDefinition[];
   config: MoonsConfig;
   routesDir: string;
   loadRoute: Record<string, () => Promise<RouteModule>>;
+  /** Endpoint `src/api` (Addendum O) — hasil scan app. */
+  apiRoutes?: RequestHandlerOptions["apiRoutes"];
+  loadApi?: RequestHandlerOptions["loadApi"];
+  apiMiddlewares?: RequestHandlerOptions["apiMiddlewares"];
+  loadApiMiddleware?: RequestHandlerOptions["loadApiMiddleware"];
   /** Default: shell in-memory dari `DEFAULT_TEMPLATE` (tanpa file). */
   shell?: Shell;
 }
@@ -34,6 +73,14 @@ export function createTestServer(
     config: options.config,
     routesDir: options.routesDir,
     loadRoute: options.loadRoute,
+    ...(options.apiRoutes === undefined ? {} : { apiRoutes: options.apiRoutes }),
+    ...(options.loadApi === undefined ? {} : { loadApi: options.loadApi }),
+    ...(options.apiMiddlewares === undefined ? {} : { apiMiddlewares: options.apiMiddlewares }),
+    ...(options.loadApiMiddleware === undefined
+      ? {}
+      : { loadApiMiddleware: options.loadApiMiddleware }),
+    renderer: () =>
+      loadRenderer([process.cwd(), resolve(options.routesDir, "..", "..")]),
     shell,
   });
 

package/src/testing-preload.ts

@@ -0,0 +1,5 @@
+import { registerMoonsTestPlugin } from "./testing";
+
+// Marker so fixture tests can skip cleanly under a plain `bun test` run.
+(globalThis as { __moonsTestPreload?: boolean }).__moonsTestPreload = true;
+registerMoonsTestPlugin();

package/src/testing.ts

@@ -0,0 +1,34 @@
+import { readFileSync } from "node:fs";
+import type { BunPlugin } from "bun";
+import { analyzeServerFile, injectServerFnMeta } from "./transform";
+
+/**
+ * Annotate a `*.server.ts` module with the transform-generated serverFn meta
+ * (`__hash`, `__file`, `__line`, `__exportName`) — the same injection the
+ * build performs. Used by `moons test` so tests can import server modules.
+ */
+export function transformServerModuleForTest(
+  file: string,
+  projectRoot = process.cwd(),
+): string {
+  const source = readFileSync(file, "utf8");
+  const analysis = analyzeServerFile(source, file, projectRoot);
+  return injectServerFnMeta(source, analysis, projectRoot);
+}
+
+/** Bun runtime plugin that applies the serverFn meta before tests load code. */
+export function moonsTestPlugin(projectRoot = process.cwd()): BunPlugin {
+  return {
+    name: "moons-test-server-meta",
+    setup(build) {
+      build.onLoad({ filter: /\.server\.(ts|tsx)$/ }, (args) => ({
+        contents: transformServerModuleForTest(args.path, projectRoot),
+        loader: args.path.endsWith(".tsx") ? "tsx" : "ts",
+      }));
+    },
+  };
+}
+
+export function registerMoonsTestPlugin(projectRoot = process.cwd()): void {
+  Bun.plugin(moonsTestPlugin(projectRoot));
+}