bosia 0.5.2 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.5.2",
+	"version": "0.5.3",
 	"type": "module",
 	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing inspired by SvelteKit. No Node.js, no Vite, no adapters.",
 	"keywords": [

package/src/core/apiResolver.ts

@@ -0,0 +1,36 @@
+import { findMatch } from "./matcher.ts";
+import type { RouteMatch } from "./types.ts";
+
+interface ApiRouteLike {
+	pattern: string;
+	module: () => Promise<{ prerender?: unknown }>;
+}
+
+/**
+ * Resolve an incoming request path to an API route, applying the `.json` alias.
+ *
+ * When the URL ends in `.json` the bare path is tried first. If the bare-path
+ * route opted into `prerender = true`, the alias wins — this prevents a
+ * catch-all sibling (e.g. `/api/components/[...path]`) from swallowing the
+ * `.json` suffix as part of its rest-segment param and returning a 4xx from
+ * the catch-all handler. Non-prerender bare-path matches fall through to the
+ * literal `.json` path so legitimate `<segment>.json` routes still resolve.
+ */
+export async function resolveApiMatch<T extends ApiRouteLike>(
+	routes: T[],
+	path: string,
+): Promise<RouteMatch<T> | null> {
+	if (path.endsWith(".json")) {
+		const bare = path.slice(0, -".json".length);
+		const aliased = findMatch(routes, bare);
+		if (aliased) {
+			try {
+				const mod = await aliased.route.module();
+				if (mod.prerender === true) return aliased;
+			} catch {
+				/* fall through to literal-path match */
+			}
+		}
+	}
+	return findMatch(routes, path);
+}

package/src/core/prerender.ts

@@ -32,6 +32,8 @@ const PRERENDER_TIMEOUT = Number(process.env.PRERENDER_TIMEOUT) || 5_000; // 5s
 
 interface PrerenderTarget {
 	path: string;
+	kind: "page" | "api";
+	/** Page targets only; APIs always write a single `.json` file regardless of slash mode. */
 	trailingSlash: TrailingSlash;
 }
 
@@ -86,6 +88,15 @@ export function prerenderDataPath(routePath: string): string {
 	return routePath === "/" ? "/index.json" : `${routePath.replace(/\/$/, "")}.json`;
 }
 
+/**
+ * Output filename for a prerendered API route. Always emits a single `.json`
+ * file at the route's path (no trailing-slash variants — static hosts serve
+ * `/api/foo.json` regardless of the request URL's slash).
+ */
+export function prerenderApiOutPath(routePath: string): string {
+	return `./dist/prerendered${routePath.replace(/\/$/, "")}.json`;
+}
+
 async function detectPrerenderRoutes(manifest: RouteManifest): Promise<PrerenderTarget[]> {
 	const targets: PrerenderTarget[] = [];
 	for (const route of manifest.pages) {
@@ -116,6 +127,7 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 				for (const entry of entryList) {
 					targets.push({
 						path: substituteParams(route.pattern, entry),
+						kind: "page",
 						trailingSlash: ts,
 					});
 				}
@@ -123,9 +135,40 @@ async function detectPrerenderRoutes(manifest: RouteManifest): Promise<Prerender
 				console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
 			}
 		} else {
-			targets.push({ path: route.pattern, trailingSlash: ts });
+			targets.push({ path: route.pattern, kind: "page", trailingSlash: ts });
 		}
 	}
+
+	for (const route of manifest.apis) {
+		const filePath = join("src", "routes", route.server);
+		const content = await Bun.file(filePath).text();
+		if (!/export\s+const\s+prerender\s*=\s*true/.test(content)) continue;
+
+		if (route.pattern.includes("[")) {
+			try {
+				const mod = await import(join(process.cwd(), filePath));
+				if (typeof mod.entries !== "function") {
+					console.warn(
+						`   ⚠️  ${route.pattern} has prerender=true but no entries() export — skipped`,
+					);
+					continue;
+				}
+				const entryList: Record<string, string>[] = await mod.entries();
+				for (const entry of entryList) {
+					targets.push({
+						path: substituteParams(route.pattern, entry),
+						kind: "api",
+						trailingSlash: "never",
+					});
+				}
+			} catch (err) {
+				console.error(`   ❌ Failed to resolve entries() for ${route.pattern}:`, err);
+			}
+		} else {
+			targets.push({ path: route.pattern, kind: "api", trailingSlash: "never" });
+		}
+	}
+
 	return targets;
 }
 
@@ -178,8 +221,21 @@ export async function prerenderStaticRoutes(manifest: RouteManifest): Promise<vo
 
 		mkdirSync("./dist/prerendered", { recursive: true });
 
-		for (const { path: routePath, trailingSlash: ts } of targets) {
+		for (const { path: routePath, kind, trailingSlash: ts } of targets) {
 			try {
+				if (kind === "api") {
+					// APIs: fetch the bare route URL, write body to `<path>.json`.
+					const res = await fetch(`${base}${routePath.replace(/\/$/, "")}`, {
+						signal: AbortSignal.timeout(PRERENDER_TIMEOUT),
+					});
+					const body = await res.text();
+					const outPath = prerenderApiOutPath(routePath);
+					mkdirSync(outPath.substring(0, outPath.lastIndexOf("/")), { recursive: true });
+					writeFileSync(outPath, body);
+					console.log(`   ✅ ${routePath} → ${outPath}`);
+					continue;
+				}
+
 				// Hit the canonical URL so the server doesn't 308 us mid-prerender
 				const canonicalRoute = canonicalRouteFor(routePath, ts);
 

package/src/core/server.ts

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 
 import { findMatch, compileRoutes, canonicalPathname } from "./matcher.ts";
+import { resolveApiMatch } from "./apiResolver.ts";
 import { apiRoutes, serverRoutes } from "bosia:routes";
 import { loadPlugins } from "./config.ts";
 import type { RouteManifest } from "./types.ts";
@@ -338,8 +339,8 @@ async function resolve(event: RequestEvent): Promise<Response> {
 		}
 	}
 
-	// API routes (+server.ts)
-	const apiMatch = findMatch(apiRoutes, path);
+	// API routes (+server.ts) — resolve with `.json` alias preference.
+	const apiMatch = await resolveApiMatch(apiRoutes, path);
 	if (apiMatch) {
 		try {
 			const mod = await apiMatch.route.module();