rwsdk 1.0.0-beta.48 → 1.0.0-beta.49-test.20260121220325

package/dist/runtime/client/client.js

@@ -16,12 +16,16 @@ export { initClientNavigation, navigate } from "./navigation.js";
 import { getCachedNavigationResponse } from "./navigationCache.js";
 import { isActionResponse } from "./types";
 export const fetchTransport = (transportContext) => {
-    const fetchCallServer = async (id, args, source = "action") => {
+    const fetchCallServer = async (id, args, source = "action", method = "POST") => {
         const url = new URL(window.location.href);
         url.searchParams.set("__rsc", "");
         const isAction = id != null;
         if (isAction) {
             url.searchParams.set("__rsc_action_id", id);
+            // If args are provided and method is GET, serialize them into the query string
+            if (args != null && method === "GET") {
+                url.searchParams.set("args", JSON.stringify(args));
+            }
         }
         let fetchPromise;
         if (!isAction && source === "navigation") {
@@ -39,11 +43,26 @@ export const fetchTransport = (transportContext) => {
             }
         }
         else {
-            fetchPromise = fetch(url, {
-                method: "POST",
-                redirect: "manual",
-                body: args != null ? await encodeReply(args) : null,
-            });
+            const headers = new Headers();
+            // Add x-rsc-data-only header if we want to skip the React tree render on the server
+            if (source === "query") {
+                headers.set("x-rsc-data-only", "true");
+            }
+            if (method === "GET") {
+                fetchPromise = fetch(url, {
+                    method: "GET",
+                    headers,
+                    redirect: "manual",
+                });
+            }
+            else {
+                fetchPromise = fetch(url, {
+                    method: "POST",
+                    headers,
+                    redirect: "manual",
+                    body: args != null ? await encodeReply(args) : null,
+                });
+            }
         }
         // If there's a response handler, check the response first
         if (transportContext.handleResponse) {
@@ -56,7 +75,9 @@ export const fetchTransport = (transportContext) => {
             const streamData = createFromFetch(Promise.resolve(response), {
                 callServer: fetchCallServer,
             });
-            transportContext.setRscPayload(streamData);
+            if (source === "navigation" || source === "action") {
+                transportContext.setRscPayload(streamData);
+            }
             const result = await streamData;
             const rawActionResult = result.actionResult;
             if (isActionResponse(rawActionResult)) {
@@ -78,7 +99,9 @@ export const fetchTransport = (transportContext) => {
         const streamData = createFromFetch(fetchPromise, {
             callServer: fetchCallServer,
         });
-        transportContext.setRscPayload(streamData);
+        if (source === "navigation" || source === "action") {
+            transportContext.setRscPayload(streamData);
+        }
         const result = await streamData;
         const rawActionResult = result.actionResult;
         if (isActionResponse(rawActionResult)) {
@@ -164,8 +187,8 @@ export const initClient = async ({ transport = fetchTransport, hydrateRootOption
         onActionResponse,
     };
     let transportCallServer = transport(transportContext);
-    const callServer = (id, args, source) => {
-        return transportCallServer(id, args, source);
+    const callServer = (id, args, source, method) => {
+        return transportCallServer(id, args, source, method);
     };
     const upgradeToRealtime = async ({ key } = {}) => {
         const { realtimeTransport } = await import("../lib/realtime/client");

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

@@ -1,6 +1,5 @@
-import type { CallServerCallback } from "react-server-dom-webpack/client.browser";
 export type { HydrationOptions } from "react-dom/client";
-export type { CallServerCallback } from "react-server-dom-webpack/client.browser";
+export type CallServerCallback = <Result>(id: null | string, args: null | unknown[], source?: "action" | "navigation" | "query", method?: "GET" | "POST") => Promise<Result | undefined>;
 export type RscActionResponse<Result> = {
     node: React.ReactNode;
     actionResult: Result;
@@ -32,4 +31,4 @@ export type TransportContext = {
     onActionResponse?: (actionResponse: ActionResponseData) => boolean | void;
 };
 export type Transport = (context: TransportContext) => CallServerCallback;
-export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[], source?: "action" | "navigation") => Promise<Result>;
+export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[], source?: "action" | "navigation" | "query", method?: "GET" | "POST") => Promise<Result | undefined>;

package/dist/runtime/client/types.js

@@ -1,3 +1,4 @@
+// import type { CallServerCallback } from "react-server-dom-webpack/client.browser";
 export function isActionResponse(value) {
     return (typeof value === "object" &&
         value !== null &&

package/dist/runtime/entries/worker.d.ts

@@ -10,4 +10,5 @@ export * from "../requestInfo/types";
 export * from "../requestInfo/utils";
 export * from "../requestInfo/worker";
 export * from "../script";
+export * from "../server";
 export * from "../worker";

package/dist/runtime/entries/worker.js

@@ -10,4 +10,5 @@ export * from "../requestInfo/types";
 export * from "../requestInfo/utils";
 export * from "../requestInfo/worker";
 export * from "../script";
+export * from "../server";
 export * from "../worker";

package/dist/runtime/lib/realtime/client.js

@@ -58,7 +58,7 @@ export const realtimeTransport = ({ key = DEFAULT_KEY, handleResponse, }) => (tr
         }
         return ws;
     };
-    const realtimeCallServer = async (id, args) => {
+    const realtimeCallServer = async (id, args, _source, _method) => {
         try {
             const socket = ensureWs();
             const { encodeReply } = await import("react-server-dom-webpack/client.browser");
@@ -82,7 +82,7 @@ export const realtimeTransport = ({ key = DEFAULT_KEY, handleResponse, }) => (tr
         }
         catch (e) {
             console.error("[Realtime] Error calling server", e);
-            return null;
+            return undefined;
         }
     };
     const processResponse = async (response) => {
@@ -99,7 +99,7 @@ export const realtimeTransport = ({ key = DEFAULT_KEY, handleResponse, }) => (tr
                 streamForRsc = response.body;
             }
             if (!shouldContinue) {
-                return null;
+                return undefined;
             }
             const rscPayload = createFromReadableStream(streamForRsc, {
                 callServer: realtimeCallServer,
@@ -114,7 +114,7 @@ export const realtimeTransport = ({ key = DEFAULT_KEY, handleResponse, }) => (tr
                     const isRedirect = actionResponse.status >= 300 && actionResponse.status < 400;
                     if (location && isRedirect) {
                         window.location.href = location;
-                        return null;
+                        return undefined;
                     }
                 }
                 return rawActionResult;

package/dist/runtime/lib/router.js

@@ -314,7 +314,7 @@ export function defineRoutes(routes) {
                             if (isRouteComponent(componentHandler)) {
                                 const requestInfo = getRequestInfo();
                                 const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(componentHandler), route.layouts || [], requestInfo);
-                                if (!isClientReference(componentHandler)) {
+                                if (!isClientReference(componentHandler) && !requestInfo.rw.pageRouteResolved) {
                                     requestInfo.rw.pageRouteResolved = Promise.withResolvers();
                                 }
                                 return await renderPage(requestInfo, WrappedComponent, onError);

package/dist/runtime/register/client.d.ts

@@ -1 +1 @@
-export declare const createServerReference: (id: string, name: string) => Function;
+export declare const createServerReference: (id: string, name: string, method?: "GET" | "POST", source?: "action" | "query") => Function;

package/dist/runtime/register/client.js

@@ -1,5 +1,12 @@
 import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.browser";
-export const createServerReference = (id, name) => {
-    id = id + "#" + name;
-    return baseCreateServerReference(id, globalThis.__rsc_callServer);
+export const createServerReference = (id, name, method, source = "action") => {
+    const fullId = id + "#" + name;
+    const proxy = baseCreateServerReference(fullId, (id, args) => {
+        return globalThis.__rsc_callServer(id, args, source, method);
+    });
+    // Attach metadata that hooks like useQuery can use
+    proxy.id = fullId;
+    proxy.method = method;
+    proxy.source = source;
+    return proxy;
 };

package/dist/runtime/register/worker.js

@@ -50,10 +50,19 @@ export async function __smokeTestActionHandler(timestamp) {
 export async function rscActionHandler(req) {
     const url = new URL(req.url);
     const contentType = req.headers.get("content-type");
-    const data = contentType?.startsWith("multipart/form-data")
-        ? await req.formData()
-        : await req.text();
-    const args = (await decodeReply(data, null));
+    let args = [];
+    if (req.method === "GET") {
+        const argsParam = url.searchParams.get("args");
+        if (argsParam) {
+            args = JSON.parse(argsParam);
+        }
+    }
+    else {
+        const data = contentType?.startsWith("multipart/form-data")
+            ? await req.formData()
+            : await req.text();
+        args = (await decodeReply(data, null));
+    }
     const actionId = url.searchParams.get("__rsc_action_id");
     if (import.meta.env.VITE_IS_DEV_SERVER && actionId === "__rsc_hot_update") {
         return null;

package/dist/runtime/server.d.ts

@@ -0,0 +1,52 @@
+type Interruptor<TArgs extends any[] = any[], TResult = any> = (context: {
+    request: Request;
+    ctx: Record<string, any>;
+    args: TArgs;
+}) => Promise<Response | void | TResult> | Response | void | TResult;
+type ServerFunction<TArgs extends any[] = any[], TResult = any> = (...args: TArgs) => Promise<TResult>;
+type ServerFunctionOptions = {
+    method?: "GET" | "POST";
+};
+type WrappedServerFunction<TArgs extends any[] = any[], TResult = any> = {
+    (...args: TArgs): Promise<TResult>;
+    method?: "GET" | "POST";
+};
+/**
+ * Wrap a function to be used as a server query.
+ *
+ * - **Method**: Defaults to `GET`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it returns data-only and does **not** rehydrate or re-render the React page.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `queries.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // getters.ts
+ * "use server"
+ *
+ * export const getUser = serverQuery(async (id: string) => {
+ *   return db.user.findUnique({ where: { id } })
+ * })
+ * ```
+ */
+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>;
+/**
+ * Wrap a function to be used as a server action.
+ *
+ * - **Method**: Defaults to `POST`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it **will** rehydrate and re-render the React page with the new server state.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `actions.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // actions.ts
+ * "use server"
+ *
+ * export const updateUser = serverAction(async (id: string, data: any) => {
+ *   return db.user.update({ where: { id }, data })
+ * })
+ * ```
+ */
+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 {};

package/dist/runtime/server.js

@@ -0,0 +1,88 @@
+import { requestInfo } from "./requestInfo/worker";
+function createServerFunction(fns, mainFn, options) {
+    const wrapped = async (...args) => {
+        const { request, ctx } = requestInfo;
+        // Execute interruptors
+        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;
+            }
+        }
+        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?
+    return wrapped;
+}
+/**
+ * Wrap a function to be used as a server query.
+ *
+ * - **Method**: Defaults to `GET`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it returns data-only and does **not** rehydrate or re-render the React page.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `queries.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // getters.ts
+ * "use server"
+ *
+ * export const getUser = serverQuery(async (id: string) => {
+ *   return db.user.findUnique({ where: { id } })
+ * })
+ * ```
+ */
+export function serverQuery(fnsOrFn, options) {
+    let fns = [];
+    let mainFn;
+    if (Array.isArray(fnsOrFn)) {
+        fns = fnsOrFn.slice(0, -1);
+        mainFn = fnsOrFn[fnsOrFn.length - 1];
+    }
+    else {
+        mainFn = fnsOrFn;
+    }
+    const method = options?.method ?? "GET"; // Default to GET for query
+    const wrapped = createServerFunction(fns, mainFn, { ...options, method });
+    wrapped.method = method;
+    return wrapped;
+}
+/**
+ * Wrap a function to be used as a server action.
+ *
+ * - **Method**: Defaults to `POST`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it **will** rehydrate and re-render the React page with the new server state.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `actions.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // actions.ts
+ * "use server"
+ *
+ * export const updateUser = serverAction(async (id: string, data: any) => {
+ *   return db.user.update({ where: { id }, data })
+ * })
+ * ```
+ */
+export function serverAction(fnsOrFn, options) {
+    let fns = [];
+    let mainFn;
+    if (Array.isArray(fnsOrFn)) {
+        fns = fnsOrFn.slice(0, -1);
+        mainFn = fnsOrFn[fnsOrFn.length - 1];
+    }
+    else {
+        mainFn = fnsOrFn;
+    }
+    const method = options?.method ?? "POST"; // Default to POST for action
+    const wrapped = createServerFunction(fns, mainFn, { ...options, method });
+    wrapped.method = method;
+    return wrapped;
+}

package/dist/runtime/worker.js

@@ -117,7 +117,13 @@ export const defineApp = (routes) => {
                         });
                     }
                     const actionResult = normalizeActionResult(requestInfo.rw.actionResult);
-                    const pageElement = createPageElement(requestInfo, Page);
+                    const isDataOnly = request.headers.get("x-rsc-data-only") === "true";
+                    const pageElement = isDataOnly && actionResult !== undefined
+                        ? null
+                        : createPageElement(requestInfo, Page);
+                    if (pageElement === null) {
+                        rw.pageRouteResolved?.resolve();
+                    }
                     const { rscPayload: shouldInjectRSCPayload } = rw;
                     let rscPayloadStream = renderToRscStream({
                         input: {

package/dist/vite/transformServerFunctions.mjs

@@ -111,16 +111,78 @@ export const transformServerFunctions = (code, normalizedId, environment, server
         else {
             s.append('import { createServerReference } from "rwsdk/client";\n\n');
         }
+        const ext = path.extname(normalizedId).toLowerCase();
+        const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+        const root = sgParse(lang, code);
         for (const name of allExports) {
             if (name !== "default" && name !== defaultFunctionName) {
-                s.append(`export let ${name} = createServerReference(${JSON.stringify(normalizedId)}, ${JSON.stringify(name)});\n`);
-                log(`Added ${environment} server reference for function: %s in normalizedId=%s`, name, normalizedId);
+                let method;
+                let source = "action";
+                // Try to find if this export is a serverQuery or serverAction call to extract the method
+                const patterns = [
+                    `export const ${name} = serverQuery($$$, { method: "$METHOD" })`,
+                    `export const ${name} = serverQuery($$$)`,
+                    `export const ${name} = serverAction($$$)`,
+                ];
+                for (const pattern of patterns) {
+                    const matches = root.root().findAll(pattern);
+                    if (matches.length > 0) {
+                        if (pattern.includes("serverQuery")) {
+                            const methodMatch = matches[0].getMatch("METHOD");
+                            method = methodMatch ? methodMatch.text() : "GET";
+                            source = "query";
+                        }
+                        else if (pattern.includes("serverAction")) {
+                            method = "POST";
+                            source = "action";
+                        }
+                        break;
+                    }
+                }
+                let extraArgs = "";
+                if (source === "query") {
+                    extraArgs = `, ${JSON.stringify(method ?? "GET")}, "query"`;
+                }
+                else if (method !== undefined) {
+                    extraArgs = `, ${JSON.stringify(method)}`;
+                }
+                s.append(`export let ${name} = createServerReference(${JSON.stringify(normalizedId)}, ${JSON.stringify(name)}${extraArgs});\n`);
+                log(`Added ${environment} server reference for function: %s (method: %s, source: %s) in normalizedId=%s`, name, method || "default", source, normalizedId);
             }
         }
         // Check for default export in the actual module (not re-exports)
         if (hasDefaultExport(code, normalizedId)) {
-            s.append(`\nexport default createServerReference(${JSON.stringify(normalizedId)}, "default");\n`);
-            log(`Added ${environment} server reference for default export in normalizedId=%s`, normalizedId);
+            let method;
+            let source = "action";
+            const patterns = [
+                `export default serverQuery($$$, { method: "$METHOD" })`,
+                `export default serverQuery($$$)`,
+                `export default serverAction($$$)`,
+            ];
+            for (const pattern of patterns) {
+                const matches = root.root().findAll(pattern);
+                if (matches.length > 0) {
+                    if (pattern.includes("serverQuery")) {
+                        const methodMatch = matches[0].getMatch("METHOD");
+                        method = methodMatch ? methodMatch.text() : "GET";
+                        source = "query";
+                    }
+                    else if (pattern.includes("serverAction")) {
+                        method = "POST";
+                        source = "action";
+                    }
+                    break;
+                }
+            }
+            let extraArgs = "";
+            if (source === "query") {
+                extraArgs = `, ${JSON.stringify(method ?? "GET")}, "query"`;
+            }
+            else if (method !== undefined) {
+                extraArgs = `, ${JSON.stringify(method)}`;
+            }
+            s.append(`\nexport default createServerReference(${JSON.stringify(normalizedId)}, "default"${extraArgs});\n`);
+            log(`Added ${environment} server reference for default export (method: %s, source: %s) in normalizedId=%s`, method || "default", source, normalizedId);
         }
         process.env.VERBOSE &&
             log(`${environment} transformation complete for normalizedId=%s`, normalizedId);

package/dist/vite/transformServerFunctions.test.mjs

@@ -89,6 +89,36 @@ export async function sum() {
 export { sum } from './math';
 export { default as multiply } from './multiply';
 export * from './utils';
+`;
+    let SERVER_QUERY_GET_CODE = `
+"use server";
+export const getProject = serverQuery(async (id) => {
+  return { id, name: "Project X" };
+});
+`;
+    let SERVER_QUERY_POST_CODE = `
+"use server";
+export const getProject = serverQuery(async (id) => {
+  return { id, name: "Project X" };
+}, { method: "POST" });
+`;
+    let SERVER_ACTION_CODE = `
+"use server";
+export const upvote = serverAction(async (id) => {
+  return { id, count: 1 };
+});
+`;
+    let SERVER_QUERY_DEFAULT_CODE = `
+"use server";
+export default serverQuery(async (id) => {
+  return { id, name: "Project X" };
+});
+`;
+    let SERVER_ACTION_DEFAULT_CODE = `
+"use server";
+export default serverAction(async (id) => {
+  return { id, name: "Project X" };
+});
 `;
     const TEST_CASES = {
         COMMENT_CODE,
@@ -102,6 +132,11 @@ export * from './utils';
         RE_EXPORT_CODE,
         PREDEFINED_DEFAULT_EXPORT_CODE,
         EXPORT_DEFAULT_FUNCTION_CODE,
+        SERVER_QUERY_GET_CODE,
+        SERVER_QUERY_POST_CODE,
+        SERVER_ACTION_CODE,
+        SERVER_QUERY_DEFAULT_CODE,
+        SERVER_ACTION_DEFAULT_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.48",
+  "version": "1.0.0-beta.49-test.20260121220325",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -151,7 +151,7 @@
   "license": "MIT",
   "dependencies": {
     "@ast-grep/napi": "~0.39.0",
-    "@cloudflare/workers-types": "~4.20260111.0",
+    "@cloudflare/workers-types": "~4.20260120.0",
     "@mdx-js/mdx": "~3.1.1",
     "@puppeteer/browsers": "~2.10.0",
     "@types/decompress": "~4.2.7",
@@ -200,7 +200,7 @@
   },
   "packageManager": "pnpm@10.0.0+sha512.b8fef5494bd3fe4cbd4edabd0745df2ee5be3e4b0b8b08fa643aa3e4c6702ccc0f00d68fa8a8c9858a735a0032485a44990ed2810526c875e416f001b17df12b",
   "devDependencies": {
-    "@cloudflare/vite-plugin": "1.20.1",
+    "@cloudflare/vite-plugin": "1.21.1",
     "capnweb": "~0.2.0",
     "@types/debug": "~4.1.12",
     "@types/js-beautify": "~1.14.3",