rwsdk 1.0.0-beta.54 → 1.0.0-beta.55

package/dist/runtime/client/client.js

@@ -64,22 +64,7 @@ export const fetchTransport = (transportContext) => {
                 });
             }
         }
-        // If there's a response handler, check the response first
-        if (transportContext.handleResponse) {
-            const response = await fetchPromise;
-            const shouldContinue = transportContext.handleResponse(response);
-            if (!shouldContinue) {
-                return;
-            }
-            // Continue with the response if handler returned true
-            const streamData = createFromFetch(Promise.resolve(response), {
-                callServer: fetchCallServer,
-            });
-            if (source === "navigation" || source === "action") {
-                transportContext.setRscPayload(streamData);
-            }
-            const result = await streamData;
-            const rawActionResult = result.actionResult;
+        const processActionResponse = (rawActionResult) => {
             if (isActionResponse(rawActionResult)) {
                 const actionResponse = rawActionResult.__rw_action_response;
                 const handledByHook = transportContext.onActionResponse?.(actionResponse) === true;
@@ -90,34 +75,49 @@ export const fetchTransport = (transportContext) => {
                         window.location.href = location;
                         return undefined;
                     }
+                    if (actionResponse.status >= 400) {
+                        throw new Error(`Server function returned status ${actionResponse.status}`);
+                    }
                 }
                 return rawActionResult;
             }
             return rawActionResult;
+        };
+        // If there's a response handler, check the response first
+        if (transportContext.handleResponse) {
+            const response = await fetchPromise;
+            const shouldContinue = transportContext.handleResponse(response);
+            if (!shouldContinue) {
+                return undefined;
+            }
+            // Continue with the response if handler returned true
+            const streamData = createFromFetch(Promise.resolve(response), {
+                callServer: fetchCallServer,
+            });
+            if (source === "navigation" || source === "action") {
+                transportContext.setRscPayload(streamData);
+            }
+            const result = await streamData;
+            return processActionResponse(result.actionResult);
         }
         // Original behavior when no handler is present
-        const streamData = createFromFetch(fetchPromise, {
+        const response = await fetchPromise;
+        console.log("[fetchTransport] Response status:", response.status);
+        const location = response.headers.get("Location");
+        console.log("[fetchTransport] Location header:", location);
+        if (response.status >= 300 && response.status < 400 && location) {
+            console.log("[fetchTransport] Redirecting to:", location);
+            window.location.href = location;
+            return undefined;
+        }
+        const streamData = createFromFetch(Promise.resolve(response), {
             callServer: fetchCallServer,
         });
         if (source === "navigation" || source === "action") {
             transportContext.setRscPayload(streamData);
         }
         const result = await streamData;
-        const rawActionResult = result.actionResult;
-        if (isActionResponse(rawActionResult)) {
-            const actionResponse = rawActionResult.__rw_action_response;
-            const handledByHook = transportContext.onActionResponse?.(actionResponse) === true;
-            if (!handledByHook) {
-                const location = actionResponse.headers["location"];
-                const isRedirect = actionResponse.status >= 300 && actionResponse.status < 400;
-                if (location && isRedirect) {
-                    window.location.href = location;
-                    return undefined;
-                }
-            }
-            return rawActionResult;
-        }
-        return rawActionResult;
+        return processActionResponse(result.actionResult);
     };
     return fetchCallServer;
 };

package/dist/runtime/client/navigation.js

@@ -122,6 +122,13 @@ export function initClientNavigation(opts = {}) {
         await globalThis.__rsc_callServer(null, null, "navigation");
     });
     function handleResponse(response) {
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get("Location");
+            if (location) {
+                window.location.href = location;
+                return false;
+            }
+        }
         if (!response.ok) {
             // Redirect to the current page (window.location) to show the error
             // This means the page that produced the error is called twice.

package/dist/runtime/client/navigation.test.js

@@ -1,8 +1,31 @@
-import { describe, expect, it } from "vitest";
-import { validateClickEvent } from "./navigation";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { validateClickEvent, initClientNavigation } from "./navigation";
+// Mocking browser globals
+vi.stubGlobal("window", {
+    location: { href: "http://localhost/" },
+    addEventListener: vi.fn(),
+    history: { scrollRestoration: "auto" },
+});
+vi.stubGlobal("document", {
+    addEventListener: vi.fn(),
+});
+vi.stubGlobal("history", {
+    scrollRestoration: "auto",
+});
+vi.stubGlobal("Headers", class {
+    constructor(init) {
+        this.map = {};
+        if (init && init.Location) {
+            this.map.location = init.Location;
+        }
+    }
+    get(name) {
+        return this.map[name.toLowerCase()] || null;
+    }
+});
 describe("clientNavigation", () => {
     let mockEvent = {
-        button: 0, // right click
+        button: 0,
         metaKey: false,
         altKey: false,
         shiftKey: false,
@@ -52,3 +75,30 @@ describe("clientNavigation", () => {
         })).toBe(true);
     });
 });
+describe("initClientNavigation", () => {
+    beforeEach(() => {
+        window.location.href = "http://localhost/";
+        vi.clearAllMocks();
+    });
+    it("handleResponse should follow redirects", () => {
+        const { handleResponse } = initClientNavigation();
+        const mockResponse = {
+            status: 302,
+            headers: new Headers({ Location: "/new-page" }),
+            ok: false,
+        };
+        const result = handleResponse(mockResponse);
+        expect(result).toBe(false);
+        expect(window.location.href).toBe("/new-page");
+    });
+    it("handleResponse should reload on error", () => {
+        const { handleResponse } = initClientNavigation();
+        const mockResponse = {
+            status: 500,
+            ok: false,
+        };
+        const result = handleResponse(mockResponse);
+        expect(result).toBe(false);
+        expect(window.location.href).toBe("http://localhost/");
+    });
+});

package/dist/runtime/server.d.ts

@@ -1,8 +1,8 @@
-type Interruptor<TArgs extends any[] = any[], TResult = any> = (context: {
+type Interruptor<TArgs extends any[] = any[]> = (context: {
     request: Request;
     ctx: Record<string, any>;
     args: TArgs;
-}) => Promise<Response | void | TResult> | Response | void | TResult;
+}) => Promise<Response | void> | Response | void;
 type ServerFunction<TArgs extends any[] = any[], TResult = any> = (...args: TArgs) => Promise<TResult>;
 type ServerFunctionOptions = {
     method?: "GET" | "POST";
@@ -29,7 +29,7 @@ type WrappedServerFunction<TArgs extends any[] = any[], TResult = any> = {
  * })
  * ```
  */
-export declare function serverQuery<TArgs extends any[] = any[], TResult = any>(fnsOrFn: ServerFunction<TArgs, TResult> | [...Interruptor<TArgs, TResult>[], ServerFunction<TArgs, TResult>], options?: ServerFunctionOptions): WrappedServerFunction<TArgs, TResult>;
+export declare function serverQuery<TArgs extends any[], TResult>(fnsOrFn: ServerFunction<TArgs, TResult> | [...Interruptor<TArgs>[], ServerFunction<TArgs, TResult>], options?: ServerFunctionOptions): WrappedServerFunction<TArgs, TResult>;
 /**
  * Wrap a function to be used as a server action.
  *
@@ -48,5 +48,5 @@ export declare function serverQuery<TArgs extends any[] = any[], TResult = any>(
  * })
  * ```
  */
-export declare function serverAction<TArgs extends any[] = any[], TResult = any>(fnsOrFn: ServerFunction<TArgs, TResult> | [...Interruptor<TArgs, TResult>[], ServerFunction<TArgs, TResult>], options?: ServerFunctionOptions): WrappedServerFunction<TArgs, TResult>;
+export declare function serverAction<TArgs extends any[], TResult>(fnsOrFn: ServerFunction<TArgs, TResult> | [...Interruptor<TArgs>[], ServerFunction<TArgs, TResult>], options?: ServerFunctionOptions): WrappedServerFunction<TArgs, TResult>;
 export {};

package/dist/runtime/server.js

@@ -6,18 +6,14 @@ function createServerFunction(fns, mainFn, options) {
         for (const fn of fns) {
             const result = await fn({ request, ctx, args });
             if (result instanceof Response) {
-                // We can't easily return a Response from a server action function
-                // because the return type is expected to be TResult.
-                // However, if the interruptor returns a Response, it usually means "stop and return this HTTP response".
-                // In the RSC context, throwing a Response is a common pattern to short-circuit.
-                throw result;
+                // We return the Response so it can be handled by the action handler
+                // and serialized into the RSC stream via normalizeActionResult.
+                return result;
             }
         }
         return mainFn(...args);
     };
-    wrapped.method = options?.method ?? "POST"; // Default to POST if not specified, though user said serverQuery defaults to GET?
-    // User said: "export const getProject = serverQuery(...) // Defaults to GET"
-    // So serverQuery defaults to GET, serverAction defaults to POST?
+    wrapped.method = options?.method ?? "POST";
     return wrapped;
 }
 /**

package/dist/vite/transformServerFunctions.test.mjs

@@ -119,6 +119,33 @@ export default serverQuery(async (id) => {
 export default serverAction(async (id) => {
   return { id, name: "Project X" };
 });
+`;
+    let SERVER_QUERY_ARRAY_CODE = `
+"use server";
+export const getProject = serverQuery([
+  auth,
+  async (id) => {
+    return { id, name: "Project X" };
+  }
+]);
+`;
+    let SERVER_ACTION_ARRAY_CODE = `
+"use server";
+export const upvote = serverAction([
+  auth,
+  async (id) => {
+    return { id, count: 1 };
+  }
+]);
+`;
+    let SERVER_QUERY_ARRAY_POST_CODE = `
+"use server";
+export const getProject = serverQuery([
+  auth,
+  async (id) => {
+    return { id, name: "Project X" };
+  }
+], { method: "POST" });
 `;
     const TEST_CASES = {
         COMMENT_CODE,
@@ -137,6 +164,9 @@ export default serverAction(async (id) => {
         SERVER_ACTION_CODE,
         SERVER_QUERY_DEFAULT_CODE,
         SERVER_ACTION_DEFAULT_CODE,
+        SERVER_QUERY_ARRAY_CODE,
+        SERVER_ACTION_ARRAY_CODE,
+        SERVER_QUERY_ARRAY_POST_CODE,
     };
     describe("TRANSFORMS", () => {
         for (const [key, CODE] of Object.entries(TEST_CASES)) {

package/package.json

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