@rhythmjs/router 0.0.17 → 0.0.20

package/README.md

@@ -39,6 +39,7 @@ Bun.serve({ port: 3000, fetch: toFetchHandler(app) });
 - **`ctx.params`**: captured path params, typed from the path: `/users/:id` gives `params.id: string`, `:id?` is `string | undefined`, and reading a name that is not in the path is a compile error. In `use()` middleware, params are an untyped `Record<string, string>`, since several routes may match.
 - **Strict context.** Like `Rhythm`, the route context only has what was added: `ctx.nope` is a compile error, and `derive()` (router-level or as a route's first handler) is how you widen it. A route-level `derive` only affects that route.
 - **Apps and the fetch handler.** Inside an app's own middleware, `ctx.request`/`ctx.response` are typed only if the app declares them as input: `new Rhythm<{}, RhythmHttpContext>()`. `toFetchHandler(app)` rejects, at compile time, an app that requires any other input.
+- **`ctx.server`.** The handler is `(request, server?)`, matching Bun's `fetch(request, server)`. Pass the server through and every handler gets the typed `Bun.Server` as `ctx.server` (for `ctx.server?.requestIP(ctx.request)`, `publish`, `upgrade`, …); without it, `ctx.server` is `undefined`.
 - **Errors.** A route that throws makes the handler reject; mounted plugins wrap failures as `mounted router "name" failed` with the original as `cause`. `errorToResponse` looks through the `cause` chain for a declared status.
 
 ## API
@@ -51,6 +52,22 @@ Bun.serve({ port: 3000, fetch: toFetchHandler(app) });
 - `createHttpContext(request)` / `toResponse(response)` (`@rhythmjs/router/context`): the request context and its conversion to a `Response`.
 - `toFetchHandler(app)` (`@rhythmjs/router/fetch`): bridges a `Rhythm` app (or router) to a Web-standard `(Request) => Promise<Response>` handler. Errors reject.
 - `errorToResponse(error)` (`@rhythmjs/router/fetch`): maps a thrown error to a `Response`.
+- `fromFetch(handler)` (`@rhythmjs/router/fetch`): wraps a fetch-style `(request) => Response` handler (Better Auth, tRPC, a webhook SDK) as a mountable. The returned `Response` becomes the response (status, headers, body stream; every `Set-Cookie` is kept).
+- `pathIs(pattern)` (`@rhythmjs/router/path`): a condition for `mount(plugin, condition)` that is true when the request path matches `pattern`, using the same rou3 conventions as routes; the HTTP method is not part of the match, and a pattern without a leading `/` throws a `TypeError`.
+
+```ts
+import { fromFetch } from "@rhythmjs/router/fetch";
+import { pathIs } from "@rhythmjs/router/path";
+
+const app = new Rhythm()
+  .use(
+    mount(
+      fromFetch((request) => auth.handler(request)),
+      pathIs("/api/auth/**"),
+    ),
+  )
+  .use(mount(router));
+```
 
 ## Serving: your Bun.serve, no wrapper
 
@@ -69,14 +86,9 @@ const handler = toFetchHandler(app);
 const server = Bun.serve({
   port: 3000,
   async fetch(request, srv) {
-    // Optional: expose the client address as request.ip, the field
-    // @rhythmjs/security's rate limit and @rhythmjs/http's proxy key off.
-    Object.defineProperty(request, "ip", {
-      configurable: true,
-      get: () => srv.requestIP(request)?.address,
-    });
     try {
-      return await handler(request);
+      // Passing the server makes it available as ctx.server in every handler.
+      return await handler(request, srv);
     } catch (error) {
       return errorToResponse(error);
     }

package/dist/context.d.ts

@@ -7,6 +7,7 @@ export declare class RhythmResponse {
 }
 export interface RhythmHttpContext {
     readonly request: Request;
+    readonly server: Bun.Server<any> | undefined;
     readonly response: RhythmResponse;
     json(data: unknown, status?: number): void;
     text(body: string, status?: number): void;
@@ -15,5 +16,5 @@ export interface RhythmHttpContext {
     redirect(url: string, status?: number): void;
 }
 export declare const STATUS_TEXT: Record<number, string>;
-export declare function createHttpContext(request: Request): RhythmHttpContext;
+export declare function createHttpContext(request: Request, server?: Bun.Server<any>): RhythmHttpContext;
 export declare function toResponse(response: RhythmResponse): Response;

package/dist/context.js

@@ -4,7 +4,7 @@ import {
   STATUS_TEXT2,
   createHttpContext2,
   toResponse2
-} from "./rhythm-router-48zw4cyy.js";
+} from "./rhythm-router-1sak3407.js";
 export {
   RhythmResponse2 as RhythmResponse,
   STATUS_TEXT2 as STATUS_TEXT,

package/dist/fetch.d.ts

@@ -1,4 +1,5 @@
-import type { Mountable } from "@rhythmjs/rhythm";
+import { Rhythm, type Mountable } from "@rhythmjs/rhythm";
 import { type RhythmHttpContext } from "./context";
-export declare function toFetchHandler<I extends object = any>(app: Mountable<I> & (RhythmHttpContext extends I ? unknown : never)): (request: Request) => Promise<Response>;
+export declare function toFetchHandler<I extends object = any>(app: Mountable<I> & (RhythmHttpContext extends I ? unknown : never)): <WebSocketData>(request: Request, server?: Bun.Server<WebSocketData>) => Promise<Response>;
+export declare function fromFetch(handler: (request: Request) => Response | Promise<Response>): Rhythm<{}, RhythmHttpContext, {}>;
 export declare function errorToResponse(error: unknown): Response;

package/dist/fetch.js

@@ -4,16 +4,17 @@ import {
   STATUS_TEXT2,
   createHttpContext2,
   toResponse2
-} from "./rhythm-router-48zw4cyy.js";
+} from "./rhythm-router-1sak3407.js";
 
 // src/fetch.ts
+import { Rhythm } from "@rhythmjs/rhythm";
 function isUntouched(response) {
   return response.status === 200 && response.statusText === undefined && response.body === null && [...response.headers].length === 0;
 }
 function toFetchHandler(app) {
   const run = app.callback();
-  return async (request) => {
-    const base = createHttpContext2(request);
+  return async (request, server) => {
+    const base = createHttpContext2(request, server);
     const result = await run(base);
     const response = result?.response ?? base.response;
     if (isUntouched(response)) {
@@ -26,6 +27,22 @@ function toFetchHandler(app) {
     return toResponse2(response);
   };
 }
+function applyResponse(ctx, response) {
+  ctx.response.status = response.status;
+  ctx.response.statusText = response.statusText;
+  for (const [name, value] of response.headers) {
+    if (name === "set-cookie")
+      ctx.response.headers.append(name, value);
+    else
+      ctx.response.headers.set(name, value);
+  }
+  ctx.response.body = response.body;
+}
+function fromFetch(handler) {
+  return new Rhythm({ name: "fetch" }).use(async (ctx) => {
+    applyResponse(ctx, await handler(ctx.request));
+  });
+}
 function declaredStatus(error) {
   const { status, statusCode } = error ?? {};
   const declared = status ?? statusCode;
@@ -56,5 +73,6 @@ function errorToResponse(error) {
 }
 export {
   errorToResponse,
+  fromFetch,
   toFetchHandler
 };

package/dist/path.d.ts

@@ -0,0 +1,2 @@
+import type { RhythmHttpContext } from "@rhythmjs/router/context";
+export declare function pathIs(pattern: string): (ctx: RhythmHttpContext) => boolean;

package/dist/path.js

@@ -0,0 +1,13 @@
+// @bun
+// src/path.ts
+import { addRoute, createRouter, findRoute } from "rou3";
+function pathIs(pattern) {
+  if (!pattern.startsWith("/"))
+    throw new TypeError(`path must start with "/", got "${pattern}"`);
+  const router = createRouter();
+  addRoute(router, "", pattern, true);
+  return (ctx) => findRoute(router, ctx.request.method, new URL(ctx.request.url).pathname) !== undefined;
+}
+export {
+  pathIs
+};

package/dist/{rhythm-router-48zw4cyy.js → rhythm-router-1sak3407.js}

@@ -25,10 +25,11 @@ var STATUS_TEXT2 = {
   503: "Service Unavailable",
   504: "Gateway Timeout"
 };
-function createHttpContext2(request) {
+function createHttpContext2(request, server) {
   const response = new RhythmResponse2;
   return {
     request,
+    server,
     response,
     json(data, status) {
       if (status !== undefined)

package/dist/rhythm-router.d.ts

@@ -12,7 +12,7 @@ export type RouteHandler<T extends object, P extends string> = (ctx: RouteContex
 export type RouteHandlers<T extends object, P extends string> = [RouteHandler<T, P>, ...RouteHandler<T, P>[]];
 export declare class RhythmRouter<I extends object = {}, D extends object = {}> extends Pipeline<UseContext<I & D>> {
     #private;
-    readonly "~input"?: I;
+    readonly "~input"?: I & RhythmHttpContext;
     constructor(options?: PipelineOptions);
     use<U extends object>(middleware: ExtensionMiddleware<UseContext<I & D>, U>): RhythmRouter<I, D & U>;
     use(middleware: Middleware<UseContext<I & D>>): this;

package/dist/rhythm-router.js

@@ -62,6 +62,8 @@ class RhythmRouter extends Pipeline {
     return { route: found.data, params };
   }
   #route(method, path, handlers) {
+    if (!path.startsWith("/"))
+      throw new TypeError(`route path must start with "/", got "${path}"`);
     const chain = compose(handlers);
     addRoute(this.#routes, method, path, (ctx) => chain(ctx));
     return this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.17",
+  "version": "0.0.20",
   "description": "Bun-native HTTP router for Rhythm: RhythmRouter plus a fetch handler for Bun.serve, matching with rou3.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
@@ -27,13 +27,17 @@
       "types": "./dist/fetch.d.ts",
       "default": "./dist/fetch.js"
     },
+    "./path": {
+      "types": "./dist/path.d.ts",
+      "default": "./dist/path.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@rhythmjs/rhythm": "0.0.17",
+    "@rhythmjs/rhythm": "0.0.20",
     "rou3": "^1.0.0"
   },
   "devDependencies": {
@@ -45,7 +49,7 @@
     "bun": ">=1.2.0"
   },
   "scripts": {
-    "build": "rm -rf dist && bun build src/rhythm-router.ts src/context.ts src/fetch.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && bun build src/rhythm-router.ts src/context.ts src/fetch.ts src/path.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   }