weifuwu 0.2.3 → 0.3.0

package/README.md

@@ -2,13 +2,19 @@
 
 **Web-standard HTTP framework for Node.js.** `(req, ctx) => Response` — no framework-specific objects, just the Web API your browser already speaks.
 
+### Design
+
+weifuwu doesn't invent its own request/response abstraction. `Request` and `Response` are the same objects you use in `fetch()` — what you learn in the browser applies directly on the server. `ctx` is the only framework object, and it only carries what the router parsed for you (`params`, `query`).
+
+Features like `tsx()`, WebSocket, GraphQL, and AI streaming all follow the same `(req, ctx) => Response` contract. There is no separate concept for "page route" vs "API route" — everything is a handler that returns a `Response`. `tsx()` just generates a `Response` from a React component the same way `router.get()` returns a `Response` from a handler function.
+
 ## Features
 
 - **Web Standard** — `Request` / `Response` / `ReadableStream`, zero abstractions
 - **Trie router** — static > param > wildcard, sub-router mounting, path params
 - **Middleware** — global, path-scoped, route-level — onion model, short-circuit
 - **Built-in middleware** — `auth()`, `cors()`, `logger()`, `rateLimit()`, `compress()`
-- **React SSR + Hydration** — `tsx({ dir })` — page.tsx / load.ts / layout.tsx / route.ts
+- **React SSR + Hydration** — `tsx({ dir })` — page.tsx / load.ts / layout.tsx / route.ts / not-found.tsx
 - **WebSocket** — `router.ws()` with upgrade middleware (auth before connect)
 - **GraphQL** — `router.graphql()` with GraphiQL IDE
 - **AI streaming** — `router.ai()` via Vercel AI SDK
@@ -46,12 +52,15 @@ serve(app.handler(), { port: 3000 })
 pages/
   page.tsx              → GET /           (React component, default export)
   layout.tsx            → root layout     (HTML shell, receives req/ctx, NOT hydrated)
+  not-found.tsx         → 404 error page  (rendered for unmatched routes, wrapped in layout)
   about/page.tsx        → GET /about
   blog/[slug]/
     page.tsx            → GET /blog/:slug
     load.ts             → data fetching   (server-only, default export)
-    route.ts            → POST /blog/:slug (API, named exports GET/POST/...)
+    route.ts            → POST /blog/:slug (API, named exports POST/PUT/DELETE/...)
   blog/layout.tsx       → /blog/* layout  (UI structure, receives children, hydrated)
+  api/search/
+    route.ts            → GET /api/search (standalone API, no page.tsx needed)
 ```
 
 ### page.tsx — page component
@@ -155,7 +164,18 @@ export const POST: Handler = async (req, ctx) => {
 }
 ```
 
-Route.ts exports `POST`/`PUT`/`DELETE`/`PATCH` (GET is handled by page.tsx). The same `route.ts` file coexists with `page.tsx` in the same directory for handling form submissions or AJAX requests.
+Route.ts exports `POST`/`PUT`/`DELETE`/`PATCH` (GET is handled by page.tsx). The same `route.ts` file coexists with `page.tsx` in the same directory for handling form submissions or AJAX requests. Standalone `route.ts` (without a co-located `page.tsx`) registers all methods including `GET`.
+
+### not-found.tsx — 404 page
+
+```tsx
+// pages/not-found.tsx
+export default function NotFound() {
+  return <h1 class="text-4xl">404 – Not Found</h1>
+}
+```
+
+Automatically rendered for unmatched routes, wrapped in the full layout chain. Works with `use('/')` mounting and standalone usage.
 
 ### Usage within a full app
 
@@ -224,6 +244,9 @@ app.get('/protected', auth({ proxy: 'http://auth:3000/validate' }), handler)
 
 // Custom header
 app.use(auth({ header: 'X-API-Key', token: 'my-key' }))
+
+// Token can also be passed via query string ?access_token=xxx
+// Proxy forwards using the same method the client used (header ↔ query)
 ```
 
 ### CORS
@@ -407,6 +430,40 @@ const app = new Router()
 serve(app.handler(), { port: 3000 })
 ```
 
+## Graceful shutdown
+
+```ts
+import { serve } from 'weifuwu'
+import type { Server } from 'weifuwu'
+
+const ac = new AbortController()
+let server: Server
+
+process.on('SIGTERM', () => {
+  console.log('shutting down…')
+  ac.abort()
+  server.stop()
+})
+
+server = serve((req, ctx) => new Response('Hello'), {
+  port: 3000,
+  signal: ac.signal,
+})
+await server.ready
+console.log(`listening on :${server.port}`)
+```
+
+### Using with WebSocket
+
+```ts
+const app = new Router().ws('/chat', { … })
+const server = serve(app.handler(), {
+  port: 3000,
+  signal: ac.signal,
+  websocket: app.websocketHandler(),
+})
+```
+
 ## Error handling
 
 ```ts

package/dist/index.js

@@ -365,7 +365,7 @@ var Router = class _Router {
     for (let i = 0; i < segments.length; i++) {
       pathMws.push(...node.pathMws);
       if (node.wildcard) {
-        const h = node.handlers.get(method) || node.handlers.get("*");
+        const h = node.handlers.get("*") || node.handlers.get(method);
         if (h) {
           wildcardHandler = h;
           wildcardMws = node.middlewares.get(method) || node.middlewares.get("*") || [];
@@ -676,6 +676,20 @@ function scanPages(dir) {
         layouts,
         routePath: rPath
       });
+    } else {
+      const rPath = join(current, "route.ts");
+      if (existsSync(rPath)) {
+        let relPath = relative(dir, rPath).replace(sep, "/");
+        relPath = relPath.replace(/\/route\.tsx?$/, "");
+        const route = filePathToRoute(relPath);
+        pages.push({
+          route,
+          entryPath: "",
+          layouts: [],
+          routePath: rPath,
+          routeOnly: true
+        });
+      }
     }
     for (const d of dirs) walk(d);
   }
@@ -821,26 +835,37 @@ ${scripts.join("\n")}`;
 async function tsx(options) {
   const pagesDir = resolve(options.dir);
   const outDir = join(pagesDir, "..", ".weifuwu", "ssr");
-  const clientDir = join(pagesDir, "..", ".weifuwu", "client");
   const pages = scanPages(pagesDir);
   if (pages.length === 0) return new Router();
   const allFiles = /* @__PURE__ */ new Set();
-  const loadMap = /* @__PURE__ */ new Map();
-  const layoutMap = /* @__PURE__ */ new Map();
   for (const p of pages) {
-    allFiles.add(p.entryPath);
-    if (p.loadPath) {
-      allFiles.add(p.loadPath);
-      loadMap.set(p.entryPath, p.loadPath);
-    }
+    if (p.entryPath) allFiles.add(p.entryPath);
+    if (p.loadPath) allFiles.add(p.loadPath);
     for (const lp of p.layouts) allFiles.add(lp);
-    layoutMap.set(p.entryPath, [...p.layouts]);
     if (p.routePath) allFiles.add(p.routePath);
   }
+  const nfPath = join(pagesDir, "not-found.tsx");
+  const hasNotFound = existsSync(nfPath);
+  if (hasNotFound) {
+    allFiles.add(nfPath);
+    const rootLayouts = resolveLayouts(pagesDir, pagesDir);
+    for (const lp of rootLayouts) allFiles.add(lp);
+  }
   mkdirSync(outDir, { recursive: true });
   await compileAll([...allFiles], outDir, "node");
   const router = new Router();
   for (const p of pages) {
+    if (p.routeOnly && p.routePath) {
+      const rUrl = compiledUrl(p.routePath, outDir);
+      const modR = await import(rUrl);
+      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+      for (const method of methods) {
+        if (modR[method]) {
+          router.route(method, p.route, modR[method]);
+        }
+      }
+      continue;
+    }
     const url = compiledUrl(p.entryPath, outDir);
     const mod = await import(url);
     const Component = mod.default;
@@ -877,6 +902,36 @@ async function tsx(options) {
       }
     }
   }
+  if (hasNotFound) {
+    const nfUrl = compiledUrl(nfPath, outDir);
+    const modNf = await import(nfUrl);
+    const NfComponent = modNf.default;
+    const nfLayouts = [];
+    const rootLayouts = resolveLayouts(pagesDir, pagesDir);
+    for (const lp of rootLayouts) {
+      const lUrl = compiledUrl(lp, outDir);
+      const modL = await import(lUrl);
+      nfLayouts.push(modL.default);
+    }
+    const handler = async (req, ctx) => {
+      let element = createElement(NfComponent, { params: ctx.params, query: ctx.query });
+      for (let i = nfLayouts.length - 1; i >= 0; i--) {
+        element = createElement(nfLayouts[i], { children: element });
+      }
+      element = createElement(TsxContext.Provider, {
+        value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
+      }, element);
+      const stream = await renderToReadableStream(element);
+      const body = await readStream(stream);
+      const html = `<!DOCTYPE html>
+${body}`;
+      return new Response(html, {
+        status: 404,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    };
+    router.all("/*", handler);
+  }
   return router;
 }
 
@@ -941,25 +996,36 @@ function cors(options) {
 function auth(options) {
   return async (req, ctx, next) => {
     const headerName = options.header ?? "Authorization";
-    const header = req.headers.get(headerName);
-    if (!header) {
+    let from = "header";
+    let header = req.headers.get(headerName);
+    let token = "";
+    if (header) {
+      token = header;
+      if (headerName.toLowerCase() === "authorization") {
+        const parts = header.split(" ");
+        if (parts[0]?.toLowerCase() === "bearer") {
+          token = parts.slice(1).join(" ");
+        }
+      }
+    } else {
+      const url = new URL(req.url);
+      const qsToken = url.searchParams.get("access_token");
+      if (qsToken) {
+        token = qsToken;
+        from = "query";
+      }
+    }
+    if (!token) {
       return new Response("Unauthorized", {
         status: 401,
         headers: headerName.toLowerCase() === "authorization" ? { "WWW-Authenticate": "Bearer" } : void 0
       });
     }
-    let token = header;
-    if (headerName.toLowerCase() === "authorization") {
-      const parts = header.split(" ");
-      if (parts[0]?.toLowerCase() === "bearer") {
-        token = parts.slice(1).join(" ");
-      }
-    }
     if (options.proxy) {
       const proxyUrl = typeof options.proxy === "string" ? new URL(options.proxy) : options.proxy;
       const proxyHeaders = {};
-      if (headerName.toLowerCase() === "authorization") {
-        proxyHeaders["Authorization"] = header;
+      if (from === "header" && header) {
+        proxyHeaders[headerName] = header;
       } else {
         proxyUrl.searchParams.set("access_token", token);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",