@tschk/moonshine-compiler 0.3.1 → 0.3.3

package/package.json

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

package/src/build.ts

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
-import type { RouteArtifact } from "@tschk/moonshine-framework";
+import { PUBLIC_DIR, type RouteArtifact } from "@tschk/moonshine-framework";
 import { toPosix } from "./path.js";
 
 export type BundleAsset = {
@@ -125,13 +125,14 @@ function toOutRelative(outDir: string, outputPath: string): string {
 async function buildBundleAssets(
   outDir: string,
   outputPaths: string[],
+  urlBase?: string,
 ): Promise<BundleAsset[]> {
   const assets: BundleAsset[] = [];
   for (const outputPath of outputPaths) {
     const file = toOutRelative(outDir, outputPath);
     assets.push({
       file,
-      path: `/${file}`,
+      path: `/${toOutRelative(urlBase ?? outDir, outputPath)}`,
       integrity: await hashFile(outputPath),
     });
   }
@@ -159,6 +160,11 @@ export async function buildBundles(options: {
   const distDir = resolve(options.outDir, "dist");
   await mkdir(distDir, { recursive: true });
 
+  // Client output goes in its own directory because that directory is what the
+  // server exposes over HTTP; the server bundle must never sit inside it.
+  const publicDir = resolve(options.outDir, PUBLIC_DIR);
+  await mkdir(publicDir, { recursive: true });
+
   const serverOutputs = await runBuild(
     serverEntry,
     distDir,
@@ -166,11 +172,15 @@ export async function buildBundles(options: {
     "bun",
   );
   const clientOutputs = clientEntry
-    ? await runBuild(clientEntry, distDir, options.root, "browser")
+    ? await runBuild(clientEntry, publicDir, options.root, "browser")
     : [];
 
   const serverAssets = await buildBundleAssets(options.outDir, serverOutputs);
-  const clientAssets = await buildBundleAssets(options.outDir, clientOutputs);
+  const clientAssets = await buildBundleAssets(
+    options.outDir,
+    clientOutputs,
+    publicDir,
+  );
 
   return {
     server: serverAssets,

package/src/discover.ts

@@ -1,12 +1,19 @@
 import { readdir } from "node:fs/promises";
 import { dirname, basename, join, relative, resolve } from "node:path";
 import type { RouteDefinition, RenderMode } from "@tschk/moonshine-framework";
-import { mergeRoutes } from "./inherit.js";
+import { mergeRoutes, type RouteConvention } from "./inherit.js";
 import { toPosix } from "./path.js";
 
+export type { RouteConvention } from "./inherit.js";
+
 export type DiscoverOptions = {
   routesDir: string;
   programmatic?: RouteDefinition[];
+  /**
+   * File-system routing dialect. `moonshine` is the native `src/routes` layout;
+   * the two `next-*` values read an adopted Next app in place.
+   */
+  convention?: RouteConvention;
 };
 
 export function segmentToPattern(segment: string): string {
@@ -43,15 +50,109 @@ async function* walkFiles(dir: string): AsyncGenerator<string> {
   }
 }
 
-export async function discoverRoutes(
-  options: DiscoverOptions,
-): Promise<RouteDefinition[]> {
-  const routesDir = resolve(options.routesDir);
-  const files: string[] = [];
-  for await (const file of walkFiles(routesDir)) {
-    files.push(file);
+const ROUTE_EXT = /\.(tsx?|jsx?|mjs)$/;
+
+/** Segments the App Router strips from the URL, or refuses to route at all. */
+function isRouteGroup(segment: string): boolean {
+  return /^\([^)]*\)$/.test(segment);
+}
+
+function isPrivateSegment(segment: string): boolean {
+  return segment.startsWith("_") || segment.startsWith("@");
+}
+
+/** Directory chain of an App Router file, as URL pattern plus a stable id. */
+function appRouterPath(dir: string): { path: string; id: string } | null {
+  const parts = dir === "." ? [] : dir.split("/").filter(Boolean);
+  const pattern: string[] = [];
+  for (const part of parts) {
+    if (isPrivateSegment(part)) return null;
+    if (isRouteGroup(part)) continue;
+    pattern.push(segmentToPattern(part));
   }
+  return {
+    path: pattern.length ? `/${pattern.join("/")}` : "/",
+    id: parts.length ? parts.join("/") : "index",
+  };
+}
+
+/**
+ * `app/**\/page.tsx` and `app/**\/route.ts`. Every other App Router special
+ * (`layout`, `loading`, `template`, `not-found`, `error`, `default`) is either
+ * picked up by layout inheritance or has no moonshine equivalent.
+ */
+function discoverNextApp(
+  files: string[],
+  routesDir: string,
+): RouteDefinition[] {
+  const raw: RouteDefinition[] = [];
+  for (const file of files) {
+    const rel = toPosix(relative(routesDir, file));
+    const name = basename(rel);
+    if (!ROUTE_EXT.test(name)) continue;
+    const base = name.replace(ROUTE_EXT, "");
+    if (base !== "page" && base !== "route") continue;
+
+    const located = appRouterPath(dirname(rel));
+    if (!located) continue;
+
+    const mode: RenderMode | undefined = base === "route" ? "api" : undefined;
+    raw.push({
+      id: base === "route" ? `${located.id}#route` : located.id,
+      path: located.path,
+      file,
+      ...(mode && { mode }),
+    });
+  }
+  return raw;
+}
 
+/** Files the Pages Router treats as framework hooks rather than routes. */
+const PAGES_RESERVED = new Set([
+  "_app",
+  "_document",
+  "_error",
+  "middleware",
+  "_middleware",
+]);
+
+/** `pages/**\/*.tsx`, with `pages/api/**` mapped onto moonshine's api mode. */
+function discoverNextPages(
+  files: string[],
+  routesDir: string,
+): RouteDefinition[] {
+  const raw: RouteDefinition[] = [];
+  for (const file of files) {
+    const rel = toPosix(relative(routesDir, file));
+    const name = basename(rel);
+    if (!ROUTE_EXT.test(name)) continue;
+    if (/\.(test|spec|d)\.[jt]sx?$/.test(name)) continue;
+    const base = name.replace(ROUTE_EXT, "");
+    if (PAGES_RESERVED.has(base)) continue;
+
+    const dir = dirname(rel);
+    const parts = dir === "." ? [] : dir.split("/").filter(Boolean);
+    if (parts.some(isPrivateSegment)) continue;
+
+    const segments = parts.map(segmentToPattern);
+    if (base !== "index") segments.push(segmentToPattern(base));
+    const path = segments.length ? `/${segments.join("/")}` : "/";
+    const mode: RenderMode | undefined = parts[0] === "api" ? "api" : undefined;
+
+    raw.push({
+      id: dir === "." ? base : `${dir}/${base}`,
+      path,
+      file,
+      ...(mode && { mode }),
+    });
+  }
+  return raw;
+}
+
+function discoverMoonshine(
+  files: string[],
+  routesDir: string,
+): RouteDefinition[] {
   const fileSet = new Set(files);
   const raw: RouteDefinition[] = [];
 
@@ -88,18 +189,41 @@ export async function discoverRoutes(
     const mode: RenderMode | undefined =
       suffix === "server" ? "api" : undefined;
 
-    const route: RouteDefinition = {
+    raw.push({
       id,
       path: routePath,
       file,
       ...(dataFile && { dataFile }),
       ...(mode && { mode }),
-    };
+    });
+  }
+
+  return raw;
+}
 
-    raw.push(route);
+export async function discoverRoutes(
+  options: DiscoverOptions,
+): Promise<RouteDefinition[]> {
+  const routesDir = resolve(options.routesDir);
+  const convention = options.convention ?? "moonshine";
+  const files: string[] = [];
+  for await (const file of walkFiles(routesDir)) {
+    files.push(file);
   }
 
-  const merged = mergeRoutes(raw, options.programmatic ?? [], routesDir);
+  const raw =
+    convention === "next-app"
+      ? discoverNextApp(files, routesDir)
+      : convention === "next-pages"
+        ? discoverNextPages(files, routesDir)
+        : discoverMoonshine(files, routesDir);
+
+  const merged = mergeRoutes(
+    raw,
+    options.programmatic ?? [],
+    routesDir,
+    convention,
+  );
   merged.sort(
     (a, b) => a.path.localeCompare(b.path) || a.id.localeCompare(b.id),
   );

package/src/index.ts

@@ -7,6 +7,7 @@ export {
 export {
   discoverRoutes,
   type DiscoverOptions,
+  type RouteConvention,
   segmentToPattern,
 } from "./discover.js";
 export { mergeRoutes } from "./inherit.js";

package/src/inherit.ts

@@ -6,20 +6,52 @@ import { toPosix } from "./path.js";
 
 type SpecialKind = "layout" | "error" | "middleware";
 
+/**
+ * Moonshine names co-located specials `+layout.tsx`; the Next App Router names
+ * them `layout.tsx`. Only the prefix differs, so one lookup serves both.
+ */
+export type RouteConvention = "moonshine" | "next-app" | "next-pages";
+
+const specialPrefix: Readonly<Record<RouteConvention, string | null>> = {
+  moonshine: "+",
+  "next-app": "",
+  // The Pages Router has no per-directory specials; `_app` wraps everything.
+  "next-pages": null,
+};
+
+/**
+ * The App Router's `error.tsx` takes `{ error, reset }` and its root
+ * `middleware.ts` runs on the edge, and neither matches the moonshine
+ * contract, so only layouts are inherited under that convention.
+ */
+const specialKinds: Readonly<Record<RouteConvention, SpecialKind[]>> = {
+  moonshine: ["layout", "error", "middleware"],
+  "next-app": ["layout"],
+  "next-pages": [],
+};
+
 function findSpecial(
   routesDir: string,
   dir: string,
   kind: SpecialKind,
+  convention: RouteConvention,
 ): string | undefined {
-  const base = join(routesDir, dir, `+${kind}`);
-  for (const ext of [".tsx", ".ts"]) {
+  const prefix = specialPrefix[convention];
+  if (prefix === null) return undefined;
+  if (!specialKinds[convention].includes(kind)) return undefined;
+  const base = join(routesDir, dir, `${prefix}${kind}`);
+  for (const ext of [".tsx", ".ts", ".jsx", ".js"]) {
     const candidate = `${base}${ext}`;
     if (existsSync(candidate)) return candidate;
   }
   return undefined;
 }
 
-function applyInheritance(routes: RouteDefinition[], routesDir: string): void {
+function applyInheritance(
+  routes: RouteDefinition[],
+  routesDir: string,
+  convention: RouteConvention,
+): void {
   const resolvedDir = resolve(routesDir);
   for (const route of routes) {
     if (!route.file) continue;
@@ -38,11 +70,11 @@ function applyInheritance(routes: RouteDefinition[], routesDir: string): void {
     let errorBoundary: string | undefined;
 
     for (const ancestor of ancestors) {
-      const layout = findSpecial(resolvedDir, ancestor, "layout");
+      const layout = findSpecial(resolvedDir, ancestor, "layout", convention);
       if (layout) layouts.push(layout);
-      const mw = findSpecial(resolvedDir, ancestor, "middleware");
+      const mw = findSpecial(resolvedDir, ancestor, "middleware", convention);
       if (mw) middleware.push(mw);
-      const err = findSpecial(resolvedDir, ancestor, "error");
+      const err = findSpecial(resolvedDir, ancestor, "error", convention);
       if (err) errorBoundary = err;
     }
 
@@ -56,6 +88,7 @@ export function mergeRoutes(
   filesystem: RouteDefinition[],
   programmatic: RouteDefinition[] = [],
   routesDir?: string,
+  convention: RouteConvention = "moonshine",
 ): RouteDefinition[] {
   const map = new Map<string, RouteDefinition>();
   for (const route of filesystem) {
@@ -70,7 +103,7 @@ export function mergeRoutes(
     }
   }
   const merged = [...map.values()];
-  if (routesDir) applyInheritance(merged, routesDir);
+  if (routesDir) applyInheritance(merged, routesDir, convention);
   createRouteGraph(merged);
   return merged;
 }

package/src/manifest.ts

@@ -11,6 +11,7 @@ import { analyzeModule } from "./analyze.js";
 import { buildBundles } from "./build.js";
 import { classifyRoute } from "./classify.js";
 import { discoverRoutes } from "./discover.js";
+import type { RouteConvention } from "./inherit.js";
 import { toPosix } from "./path.js";
 
 export type BuildOptions = {
@@ -19,6 +20,7 @@ export type BuildOptions = {
   outDir?: string;
   programmatic?: RouteDefinition[];
   runtime?: RuntimeTarget;
+  convention?: RouteConvention;
 };
 
 function toProjectRelative(projectDir: string, p: string): string {
@@ -94,6 +96,7 @@ export async function buildProject(
   const rawRoutes = await discoverRoutes({
     routesDir,
     programmatic: options.programmatic,
+    ...(options.convention && { convention: options.convention }),
   });
 
   const buildRoutes: RouteArtifact[] = [];

package/test/manifest.test.ts

@@ -48,14 +48,19 @@ describe("buildProject", () => {
     ]);
     expect(manifest.routes.every((r) => r.runtime === "bun")).toBe(true);
     expect(manifest.entries.server).toBe("dist/server.js");
-    expect(manifest.entries.client).toBe("/dist/client.js");
+    expect(manifest.entries.client).toBe("/client.js");
     expect(manifest.capabilities).toEqual(["islands", "streaming"]);
+    // Client assets build into public/ because that is the only directory the
+    // server exposes; the server bundle must stay outside it.
     expect(manifest.assets.map((a) => a.file)).toEqual([
-      "dist/client.js",
       "dist/server.js",
+      "public/client.js",
     ]);
     for (const asset of manifest.assets) {
-      expect(asset.path).toBe(`/${asset.file}`);
+      const served = asset.file.startsWith("public/");
+      expect(asset.path).toBe(
+        served ? `/${asset.file.slice("public/".length)}` : `/${asset.file}`,
+      );
       expect(asset.integrity).toMatch(/^sha256-[A-Za-z0-9+/]+=?$/);
     }