@rhythmjs/router 0.0.13 → 0.0.14

package/README.md

@@ -4,7 +4,7 @@ The HTTP layer of Rhythm, the Bun-native backend framework: web-standard (`Reque
 
 Route patterns follow rou3's conventions: `:name` params (`:name?` optional, `:id(\\d+)` regex-constrained), `*` for one unnamed segment (captured as `params["0"]`), and `**` for the rest of the path (`params._`, or `params.name` with `**:name`). Param values are the raw path segments, undecoded.
 
-`RhythmRouter` is not an app and does not extend `Rhythm`; it is a controller that compiles routes and middleware down to a single middleware (`.middleware()`). It shares the core middleware contract (`compose`, `Middleware`, `derive`; `next()` takes no arguments, extend the context with `derive()`), but has no `provide()` or `register()`, and it can't be served on its own: a `Rhythm` app is always the host that owns the lifecycle and the adapters.
+`RhythmRouter` is not an app and does not extend `Rhythm`; it is a controller that compiles routes and middleware down to a single middleware (`.middleware()`). It shares the core middleware contract (`compose`, `Middleware`, `derive`; `next()` takes no arguments, extend the context with `derive()`), but has no a startup `context` or `register()`, and it can't be served on its own: a `Rhythm` app is always the host that owns the lifecycle and the adapters.
 
 ## Example
 
@@ -31,7 +31,7 @@ A fuller runnable version, including nested prefixes and a fallback route, is at
 - **`ctx.params`**: captured `:name` path segments, added once a route matches.
 - **Nesting is `.use(child.middleware())`**: a router mounts into another router (or into the app) as a compiled middleware. The mount is opaque, so the parent's prefix is **not** applied to the child's routes: the child carries its own absolute prefix (`new RhythmRouter({ prefix: "/api/users" })`). On a miss the child falls through to `next()`, so the parent's later middleware and routes still run, and the child keeps working standalone.
 - **Registration order is execution order**: a `.use()` middleware wraps only the routes registered after it, and runs only when one of them matches the request's method and path (so a guard in a `/projects` router never answers `/docs`); a mounted router (`.use(child.middleware())`) always runs; routes registered before it are untouched, and a matched route that doesn't call `next()` returns without reaching anything registered later. Consecutive routes share one rou3 lookup; an unmatched request falls through, entry by entry, to the outer `next()`.
-- **A router is a controller, not a module**: it has no `provide()` or `register()`, and it cannot be `register()`ed into a `Rhythm` app either; `register()` composes `Rhythm` modules only. A router mounts into an app exactly one way: koa-style, via `.use(router.middleware())`.
+- **A router is a controller, not a module**: it has no a startup `context` or `register()`, and it cannot be `register()`ed into a `Rhythm` app either; `register()` composes `Rhythm` modules only. A router mounts into an app exactly one way: koa-style, via `.use(router.middleware())`.
 
 ## API
 

package/dist/fetch.d.ts

@@ -1,4 +1,4 @@
 import type { Rhythm } from "@rhythmjs/rhythm";
 import { type RhythmHttpContext } from "./context";
-export declare function toFetchHandler<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request) => Promise<Response>;
+export declare function toFetchHandler<TContext extends RhythmHttpContext>(app: Rhythm<RhythmHttpContext, any, TContext>): (request: Request) => Promise<Response>;
 export declare function errorToResponse(error: unknown): Response;

package/dist/rhythm-router.js

@@ -6,10 +6,26 @@ import { addRoute, createRouter, findRoute } from "rou3";
 function joinPath(prefix, path) {
   if (!prefix)
     return path;
+  if (path === "/" || path === "")
+    return prefix;
   const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
   const normalizedPath = path.startsWith("/") ? path : `/${path}`;
   return `${trimmedPrefix}${normalizedPath}`;
 }
+function mountedRoutes(router, tree, seen = new Set) {
+  if (seen.has(router))
+    return;
+  seen.add(router);
+  for (const entry of router.entries) {
+    if (entry.kind === "route")
+      addRoute(tree, entry.method, entry.path, true);
+    else {
+      const child = sourceOf(entry.fn);
+      if (child instanceof RhythmRouter)
+        mountedRoutes(child, tree, seen);
+    }
+  }
+}
 
 class RhythmRouter {
   #options;
@@ -74,8 +90,18 @@ class RhythmRouter {
       const entry = this.#entries[i];
       if (entry.kind === "middleware") {
         const { fn } = entry;
-        const from = trees.length;
-        stack.push(sourceOf(fn) ? fn : (ctx, next) => reaches(ctx, from) ? fn(ctx, next) : next());
+        const source = sourceOf(fn);
+        if (source) {
+          if (source instanceof RhythmRouter) {
+            const tree = createRouter();
+            mountedRoutes(source, tree);
+            trees.push(tree);
+          }
+          stack.push(fn);
+        } else {
+          const from = trees.length;
+          stack.push((ctx, next) => reaches(ctx, from) ? fn(ctx, next) : next());
+        }
         i++;
         continue;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "Bun-native HTTP router for the Rhythm middleware kernel, matching with rou3 and serving with Bun.serve.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "rou3": "^0.11.0",
-    "@rhythmjs/rhythm": "0.0.14"
+    "@rhythmjs/rhythm": "0.0.15"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",