bosia 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.5.1",
+	"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/cli/add.ts

@@ -47,10 +47,10 @@ export async function initAddRegistry(root: string | null) {
 	registryIndex = await loadIndex();
 }
 
-export async function runAdd(name: string | undefined, flags: string[] = []) {
-	if (!name) {
+export async function runAdd(names: string[], flags: string[] = []) {
+	if (names.length === 0) {
 		console.error(
-			"❌ Please provide a component name.\n   Usage: bun x bosia@latest add <component> [--local]",
+			"❌ Please provide a component name.\n   Usage: bun x bosia@latest add <component...> [-y] [--local]",
 		);
 		process.exit(1);
 	}
@@ -60,11 +60,15 @@ export async function runAdd(name: string | undefined, flags: string[] = []) {
 		console.log(`⬡ Using local registry: ${registryRoot}\n`);
 	}
 
+	const skipPrompts = flags.includes("-y") || flags.includes("--yes");
+
 	// Load index once to resolve component paths
 	registryIndex = await loadIndex();
 
 	ensureUtils();
-	await addComponent(name, true);
+	for (const name of names) {
+		await addComponent(name, true, { skipPrompts });
+	}
 }
 
 /**

package/src/cli/index.ts

@@ -37,18 +37,20 @@ async function main() {
 			break;
 		}
 		case "add": {
-			const positional = args.filter((a) => !a.startsWith("--"));
-			const flags = args.filter((a) => a.startsWith("--"));
+			const positional = args.filter((a) => !a.startsWith("-"));
+			const flags = args.filter((a) => a.startsWith("-"));
 			const sub = positional[0];
 			if (sub === "block") {
+				const blockFlags = args.filter((a) => a.startsWith("--"));
 				const { runAddBlock } = await import("./block.ts");
-				await runAddBlock(positional[1], flags);
+				await runAddBlock(positional[1], blockFlags);
 			} else if (sub === "theme") {
+				const themeFlags = args.filter((a) => a.startsWith("--"));
 				const { runAddTheme } = await import("./theme.ts");
-				await runAddTheme(positional[1], flags);
+				await runAddTheme(positional[1], themeFlags);
 			} else {
 				const { runAdd } = await import("./add.ts");
-				await runAdd(sub, flags);
+				await runAdd(positional, flags);
 			}
 			break;
 		}
@@ -72,7 +74,7 @@ Commands:
   build               Build for production
   start               Run the production server
   test [args]         Run tests with bun test (auto-loads .env.test, sets BOSIA_ENV=test)
-  add <component>           Add a UI component from the registry
+  add <component...> [-y]   Add one or more UI components from the registry
   add block <cat>/<name>    Add a composed block from the registry
   add theme <name>          Add a theme (tokens.css) from the registry
   feat <feature>            Add a feature scaffold from the registry [--local]
@@ -87,6 +89,8 @@ Examples:
   bun x bosia test --watch
   bun x bosia test --coverage
   bun x bosia@latest add button              → src/lib/components/ui/button/
+  bun x bosia@latest add button card input   → install multiple at once
+  bun x bosia@latest add -y button card      → auto-confirm overwrites (CI / scripts)
   bun x bosia@latest add shop/cart           → src/lib/components/shop/cart/
   bun x bosia@latest add block cards/feature-editorial
   bun x bosia@latest add theme editorial

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/dev.ts

@@ -212,29 +212,43 @@ const devServer = Bun.serve({
 		// the app's CSRF origin check (gated behind TRUST_PROXY=true, also set in the
 		// app env above) reconstructs the public-facing origin from the dev proxy
 		// rather than the inner-app's host (localhost:APP_PORT).
-		try {
-			const reqUrl = new URL(req.url);
-			const target = new URL(req.url);
-			target.hostname = "localhost";
-			target.port = String(APP_PORT);
-
-			const forwardedHeaders = new Headers(req.headers);
-			forwardedHeaders.set("x-forwarded-host", reqUrl.host);
-			forwardedHeaders.set("x-forwarded-proto", reqUrl.protocol.replace(":", ""));
-
-			return await fetch(
-				new Request(target.toString(), {
-					method: req.method,
-					headers: forwardedHeaders,
-					body: req.body,
-					redirect: "manual",
-				}),
-			);
-		} catch {
-			return new Response("App server is starting...", {
-				status: 503,
-				headers: { "Content-Type": "text/plain", "Retry-After": "1" },
-			});
+		const reqUrl = new URL(req.url);
+		const target = new URL(req.url);
+		target.hostname = "localhost";
+		target.port = String(APP_PORT);
+
+		const forwardedHeaders = new Headers(req.headers);
+		forwardedHeaders.set("x-forwarded-host", reqUrl.host);
+		forwardedHeaders.set("x-forwarded-proto", reqUrl.protocol.replace(":", ""));
+
+		// HMR-driven reloads can land on the proxy before the freshly-respawned
+		// inner has bound APP_PORT. Retry for a few seconds on idempotent HTML
+		// navigations so the browser doesn't get stuck rendering the 503 body.
+		const accept = req.headers.get("accept") ?? "";
+		const retryable =
+			(req.method === "GET" || req.method === "HEAD") && accept.includes("text/html");
+		const deadline = Date.now() + (retryable ? 10_000 : 0);
+
+		while (true) {
+			try {
+				return await fetch(
+					new Request(target.toString(), {
+						method: req.method,
+						headers: forwardedHeaders,
+						body: req.body,
+						redirect: "manual",
+					}),
+				);
+			} catch {
+				if (retryable && Date.now() < deadline) {
+					await Bun.sleep(250);
+					continue;
+				}
+				return new Response("App server is starting...", {
+					status: 503,
+					headers: { "Content-Type": "text/plain", "Retry-After": "1" },
+				});
+			}
 		}
 	},
 });

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();