bosia 0.1.26 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosia",
-  "version": "0.1.26",
+  "version": "0.2.1",
   "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/build.ts

@@ -1,7 +1,6 @@
 import { SveltePlugin } from "bun-plugin-svelte";
 import { writeFileSync, rmSync, mkdirSync } from "fs";
 import { join, relative } from "path";
-import { spawnSync } from "bun";
 
 import { scanRoutes } from "./scanner.ts";
 import { generateRoutesFile } from "./routeFile.ts";
@@ -19,6 +18,7 @@ const CORE_DIR = import.meta.dir;
 
 const isProduction = process.env.NODE_ENV === "production";
 
+const buildStart = performance.now();
 console.log("🏗️  Starting Bosia build...\n");
 
 // 0. Load .env files (before cleaning .bosia so loadEnv can set process.env early)
@@ -55,21 +55,17 @@ ensureRootDirs();
 // 2d. Generate .bosia/env.server.ts, .bosia/env.client.ts, .bosia/types/env.d.ts
 generateEnvModules(classifiedEnv);
 
-// 3. Build Tailwind CSS
-console.log("\n🎨 Building Tailwind CSS...");
+// 3. Start Tailwind CSS (async — runs concurrently with client+server builds)
 const tailwindBin = resolveBosiaBin("tailwindcss");
-const tailwindResult = spawnSync(
+const tailwindProc = Bun.spawn(
     [tailwindBin, "-i", "./src/app.css", "-o", "./public/bosia-tw.css", ...(isProduction ? ["--minify"] : [])],
     {
         cwd: process.cwd(),
         env: { ...process.env, NODE_PATH: BOSIA_NODE_PATH },
+        stderr: "pipe",
     },
 );
-if (tailwindResult.exitCode !== 0) {
-    console.error("❌ Tailwind CSS build failed:\n" + tailwindResult.stderr.toString());
-    process.exit(1);
-}
-console.log("✅ Tailwind CSS built: public/bosia-tw.css");
+const tailwindPromise = tailwindProc.exited;
 
 // Separate plugin instances per build target ($env resolves differently)
 const clientPlugin = makeBosiaPlugin("browser");
@@ -84,9 +80,9 @@ for (const [key, value] of Object.entries(classifiedEnv.privateStatic)) {
     staticDefines[`import.meta.env.${key}`] = JSON.stringify(value);
 }
 
-// 5. Build client bundle
-console.log("\n📦 Building client bundle...");
-const clientResult = await Bun.build({
+// 5. Build Tailwind + client + server bundles in parallel
+console.log("\n📦 Building Tailwind + client + server...");
+const clientPromise = Bun.build({
     entrypoints: [join(CORE_DIR, "client", "hydrate.ts")],
     outdir: "./dist/client",
     target: "browser",
@@ -100,24 +96,7 @@ const clientResult = await Bun.build({
     plugins: [clientPlugin, SveltePlugin()],
 });
 
-if (!clientResult.success) {
-    console.error("❌ Client build failed:");
-    for (const msg of clientResult.logs) console.error(msg);
-    process.exit(1);
-}
-
-// 6. Collect output files for dist/manifest.json
-const jsFiles: string[] = [];
-const cssFiles: string[] = [];
-for (const output of clientResult.outputs) {
-    const rel = relative("./dist/client", output.path);
-    if (output.path.endsWith(".js")) jsFiles.push(rel);
-    if (output.path.endsWith(".css")) cssFiles.push(rel);
-}
-
-// 7. Build server bundle (before writing manifest so we can record the entry)
-console.log("\n📦 Building server bundle...");
-const serverResult = await Bun.build({
+const serverPromise = Bun.build({
     entrypoints: [join(CORE_DIR, "server.ts")],
     outdir: "./dist/server",
     target: "bun",
@@ -128,12 +107,40 @@ const serverResult = await Bun.build({
     plugins: [serverPlugin, SveltePlugin()],
 });
 
+const [tailwindExitCode, clientResult, serverResult] = await Promise.all([
+    tailwindPromise,
+    clientPromise,
+    serverPromise,
+]);
+
+if (tailwindExitCode !== 0) {
+    const stderr = await new Response(tailwindProc.stderr).text();
+    console.error("❌ Tailwind CSS build failed:\n" + stderr);
+    process.exit(1);
+}
+console.log("✅ Tailwind CSS built: public/bosia-tw.css");
+
+if (!clientResult.success) {
+    console.error("❌ Client build failed:");
+    for (const msg of clientResult.logs) console.error(msg);
+    process.exit(1);
+}
+
 if (!serverResult.success) {
     console.error("❌ Server build failed:");
     for (const msg of serverResult.logs) console.error(msg);
     process.exit(1);
 }
 
+// 6. Collect output files for dist/manifest.json
+const jsFiles: string[] = [];
+const cssFiles: string[] = [];
+for (const output of clientResult.outputs) {
+    const rel = relative("./dist/client", output.path);
+    if (output.path.endsWith(".js")) jsFiles.push(rel);
+    if (output.path.endsWith(".css")) cssFiles.push(rel);
+}
+
 // Entry is always "index.js" due to naming: { entry: "index.[ext]" }
 const serverEntry = serverResult.outputs
     .find(o => o.path.endsWith("index.js"))
@@ -157,4 +164,4 @@ await prerenderStaticRoutes(manifest);
 // 10. Generate static site output (HTML + client assets + public → dist/static/)
 generateStaticSite();
 
-console.log("\n🎉 Build complete!");
+console.log(`\n🎉 Build complete in ${Math.round(performance.now() - buildStart)}ms!`);

package/src/core/client/hydrate.ts

@@ -2,9 +2,12 @@ import { hydrate } from "svelte";
 import App from "./App.svelte";
 import { router } from "./router.svelte.ts";
 import { initPrefetch } from "./prefetch.ts";
-import { findMatch } from "../matcher.ts";
+import { findMatch, compileRoutes } from "../matcher.ts";
 import { clientRoutes } from "bosia:routes";
 
+// Pre-compile route patterns into RegExp at startup (shared by App.svelte and router via module reference)
+compileRoutes(clientRoutes);
+
 // ─── Hydration ────────────────────────────────────────────
 
 async function main() {

package/src/core/dedup.ts

@@ -0,0 +1,32 @@
+// packages/bosia/src/core/dedup.ts
+// Request deduplication for concurrent identical GET requests to /__bosia/data/
+
+const inflight = new Map<string, Promise<any>>();
+
+const AUTH_COOKIE_RE = /(?:^|;\s*)authorization=([^;]*)/i;
+
+/** Build dedup key from route URL + request identity. Sort search params for consistency. */
+export function dedupKey(url: URL, request: Request): string {
+    let path = url.pathname;
+    if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+    const sorted = new URLSearchParams([...url.searchParams.entries()].sort());
+    const search = sorted.toString();
+    const base = search ? `${path}?${search}` : path;
+
+    const authHeader = request.headers.get("authorization") ?? "";
+    const cookieHeader = request.headers.get("cookie") ?? "";
+    const match = cookieHeader.match(AUTH_COOKIE_RE);
+    const authCookie = match?.[1] ?? "";
+    const identity = authHeader || authCookie;
+    if (!identity) return base;
+    return `${base}|${Bun.hash(identity).toString(36)}`;
+}
+
+/** Run `fn` with dedup. Concurrent calls with same key share the in-flight promise. */
+export function dedup<T>(key: string, fn: () => Promise<T>): Promise<T> {
+    const existing = inflight.get(key);
+    if (existing) return existing;
+    const promise = fn().finally(() => inflight.delete(key));
+    inflight.set(key, promise);
+    return promise;
+}

package/src/core/hooks.ts

@@ -85,10 +85,12 @@ type MaybePromise<T> = T | Promise<T>;
  */
 export function sequence(...handlers: Handle[]): Handle {
     return ({ event, resolve }) => {
-        function apply(i: number, e: RequestEvent): MaybePromise<Response> {
-            if (i >= handlers.length) return resolve(e);
-            return handlers[i]!({ event: e, resolve: (next) => apply(i + 1, next) });
+        let next = resolve;
+        for (let i = handlers.length - 1; i >= 0; i--) {
+            const handler = handlers[i]!;
+            const prev = next;
+            next = (e: RequestEvent) => handler({ event: e, resolve: prev });
         }
-        return apply(0, event);
+        return next(event);
     };
 }

package/src/core/matcher.ts

@@ -9,6 +9,78 @@ import type { RouteMatch } from "./types.ts";
 //   2. Dynamic match      — "/blog/[slug]" matches "/blog/hello"
 //   3. Catch-all match    — "/[...rest]" matches anything
 
+// ─── Compiled Route Types ────────────────────────────────
+
+interface CompiledRoute {
+    regex: RegExp;
+    paramNames: string[];
+    isExact: boolean;
+}
+
+// ─── Pattern Compiler ────────────────────────────────────
+
+/** Escape regex special chars in a literal string segment. */
+function escapeRegex(s: string): string {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Pre-compile a route pattern into a RegExp for fast matching.
+ */
+function compilePattern(pattern: string): CompiledRoute {
+    // No dynamic segments — exact match via ===
+    if (!pattern.includes("[")) {
+        return { regex: null!, paramNames: [], isExact: true };
+    }
+
+    const paramNames: string[] = [];
+
+    // Catch-all: /prefix/[...name]
+    const catchallMatch = pattern.match(/^(.*?)\/\[\.\.\.(\w+)\]$/);
+    if (catchallMatch) {
+        const prefix = catchallMatch[1] || "";
+        paramNames.push(catchallMatch[2]!);
+        const escaped = prefix ? escapeRegex(prefix) : "";
+        // Root catch-all /[...rest] must have at least one char after /
+        const regex = prefix
+            ? new RegExp(`^${escaped}\\/(.+)$`)
+            : new RegExp(`^\\/(.+)$`);
+        return { regex, paramNames, isExact: false };
+    }
+
+    // Dynamic segments: /blog/[slug]/comments → ^\/blog\/([^/]+)\/comments$
+    const segments = pattern.split("/").filter(Boolean);
+    let regexStr = "^";
+    for (const seg of segments) {
+        regexStr += "\\/";
+        if (seg.startsWith("[") && seg.endsWith("]")) {
+            paramNames.push(seg.slice(1, -1));
+            regexStr += "([^/]+)";
+        } else {
+            regexStr += escapeRegex(seg);
+        }
+    }
+    regexStr += "$";
+
+    return { regex: new RegExp(regexStr), paramNames, isExact: false };
+}
+
+/**
+ * Pre-compile all route patterns in-place.
+ * Mutates each route by adding a `_compiled` property.
+ * Call once at startup — all modules sharing the same route array see the result.
+ */
+export function compileRoutes<T extends { pattern: string }>(
+    routes: T[],
+): (T & { _compiled: CompiledRoute })[] {
+    for (const route of routes) {
+        (route as any)._compiled = compilePattern(route.pattern);
+    }
+    return routes as (T & { _compiled: CompiledRoute })[];
+}
+
+// ─── Legacy Pattern Matcher (fallback for uncompiled routes) ─
+
 /**
  * Match a URL pathname against a single route pattern.
  * Returns extracted params if matched, null otherwise.
@@ -60,6 +132,31 @@ function matchPattern(
     return params;
 }
 
+// ─── Route Matching ──────────────────────────────────────
+
+/**
+ * Match a compiled route against a pathname using regex.
+ * Returns extracted params if matched, null otherwise.
+ */
+function matchCompiled(
+    compiled: CompiledRoute,
+    pattern: string,
+    pathname: string,
+): Record<string, string> | null {
+    if (compiled.isExact) {
+        return pattern === pathname ? {} : null;
+    }
+
+    const m = compiled.regex.exec(pathname);
+    if (!m) return null;
+
+    const params: Record<string, string> = {};
+    for (let i = 0; i < compiled.paramNames.length; i++) {
+        params[compiled.paramNames[i]!] = m[i + 1]!;
+    }
+    return params;
+}
+
 /**
  * Find the first matching route from a list.
  * Routes must be pre-sorted by priority (exact → dynamic → catch-all).
@@ -75,7 +172,10 @@ export function findMatch<T extends { pattern: string }>(
     }
 
     for (const route of routes) {
-        const params = matchPattern(route.pattern, pathname);
+        const compiled = (route as any)._compiled as CompiledRoute | undefined;
+        const params = compiled
+            ? matchCompiled(compiled, route.pattern, pathname)
+            : matchPattern(route.pattern, pathname);
         if (params !== null) return { route, params };
     }
 

package/src/core/server.ts

@@ -3,8 +3,12 @@ import { Elysia } from "elysia";
 import { existsSync } from "fs";
 import { join, resolve as resolvePath } from "path";
 
-import { findMatch } from "./matcher.ts";
+import { findMatch, compileRoutes } from "./matcher.ts";
 import { apiRoutes, serverRoutes } from "bosia:routes";
+
+// Pre-compile route patterns into RegExp at startup (shared by renderer.ts via module reference)
+compileRoutes(apiRoutes);
+compileRoutes(serverRoutes);
 import type { Handle, RequestEvent } from "./hooks.ts";
 import { HttpError, Redirect, ActionFailure } from "./errors.ts";
 import { CookieJar } from "./cookies.ts";
@@ -15,6 +19,7 @@ import type { CorsConfig } from "./cors.ts";
 import { isDev, compress, isStaticPath } from "./html.ts";
 import { loadRouteData, loadMetadata, renderSSRStream, renderErrorPage, renderPageWithFormData } from "./renderer.ts";
 import { getServerTime } from "../lib/utils.ts";
+import { dedup, dedupKey } from "./dedup.ts";
 
 // ─── User Hooks ──────────────────────────────────────────
 // Load src/hooks.server.ts if present. Uses process.cwd() so
@@ -128,29 +133,30 @@ async function resolve(event: RequestEvent): Promise<Response> {
         }
         // Rewrite event.url so logging middleware sees the real page path, not /__bosia/data
         event.url = routeUrl;
+        const dedupKeyStr = dedupKey(routeUrl, request);
         try {
-            const pageMatch = findMatch(serverRoutes, routeUrl.pathname);
-            const data = await loadRouteData(routeUrl, locals, request, cookies);
-            if (!data) {
-                const cc = (cookies as CookieJar).accessed ? "private, no-cache" : "public, max-age=0, must-revalidate";
-                return compress(JSON.stringify({ pageData: {}, layoutData: [] }), "application/json", request, 200, { "Cache-Control": cc });
-            }
+            const result = await dedup(dedupKeyStr, async () => {
+                const pageMatch = findMatch(serverRoutes, routeUrl.pathname);
+                const data = await loadRouteData(routeUrl, locals, request, cookies);
 
-            // Include metadata for client-side title/description updates
-            let metadata = null;
-            if (pageMatch) {
-                try {
-                    const meta = await loadMetadata(pageMatch.route, pageMatch.params, routeUrl, locals, cookies, request);
-                    if (meta) metadata = { title: meta.title, description: meta.description };
-                } catch { /* non-fatal */ }
-            }
+                let metadata = null;
+                if (pageMatch) {
+                    try {
+                        const meta = await loadMetadata(pageMatch.route, pageMatch.params, routeUrl, locals, cookies, request);
+                        if (meta) metadata = { title: meta.title, description: meta.description };
+                    } catch { /* non-fatal */ }
+                }
+
+                return { data, metadata, cookiesAccessed: (cookies as CookieJar).accessed };
+            });
 
-            const cacheControl = (cookies as CookieJar).accessed
-                ? "private, no-cache"
-                : "public, max-age=0, must-revalidate";
-            const cacheHeaders = { "Cache-Control": cacheControl };
+            const cookiesWereAccessed = (cookies as CookieJar).accessed || result.cookiesAccessed;
+            const cc = cookiesWereAccessed ? "private, no-cache" : "public, max-age=0, must-revalidate";
 
-            return compress(JSON.stringify({ ...data, metadata }), "application/json", request, 200, cacheHeaders);
+            if (!result.data) {
+                return compress(JSON.stringify({ pageData: {}, layoutData: [] }), "application/json", request, 200, { "Cache-Control": cc });
+            }
+            return compress(JSON.stringify({ ...result.data, metadata: result.metadata }), "application/json", request, 200, { "Cache-Control": cc });
         } catch (err) {
             if (err instanceof Redirect) {
                 return compress(JSON.stringify({ redirect: err.location, status: err.status }), "application/json", request);