rwsdk 1.0.0-beta.3 → 1.0.0-beta.30-test.20251119220440

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

@@ -71,6 +71,8 @@ describe("defineRoutes - Request Handling Behavior", () => {
                 ssr: true,
                 databases: new Map(),
                 scriptsToBeLoaded: new Set(),
+                entryScripts: new Set(),
+                inlineScripts: new Set(),
                 pageRouteResolved: undefined,
             },
             cf: {},
@@ -593,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/dist/runtime/lib/stitchDocumentAndAppStreams.d.ts

@@ -15,4 +15,70 @@
  * @param startMarker The marker in the document to start injecting the app.
  * @param endMarker The marker in the app stream that signals the end of the initial, non-suspended render.
  */
+/**
+ * A utility that orchestrates and interleaves three ReadableStreams to produce a
+ * single, valid HTML response stream. It uses two special markers:
+ *
+ * - `startMarker`: Placed in the `outerHtml` stream (the document shell) to
+ *   designate where the application's content should be injected.
+ * - `endMarker`: Injected into the `innerHtml` stream's RSC payload to signal
+ *   the end of the initial, non-suspended render. This marker is needed for
+ *   non-blocking hydration, as it allows the stitching process to send the
+ *   client `<script>` tags before all suspended content has resolved.
+ *
+ * It manages three main stream readers:
+ *
+ * - `hoistedTagsReader`: Reads from the `hoistedTagsStream`, which contains only
+ *   the hoisted meta tags (e.g., `<title>`, `<meta>`).
+ * - `outerReader`: Reads from the `outerHtml` stream, which is the server-rendered
+ *   document shell (containing `<html>`, `<head>`, etc.).
+ * - `innerReader`: Reads from the `appBodyStream`, which contains the main
+ *   application content, stripped of its hoisted tags.
+ *
+ * The function proceeds through a multi-phase state machine, managed by the
+ * `pump` function, to correctly interleave these streams.
+ *
+ * The state machine moves through the following phases:
+ *
+ * 1. `read-hoisted`:
+ *    - **Goal:** Buffer all hoisted tags from the `hoistedTagsStream`.
+ *    - **Action:** Reads from `hoistedTagsReader` and appends all content into
+ *      the `hoistedTagsBuffer`. Does not enqueue anything yet.
+ *    - **Transition:** Moves to `outer-head` when the stream is exhausted.
+ *
+ * 2. `outer-head`:
+ *    - **Goal:** Stream the document up to the closing `</head>` tag, inject the
+ *      hoisted tags, and then continue until the app `startMarker`.
+ *    - **Action:** Reads from `outerReader`. When it finds `</head>`, it enqueues
+ *      the content before it, then enqueues the `hoistedTagsBuffer`, and finally
+ *      enqueues the `</head>` tag itself. It then continues reading from
+ *      `outerReader` until it finds the `startMarker`.
+ *    - **Transition:** Moves to `inner-shell` after finding and discarding the
+ *      `startMarker`.
+ *
+ * 3. `inner-shell`:
+ *    - **Goal:** Stream the initial, non-suspended part of the application.
+ *    - **Action:** Switches to `innerReader`. It enqueues chunks until it finds
+ *      the `endMarker`. Any content after the marker is stored in
+ *      `innerSuspendedRemains`.
+ *    - **Transition:** Moves to `outer-tail` after finding the `endMarker`.
+ *
+ * 4. `outer-tail`:
+ *    - **Goal:** Stream the rest of the document's `<body>`, including client
+ *      `<script>` tags.
+ *    - **Action:** Switches back to `outerReader` and enqueues chunks until it
+ *      finds the `</body>` tag.
+ *    - **Transition:** Moves to `inner-suspended` after finding `</body>`.
+ *
+ * 5. `inner-suspended`:
+ *    - **Goal:** Stream any suspended content from the React app.
+ *    - **Action:** First enqueues any content from `innerSuspendedRemains`, then
+ *      continues reading from `innerReader` until the stream is exhausted.
+ *    - **Transition:** Moves to `outer-end` when the stream is exhausted.
+ *
+ * 6. `outer-end`:
+ *    - **Goal:** Finish the document.
+ *    - **Action:** Switches back to `outerReader` for the last time to send the
+ *      closing `</body>` and `</html>` tags.
+ */
 export declare function stitchDocumentAndAppStreams(outerHtml: ReadableStream<Uint8Array>, innerHtml: ReadableStream<Uint8Array>, startMarker: string, endMarker: string): ReadableStream<Uint8Array>;