weifuwu 0.2.3 → 0.2.4

package/README.md

@@ -407,6 +407,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.2.4",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",