rwsdk 1.0.0-beta.43 → 1.0.0-beta.45

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

@@ -1,6 +1,6 @@
 import React from "react";
 import { describe, expect, it } from "vitest";
-import { defineRoutes, layout, matchPath, prefix, render, route, } from "./router";
+import { defineRoutes, except, layout, matchPath, prefix, render, route, } from "./router";
 describe("matchPath", () => {
     // Test case 1: Static paths
     it("should match static paths", () => {
@@ -34,6 +34,11 @@ describe("matchPath", () => {
     it("should match empty wildcard", () => {
         expect(matchPath("/files/*/", "/files//")).toEqual({ $0: "" });
     });
+    it("should match wildcard route against root path", () => {
+        // Wildcard route should match the root path "/"
+        // This tests the regression where route("*") stopped matching "/"
+        expect(matchPath("/*", "/")).toEqual({ $0: "" });
+    });
     // Test case 4: Paths with both parameters and wildcards
     it("should match paths with both parameters and wildcards", () => {
         expect(matchPath("/products/:productId/*/", "/products/abc/details/more/")).toEqual({ productId: "abc", $0: "details/more" });
@@ -62,6 +67,7 @@ describe("defineRoutes - Request Handling Behavior", () => {
     const createMockDependencies = () => {
         const mockRequestInfo = {
             request: new Request("http://localhost:3000/"),
+            path: "/",
             params: {},
             ctx: {},
             rw: {
@@ -293,6 +299,109 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(executionOrder).toEqual(["prefixedMiddleware"]);
             expect(await response.text()).toBe("From prefixed middleware");
         });
+        it("should pass prefix parameters to route handlers", async () => {
+            let capturedParams = null;
+            const TaskDetailPage = (requestInfo) => {
+                capturedParams = requestInfo.params;
+                return React.createElement("div", {}, "Task Detail");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [route("/", TaskDetailPage)]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParams).toEqual({ containerId: "123" });
+        });
+        it("should pass prefix parameters to middlewares within a parameterized prefix", async () => {
+            const executionOrder = [];
+            let capturedParams = null;
+            const prefixedMiddleware = (requestInfo) => {
+                executionOrder.push("prefixedMiddleware");
+                capturedParams = requestInfo.params;
+            };
+            const PageComponent = () => {
+                executionOrder.push("PageComponent");
+                return React.createElement("div", {}, "Page");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [
+                    prefixedMiddleware,
+                    route("/", PageComponent),
+                ]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["prefixedMiddleware", "PageComponent"]);
+            // The wildcard captures the trailing slash as an empty string
+            expect(capturedParams).toEqual({ containerId: "123", $0: "" });
+        });
+        it("should pass prefix parameters to route handlers (array)", async () => {
+            let capturedParamsInMiddleware = null;
+            let capturedParamsInComponent = null;
+            const middleware = (requestInfo) => {
+                capturedParamsInMiddleware = requestInfo.params;
+            };
+            const Component = (requestInfo) => {
+                capturedParamsInComponent = requestInfo.params;
+                return React.createElement("div", {}, "Component");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId", [route("/", [middleware, Component])]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParamsInMiddleware).toEqual({ containerId: "123" });
+            expect(capturedParamsInComponent).toEqual({ containerId: "123" });
+        });
+        it("should match even if prefix has a trailing slash", async () => {
+            let capturedParams = null;
+            const TaskDetailPage = (requestInfo) => {
+                capturedParams = requestInfo.params;
+                return React.createElement("div", {}, "Task Detail");
+            };
+            const router = defineRoutes([
+                ...prefix("/tasks/:containerId/", [route("/", TaskDetailPage)]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/tasks/123/");
+            const request = new Request("http://localhost:3000/tasks/123/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(capturedParams).toEqual({ containerId: "123" });
+        });
     });
     describe("RSC Action Handling", () => {
         it("should handle RSC actions before the first route definition", async () => {
@@ -437,6 +546,28 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(response.status).toBe(404);
             expect(await response.text()).toBe("Not Found");
         });
+        it("should match wildcard route against root path", async () => {
+            // Regression test: wildcard route should match the root path "/"
+            const executionOrder = [];
+            const WildcardPage = () => {
+                executionOrder.push("WildcardPage");
+                return React.createElement("div", {}, "Wildcard Page");
+            };
+            const router = defineRoutes([route("*", WildcardPage)]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/");
+            deps.mockRequestInfo.path = "/";
+            const request = new Request("http://localhost:3000/");
+            await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["WildcardPage"]);
+        });
     });
     describe("Multiple Render Blocks with SSR Configuration", () => {
         it("should short-circuit on first matching render block and not apply later configurations", async () => {
@@ -884,4 +1015,242 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(await response.text()).toBe("Rendered: Element");
         });
     });
+    describe("except - Error Handling", () => {
+        it("should catch errors from global middleware", async () => {
+            const errorMessage = "Middleware error";
+            const middleware = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                middleware,
+                errorHandler,
+                route("/test/", () => React.createElement("div")),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            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(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from route handlers (components)", async () => {
+            const errorMessage = "Component error";
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            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(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from route handlers (functions)", async () => {
+            const errorMessage = "Handler error";
+            const routeHandler = () => {
+                throw new Error(errorMessage);
+            };
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", routeHandler),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            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(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should catch errors from RSC actions", async () => {
+            const errorMessage = "RSC action error";
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", () => React.createElement("div")),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/?__rsc_action_id=test");
+            deps.mockRscActionHandler = async () => {
+                throw new Error(errorMessage);
+            };
+            const request = new Request("http://localhost:3000/test/?__rsc_action_id=test");
+            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(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+        it("should use the most recent except handler before the error", async () => {
+            const errorMessage = "Route error";
+            const firstHandler = except((error) => {
+                return new Response("First handler", { status: 500 });
+            });
+            const secondHandler = except((error) => {
+                return new Response("Second handler", { status: 500 });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                firstHandler,
+                secondHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            // Should use the second handler (most recent before the route)
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe("Second handler");
+        });
+        it("should try next except handler if current one throws", async () => {
+            const errorMessage = "Route error";
+            const firstHandler = except(() => {
+                throw new Error("First handler error");
+            });
+            const secondHandler = except((error) => {
+                return new Response(`Caught by second: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                secondHandler, // Outer handler
+                firstHandler, // Inner handler (closer to route)
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            // Should catch the error from the first handler with the second handler
+            expect(response.status).toBe(500);
+            expect(await response.text()).toBe("Caught by second: First handler error");
+        });
+        it("should return JSX element from except handler", async () => {
+            const errorMessage = "Route error";
+            function ErrorComponent() {
+                return React.createElement("div", {}, "Error Page");
+            }
+            const errorHandler = except(() => {
+                return React.createElement(ErrorComponent);
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const router = defineRoutes([
+                errorHandler,
+                route("/test/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/");
+            const request = new Request("http://localhost:3000/test/");
+            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("Rendered: ErrorComponent");
+        });
+        it("should work with prefix and layout", async () => {
+            const errorMessage = "Route error";
+            const errorHandler = except((error) => {
+                return new Response(`Caught: ${error instanceof Error ? error.message : String(error)}`, {
+                    status: 500,
+                });
+            });
+            const PageComponent = () => {
+                throw new Error(errorMessage);
+            };
+            const Layout = ({ children }) => {
+                return React.createElement("div", {}, children);
+            };
+            const router = defineRoutes([
+                errorHandler,
+                layout(Layout, [prefix("/api", [route("/test/", PageComponent)])]),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/api/test/");
+            const request = new Request("http://localhost:3000/api/test/");
+            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(500);
+            expect(await response.text()).toBe(`Caught: ${errorMessage}`);
+        });
+    });
 });

package/dist/runtime/requestInfo/types.d.ts

@@ -3,6 +3,7 @@ export interface DefaultAppContext {
 }
 export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
     request: Request;
+    path: string;
     params: Params;
     ctx: AppContext;
     rw: RwContext;

package/dist/runtime/requestInfo/utils.js

@@ -9,6 +9,7 @@ export const constructWithDefaultRequestInfo = (overrides = {}) => {
     const { rw: rwOverrides, ...otherRequestInfoOverrides } = overrides;
     const defaultRequestInfo = {
         request: new Request("http://localhost/"),
+        path: "/",
         params: {},
         ctx: {},
         cf: {

package/dist/runtime/requestInfo/worker.js

@@ -17,7 +17,8 @@ export const requestInfo = Object.freeze(requestInfoBase);
 export function getRequestInfo() {
     const store = requestInfoStore.getStore();
     if (!store) {
-        throw new Error("Request context not found");
+        throw new Error("RedwoodSDK: Request context not found. getRequestInfo() can only be called within the request lifecycle (e.g., in a route handler, middleware, or server action).\n\n" +
+            "For detailed troubleshooting steps, see: https://docs.rwsdk.com/guides/troubleshooting#request-context-errors");
     }
     return store;
 }

package/dist/runtime/worker.js

@@ -11,11 +11,11 @@ import { defineRoutes } from "./lib/router";
 import { generateNonce } from "./lib/utils";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
+    const router = defineRoutes(routes);
     return {
         __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
-            const router = defineRoutes(routes);
             // context(justinvdm, 5 Feb 2025): Serve assets requests using the assets service binding
             // todo(justinvdm, 5 Feb 2025): Find a way to avoid this so asset requests are served directly
             // rather than first needing to go through the worker
@@ -63,6 +63,10 @@ export const defineApp = (routes) => {
             }
             try {
                 const url = new URL(request.url);
+                let path = url.pathname;
+                if (path !== "/" && !path.endsWith("/")) {
+                    path = path + "/";
+                }
                 const isRSCRequest = url.searchParams.has("__rsc") ||
                     request.headers.get("accept")?.includes("text/x-component");
                 const isAction = url.searchParams.has("__rsc_action_id");
@@ -83,6 +87,7 @@ export const defineApp = (routes) => {
                 };
                 const outerRequestInfo = {
                     request,
+                    path,
                     cf,
                     params: {},
                     ctx: {},

package/dist/vite/runDirectivesScan.mjs

@@ -298,7 +298,9 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
         });
     }
     catch (e) {
-        throw new Error(`RWSDK directive scan failed:\n${e.stack}`);
+        throw new Error(`RedwoodSDK: Directive scan failed. This often happens due to syntax errors in files using "use client" or "use server". Check your directive files for issues.\n\n` +
+            `For detailed troubleshooting steps, see: https://docs.rwsdk.com/guides/troubleshooting#directive-scan-errors\n\n` +
+            `${e.stack}`);
     }
     finally {
         deferredLog("✔ (rwsdk) Done scanning for 'use client' and 'use server' directives.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.43",
+  "version": "1.0.0-beta.45",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -182,6 +182,7 @@
     "puppeteer-core": "~24.22.0",
     "react-is": "~19.1.0",
     "rsc-html-stream": "~0.0.6",
+    "server-only": "^0.0.1",
     "tmp-promise": "~3.0.3",
     "ts-morph": "~27.0.0",
     "unique-names-generator": "~4.7.1",