bini-router 1.0.12 → 1.0.14

package/Readme.md

@@ -352,21 +352,20 @@ server/index.ts
 
 ### 🔺 Vercel
 
-```bash
-pnpm add @hono/vercel
-```
+No extra package needed — Vercel runs a Hono app as a direct default export.
 
 `vite build` auto-generates `api/index.ts`:
 
 ```ts
 // ⚠️ Auto-generated — do not edit. Add routes in src/app/api/ only.
-import { handle } from '@hono/vercel';
-import _route0 from './src/app/api/test';
-import _route1 from './src/app/api/users';
-let app = _route0;
-app = app.route('/', _route1);
-export const config = { runtime: 'edge' };
-export default handle(app);
+import { Hono } from 'hono';
+import _route0 from '../src/app/api/test';
+import _route1 from '../src/app/api/users';
+const app = new Hono();
+app.route('/', _route0);
+app.route('/', _route1);
+export const runtime = 'edge';
+export default app;
 ```
 
 Add `vercel.json`:

package/dist/index.cjs

@@ -544,62 +544,115 @@ function scanApiRoutes(dir, baseRoute = "") {
   }
   return routes;
 }
-async function buildHonoApp(apiDir, enableCors) {
-  const { Hono } = await import("hono");
-  const app = new Hono();
-  if (enableCors) {
-    const { cors } = await import("hono/cors");
-    app.use("*", cors({
-      origin: "*",
-      allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
-      allowHeaders: ["Content-Type", "Authorization"]
-    }));
-  }
-  for (const route of scanApiRoutes(apiDir)) {
-    const filePath = route.filePath;
-    app.all(route.routePath, async (c) => {
-      try {
-        const { pathToFileURL } = await import("url");
-        const mod = await import(pathToFileURL(filePath).href + "?t=" + Date.now());
-        const handler = mod.default;
-        if (!handler) return c.json({ error: "No default export" }, 500);
-        if (typeof handler.fetch === "function") {
-          return await handler.fetch(c.req.raw);
-        }
-        if (typeof handler === "function") {
-          return await handler(c.req.raw);
-        }
-        return c.json({
-          error: "Default export must be a Hono app or async function(req: Request). Do not wrap with handle() or serve() in route files."
-        }, 500);
-      } catch (e) {
-        return c.json({ error: e.message }, 500);
-      }
-    });
+function matchRoute(pattern, pathname) {
+  const patParts = pattern.split("/").filter(Boolean);
+  const urlParts = pathname.split("/").filter(Boolean);
+  const isCatchAll = patParts[patParts.length - 1] === "*";
+  if (isCatchAll) {
+    const prefix = patParts.slice(0, -1);
+    if (urlParts.length < prefix.length) return null;
+    for (let i = 0; i < prefix.length; i++) {
+      if (prefix[i].startsWith(":")) continue;
+      if (prefix[i] !== urlParts[i]) return null;
+    }
+    return { "*": urlParts.slice(prefix.length).join("/") };
+  }
+  if (patParts.length !== urlParts.length) return null;
+  const params = {};
+  for (let i = 0; i < patParts.length; i++) {
+    if (patParts[i].startsWith(":")) {
+      params[patParts[i].slice(1)] = decodeURIComponent(urlParts[i]);
+    } else if (patParts[i] !== urlParts[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+var moduleCache = /* @__PURE__ */ new Map();
+async function importHandler(filePath) {
+  const { pathToFileURL } = await import("url");
+  let mtime = 0;
+  try {
+    mtime = import_fs.default.statSync(filePath).mtimeMs;
+  } catch {
   }
-  return app;
+  const cached = moduleCache.get(filePath);
+  if (cached && cached.mtime === mtime) return cached.handler;
+  const mod = await import(pathToFileURL(filePath).href + "?t=" + mtime);
+  const handler = mod.default ?? null;
+  moduleCache.set(filePath, { mtime, handler });
+  return handler;
 }
 async function handleApiRequest(req, res, next, apiDir, enableCors, getCache, setCache) {
   try {
-    let app = getCache();
-    if (!app) {
-      app = await buildHonoApp(apiDir, enableCors);
-      setCache(app);
+    if (enableCors && req.method === "OPTIONS") {
+      res.statusCode = 204;
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type,Authorization");
+      res.setHeader("Access-Control-Max-Age", "86400");
+      res.end();
+      return;
+    }
+    let cache = getCache();
+    if (!cache) {
+      cache = { routes: scanApiRoutes(apiDir, "/api") };
+      setCache(cache);
     }
     const host = req.headers.host ?? "localhost";
-    const url = `http://${host}/api${req.url}`;
+    const url = `http://${host}${req.url}`;
+    const pathname = new URL(url).pathname;
     const chunks = [];
     for await (const chunk of req) chunks.push(chunk);
     const body = chunks.length > 0 ? Buffer.concat(chunks) : void 0;
+    const method = req.method.toUpperCase();
     const webReq = new Request(url, {
-      method: req.method,
+      method,
       headers: req.headers,
-      body: body?.length ? body : void 0
+      body: !["GET", "HEAD"].includes(method) && body?.length ? body : void 0
     });
-    const webRes = await app.fetch(webReq);
-    res.statusCode = webRes.status;
-    webRes.headers.forEach((v, k) => res.setHeader(k, v));
-    res.end(Buffer.from(await webRes.arrayBuffer()));
+    for (const route of cache.routes) {
+      const handler = await importHandler(route.filePath);
+      if (!handler) continue;
+      let webRes;
+      try {
+        if (typeof handler.fetch === "function") {
+          webRes = await handler.fetch(webReq.clone());
+          if (webRes.status === 404) continue;
+        } else if (typeof handler === "function") {
+          const params = matchRoute(route.routePath, pathname);
+          if (params === null) continue;
+          const existingHeaders = {};
+          webReq.headers.forEach((v, k) => {
+            existingHeaders[k] = v;
+          });
+          const reqWithParams = new Request(webReq.clone(), {
+            headers: { ...existingHeaders, "x-bini-params": JSON.stringify(params) }
+          });
+          webRes = await handler(reqWithParams);
+        } else {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      const finalHeaders = {};
+      webRes.headers.forEach((v, k) => {
+        finalHeaders[k] = v;
+      });
+      if (enableCors) {
+        finalHeaders["access-control-allow-origin"] = "*";
+        finalHeaders["access-control-allow-methods"] = "GET,POST,PUT,PATCH,DELETE,OPTIONS";
+        finalHeaders["access-control-allow-headers"] = "Content-Type,Authorization";
+      }
+      res.statusCode = webRes.status;
+      for (const [k, v] of Object.entries(finalHeaders)) res.setHeader(k, v);
+      res.end(Buffer.from(await webRes.arrayBuffer()));
+      return;
+    }
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: `No API handler found for ${req.url}` }));
   } catch (e) {
     next(e);
   }
@@ -647,13 +700,12 @@ function buildProductionEntry(srcApiDir, platform, enableCors) {
     lines = [
       ...header,
       `import { Hono } from 'hono';`,
-      `import { handle } from '@hono/vercel';`,
       ...corsImport ? [corsImport] : [],
       ...imports,
       ...appSetup,
       ``,
-      `export const config = { runtime: 'edge' };`,
-      `export default handle(app);`
+      `export const runtime = 'edge';`,
+      `export default app;`
     ];
   } else if (platform === "cloudflare") {
     outFile = import_path.default.join(cwd, "worker.ts");
@@ -791,6 +843,7 @@ function biniroute(options = {}) {
     },
     buildEnd() {
       honoCache = null;
+      moduleCache.clear();
       if (debounceTimer) {
         clearTimeout(debounceTimer);
         debounceTimer = null;
@@ -823,16 +876,17 @@ function biniroute(options = {}) {
       });
       if (import_fs.default.existsSync(apiDir)) {
         server.watcher.add(apiDir);
-        const resetApi = () => {
+        const resetApi = (f) => {
           honoCache = null;
+          if (f) moduleCache.delete(f);
           server.ws.send({ type: "full-reload", path: "*" });
         };
-        server.watcher.on("add", (f) => isApiFile(f) && resetApi());
-        server.watcher.on("unlink", (f) => isApiFile(f) && resetApi());
-        server.watcher.on("change", (f) => isApiFile(f) && resetApi());
-        server.middlewares.use(
-          "/api",
-          (req, res, next) => handleApiRequest(
+        server.watcher.on("add", (f) => isApiFile(f) && resetApi(f));
+        server.watcher.on("unlink", (f) => isApiFile(f) && resetApi(f));
+        server.watcher.on("change", (f) => isApiFile(f) && resetApi(f));
+        server.middlewares.use((req, res, next) => {
+          if (!req.url?.startsWith("/api")) return next();
+          handleApiRequest(
             req,
             res,
             next,
@@ -842,17 +896,17 @@ function biniroute(options = {}) {
             (v) => {
               honoCache = v;
             }
-          )
-        );
+          );
+        });
       }
     },
     async configurePreviewServer(server) {
       addSpaFallback(server);
       const apiDir = getApiDir();
       if (!import_fs.default.existsSync(apiDir)) return;
-      server.middlewares.use(
-        "/api",
-        (req, res, next) => handleApiRequest(
+      server.middlewares.use((req, res, next) => {
+        if (!req.url?.startsWith("/api")) return next();
+        handleApiRequest(
           req,
           res,
           next,
@@ -862,8 +916,8 @@ function biniroute(options = {}) {
           (v) => {
             honoCache = v;
           }
-        )
-      );
+        );
+      });
     },
     transformIndexHtml: {
       order: "pre",