rwsdk 1.0.0-beta.13-test.20251016112315 → 1.0.0-beta.15

package/dist/runtime/lib/router.d.ts

@@ -6,10 +6,23 @@ type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Ma
 type MaybePromise<T> = T | Promise<T>;
 type RouteComponent<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
 type RouteHandler<T extends RequestInfo = RequestInfo> = RouteFunction<T> | RouteComponent<T> | [...RouteMiddleware<T>[], RouteFunction<T> | RouteComponent<T>];
+declare const METHOD_VERBS: readonly ["delete", "get", "head", "patch", "post", "put"];
+export type MethodVerb = (typeof METHOD_VERBS)[number];
+export type MethodHandlers<T extends RequestInfo = RequestInfo> = {
+    [K in MethodVerb]?: RouteHandler<T>;
+} & {
+    config?: {
+        disable405?: true;
+        disableOptions?: true;
+    };
+    custom?: {
+        [method: string]: RouteHandler<T>;
+    };
+};
 export type Route<T extends RequestInfo = RequestInfo> = RouteMiddleware<T> | RouteDefinition<T> | Array<Route<T>>;
 export type RouteDefinition<T extends RequestInfo = RequestInfo> = {
     path: string;
-    handler: RouteHandler<T>;
+    handler: RouteHandler<T> | MethodHandlers<T>;
     layouts?: React.FC<LayoutProps<T>>[];
 };
 export declare function matchPath<T extends RequestInfo = RequestInfo>(routePath: string, requestPath: string): T["params"] | null;
@@ -24,7 +37,7 @@ export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes
         rscActionHandler: (request: Request) => Promise<unknown>;
     }) => Response | Promise<Response>;
 };
-export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T>): RouteDefinition<T>;
+export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T> | MethodHandlers<T>): RouteDefinition<T>;
 export declare function index<T extends RequestInfo = RequestInfo>(handler: RouteHandler<T>): RouteDefinition<T>;
 export declare function prefix<T extends RequestInfo = RequestInfo>(prefixPath: string, routes: Route<T>[]): Route<T>[];
 export declare const wrapHandlerToThrowResponses: <T extends RequestInfo = RequestInfo>(handler: RouteFunction<T> | RouteComponent<T>) => RouteHandler<T>;

package/dist/runtime/lib/router.js

@@ -1,5 +1,6 @@
 import React from "react";
 import { isValidElementType } from "react-is";
+const METHOD_VERBS = ["delete", "get", "head", "patch", "post", "put"];
 export function matchPath(routePath, requestPath) {
     // Check for invalid pattern: multiple colons in a segment (e.g., /:param1:param2/)
     if (routePath.includes(":")) {
@@ -60,6 +61,38 @@ function flattenRoutes(routes) {
         return [...acc, route];
     }, []);
 }
+function isMethodHandlers(handler) {
+    return (typeof handler === "object" && handler !== null && !Array.isArray(handler));
+}
+function handleOptionsRequest(methodHandlers) {
+    const methods = new Set([
+        ...(methodHandlers.config?.disableOptions ? [] : ["OPTIONS"]),
+        ...METHOD_VERBS.filter((verb) => methodHandlers[verb]).map((verb) => verb.toUpperCase()),
+        ...Object.keys(methodHandlers.custom ?? {}).map((method) => method.toUpperCase()),
+    ]);
+    return new Response(null, {
+        status: 204,
+        headers: {
+            Allow: Array.from(methods).sort().join(", "),
+        },
+    });
+}
+function handleMethodNotAllowed(methodHandlers) {
+    const optionsResponse = handleOptionsRequest(methodHandlers);
+    return new Response("Method Not Allowed", {
+        status: 405,
+        headers: optionsResponse.headers,
+    });
+}
+function getHandlerForMethod(methodHandlers, method) {
+    const lowerMethod = method.toLowerCase();
+    // Check standard method verbs
+    if (METHOD_VERBS.includes(lowerMethod)) {
+        return methodHandlers[lowerMethod];
+    }
+    // Check custom methods (already normalized to lowercase)
+    return methodHandlers.custom?.[lowerMethod];
+}
 export function defineRoutes(routes) {
     const flattenedRoutes = flattenRoutes(routes);
     return {
@@ -125,9 +158,32 @@ export function defineRoutes(routes) {
                 if (!params) {
                     continue; // Not a match, keep going.
                 }
+                // Resolve handler if method-based routing
+                let handler;
+                if (isMethodHandlers(route.handler)) {
+                    const requestMethod = request.method;
+                    // Handle OPTIONS request
+                    if (requestMethod === "OPTIONS" &&
+                        !route.handler.config?.disableOptions) {
+                        return handleOptionsRequest(route.handler);
+                    }
+                    // Try to find handler for the request method
+                    handler = getHandlerForMethod(route.handler, requestMethod);
+                    if (!handler) {
+                        // Method not supported for this route
+                        if (!route.handler.config?.disable405) {
+                            return handleMethodNotAllowed(route.handler);
+                        }
+                        // If 405 is disabled, continue to next route
+                        continue;
+                    }
+                }
+                else {
+                    handler = route.handler;
+                }
                 // Found a match: run route-specific middlewares, then the final component, then stop.
                 return await runWithRequestInfoOverrides({ params }, async () => {
-                    const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
+                    const { routeMiddlewares, componentHandler } = parseHandlers(handler);
                     // Route-specific middlewares
                     for (const mw of routeMiddlewares) {
                         const result = await mw(getRequestInfo());
@@ -169,6 +225,16 @@ export function route(path, handler) {
     if (!path.endsWith("/")) {
         path = path + "/";
     }
+    // Normalize custom method keys to lowercase
+    if (isMethodHandlers(handler) && handler.custom) {
+        handler = {
+            ...handler,
+            custom: Object.fromEntries(Object.entries(handler.custom).map(([method, methodHandler]) => [
+                method.toLowerCase(),
+                methodHandler,
+            ])),
+        };
+    }
     return {
         path,
         handler,

package/dist/runtime/lib/router.test.js

@@ -595,6 +595,245 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(extractedParams).toEqual({ id: "123" });
         });
     });
+    describe("HTTP Method Routing", () => {
+        it("should route GET request to get handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("GET Response");
+        });
+        it("should route POST request to post handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("POST Response");
+        });
+        it("should return 405 for unsupported method with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should handle OPTIONS request with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(204);
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should support custom methods (case-insensitive)", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        report: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should normalize custom method keys to lowercase", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        REPORT: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should disable 405 when config.disable405 is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    config: {
+                        disable405: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(404);
+            expect(await response.text()).toBe("Not Found");
+        });
+        it("should disable OPTIONS when config.disableOptions is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                    config: {
+                        disableOptions: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, POST");
+        });
+        it("should support middleware arrays in method handlers", async () => {
+            const executionOrder = [];
+            const authMiddleware = () => {
+                executionOrder.push("authMiddleware");
+            };
+            const getHandler = () => {
+                executionOrder.push("getHandler");
+                return new Response("GET Response");
+            };
+            const router = defineRoutes([
+                route("/test/", {
+                    get: [authMiddleware, getHandler],
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["authMiddleware", "getHandler"]);
+            expect(await response.text()).toBe("GET Response");
+        });
+    });
     describe("Edge Cases", () => {
         it("should handle middleware-only apps with RSC actions", async () => {
             const executionOrder = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.13-test.20251016112315",
+  "version": "1.0.0-beta.15",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {