@tschk/moonshine-compiler 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tschk/moonshine-compiler",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "license": "ISC",
   "type": "module",
   "main": "./src/index.ts",
@@ -15,8 +15,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@tschk/moonshine-framework": "^0.3.5",
-    "@tschk/moonshine-router": "^0.3.5"
+    "@tschk/moonshine-framework": "^0.3.6",
+    "@tschk/moonshine-router": "^0.3.6"
   },
   "devDependencies": {
     "@types/bun": "1.3.14",

package/src/build.ts

@@ -63,6 +63,30 @@ function generateServerEntry(
       : ""
   }`);
   }
+  // Layouts, middleware, and error boundaries are route dependencies the server
+  // renders through, so they belong in the bundle alongside the pages. Without
+  // them the renderer falls back to `await import(file)` on their SOURCE paths,
+  // which only resolves where the source tree sits next to the build output —
+  // never in a deployed image, and never on a runtime that cannot resolve a
+  // dynamic import at all. A page would render locally and 500 in production.
+  const supportFiles: string[] = [];
+  for (const route of routes) {
+    for (const file of [
+      ...(route.layouts ?? []),
+      ...(route.middleware ?? []),
+      ...(route.errorBoundary ? [route.errorBoundary] : []),
+    ]) {
+      if (file && !supportFiles.includes(file)) supportFiles.push(file);
+    }
+  }
+  for (let i = 0; i < supportFiles.length; i++) {
+    const file = supportFiles[i]!;
+    imports.push(`import * as support_${i} from "${importPath(buildDir, file)}";`);
+    // Registered unwrapped: these export a component or middleware, not a route
+    // module with loader/action semantics.
+    moduleBodys.push(`  "${toPosix(file)}": support_${i}`);
+  }
+
   return `${imports.join("\n")}\n\n${moduleHelpers.join("\n")}\n\nconst ${routes.map((_, i) => `module_${i} = makeModule_${i}(route_${i}, ${routes[i]!.dataFile ? `data_${i}` : "undefined"})`).join(";\nconst ")};\n\nexport const routes = {\n${bodies.join(",\n")}\n};\n\nexport const modules = {\n${moduleBodys.join(",\n")}\n};\n`;
 }
 

package/test/server-bundle-support-modules.test.ts

@@ -0,0 +1,68 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { buildProject } from "../src/manifest";
+
+/**
+ * The server bundle must carry every module the server renders through, not
+ * just the page.
+ *
+ * A page's layout is loaded during server rendering. When it is missing from
+ * `modules`, the renderer falls back to `await import(file)` on the layout's
+ * SOURCE path. That resolves in a checkout, where the source sits beside the
+ * build output, and fails in a deployed image that ships only the build — so
+ * the route renders locally and returns 500 in production. It also fails
+ * outright on runtimes that cannot resolve a dynamic import.
+ */
+
+const projectDir = resolve(import.meta.dir, "fixtures", "project");
+const outDir = join(projectDir, ".moonshine");
+
+function clean() {
+  if (existsSync(outDir)) rmSync(outDir, { recursive: true, force: true });
+}
+
+afterAll(clean);
+
+describe("server bundle support modules", () => {
+  test("registers the layouts its routes render through", async () => {
+    const manifest = await buildProject({ projectDir });
+
+    const layouts = [
+      ...new Set(manifest.routes.flatMap((route) => route.layouts ?? [])),
+    ];
+    expect(layouts.length).toBeGreaterThan(0);
+
+    const { modules } = await import(join(outDir, "dist", "server.js"));
+    // The bundle keys modules by their build-time absolute path, while the
+    // manifest stores them relative to the project.
+    for (const layout of layouts) {
+      expect(Object.keys(modules)).toContain(join(projectDir, layout));
+    }
+  });
+
+  test("a registered layout is the real module, not a route wrapper", async () => {
+    const manifest = await buildProject({ projectDir });
+    const layout = join(
+      projectDir,
+      manifest.routes.flatMap((route) => route.layouts ?? [])[0]!,
+    );
+
+    const { modules } = await import(join(outDir, "dist", "server.js"));
+
+    // Layouts export a component; wrapping them in loader/action semantics
+    // would make the renderer read `default` off the wrong object.
+    expect(modules[layout]).toBeDefined();
+    expect(typeof modules[layout].default).toBe("function");
+  });
+
+  test("still registers pages by id and file", async () => {
+    const manifest = await buildProject({ projectDir });
+    const route = manifest.routes[0]!;
+
+    const { modules } = await import(join(outDir, "dist", "server.js"));
+
+    expect(modules[route.id]).toBeDefined();
+    expect(modules[join(projectDir, route.file)]).toBeDefined();
+  });
+});