rwsdk 1.0.9 → 1.1.0

package/dist/lib/e2e/testHarness.mjs

@@ -231,10 +231,15 @@ export function createDeployment() {
                     ? match[1]
                     : Math.random().toString(36).substring(2, 15);
                 const deployResult = await runRelease(projectDir, projectDir, resourceUniqueKey);
+                // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
+                // "There is nothing here yet" placeholder before the worker code
+                // propagates globally. Wait until the response body contains the
+                // rwsdk-rendered marker so tests don't run against the placeholder.
                 await poll(async () => {
                     try {
                         const response = await fetch(deployResult.url);
-                        return response.status > 0;
+                        const body = await response.text();
+                        return body.includes("__RWSDK_CONTEXT");
                     }
                     catch (e) {
                         return false;

package/dist/lib/smokeTests/codeUpdates.mjs

@@ -75,9 +75,9 @@ export async function createSmokeTestStylesheets(targetDir) {
     const urlStylesPath = join(appDir, "smokeTestUrlStyles.css");
     log("Creating smokeTestUrlStyles.css at: %s", urlStylesPath);
     await fs.writeFile(urlStylesPath, smokeTestUrlStylesCssTemplate);
-    // Modify Document.tsx to include the URL stylesheet using CSS URL import
-    const documentPath = join(appDir, "Document.tsx");
-    log("Modifying Document.tsx to include URL stylesheet at: %s", documentPath);
+    // Modify document.tsx to include the URL stylesheet using CSS URL import
+    const documentPath = join(appDir, "document.tsx");
+    log("Modifying document.tsx to include URL stylesheet at: %s", documentPath);
     try {
         const documentContent = await fs.readFile(documentPath, "utf-8");
         const s = new MagicString(documentContent);
@@ -90,14 +90,14 @@ export async function createSmokeTestStylesheets(targetDir) {
         if (headTagEnd !== -1) {
             s.appendLeft(headTagEnd, '      <link rel="stylesheet" href={smokeTestUrlStyles} />\n');
             await fs.writeFile(documentPath, s.toString(), "utf-8");
-            log("Successfully modified Document.tsx with CSS URL import pattern");
+            log("Successfully modified document.tsx with CSS URL import pattern");
         }
         else {
-            log("Could not find </head> tag in Document.tsx");
+            log("Could not find </head> tag in document.tsx");
         }
     }
     catch (e) {
-        log("Could not modify Document.tsx: %s", e);
+        log("Could not modify document.tsx: %s", e);
     }
     log("Smoke test stylesheets created successfully");
 }

package/dist/lib/smokeTests/release.mjs

@@ -9,6 +9,35 @@ export { $expect, deleteD1Database, deleteWorker, isRelatedToTest, listD1Databas
 export async function runRelease(cwd, projectDir, resourceUniqueKey) {
     return runE2ERelease(cwd, projectDir, resourceUniqueKey);
 }
+async function waitForDeploymentContent(baseUrl, { timeoutMs = 60_000, intervalMs = 2_000, } = {}) {
+    const marker = "__RWSDK_CONTEXT";
+    const deadline = Date.now() + timeoutMs;
+    let attempt = 0;
+    let lastStatus;
+    let lastBytes = 0;
+    while (Date.now() < deadline) {
+        attempt += 1;
+        try {
+            const res = await fetch(baseUrl);
+            const body = await res.text();
+            lastStatus = res.status;
+            lastBytes = body.length;
+            if (body.includes(marker)) {
+                log("Deployment content verified at %s after %d attempt(s)", baseUrl, attempt);
+                console.log(`✅ Deployment content ready at ${baseUrl} (attempt ${attempt})`);
+                return;
+            }
+            log("Attempt %d: %s returned %d (%d bytes), no app marker yet", attempt, baseUrl, res.status, body.length);
+        }
+        catch (err) {
+            log("Attempt %d: fetch failed for %s: %O", attempt, baseUrl, err);
+        }
+        await setTimeout(intervalMs);
+    }
+    throw new Error(`Deployment at ${baseUrl} did not serve app content within ${timeoutMs}ms ` +
+        `(last status ${lastStatus ?? "n/a"}, ${lastBytes} bytes). ` +
+        `Likely Cloudflare *.workers.dev propagation still in progress.`);
+}
 /**
  * Runs tests against the production deployment
  */
@@ -23,6 +52,12 @@ export async function runReleaseTest(artifactDir, resources, browserPath, headle
         await setTimeout(1000);
         // DRY: check both root and custom path
         await checkServerUp(url, "/");
+        // A fresh *.workers.dev subdomain can return 200 with Cloudflare's
+        // "There is nothing here yet" placeholder before the worker code is
+        // globally propagated. Poll the URL until the response body contains
+        // an rwsdk-rendered marker so we don't run the browser tests against
+        // the placeholder.
+        await waitForDeploymentContent(url);
         // Now run the tests with the custom path
         const testUrl = new URL("/__smoke_test", url).toString();
         await checkUrl(testUrl, artifactDir, browserPath, headless, bail, skipClient, "Production", realtime, resources.targetDir, // Add target directory parameter

package/dist/runtime/server.d.ts

@@ -11,6 +11,34 @@ type WrappedServerFunction<TArgs extends any[] = any[], TResult = any> = {
     (...args: TArgs): Promise<TResult>;
     method?: "GET" | "POST";
 };
+export type ServerFunctionWrap = (fn: Function, args: any[], type: "action" | "query") => Promise<any>;
+/**
+ * Register a wrapper that runs around every server action and query handler.
+ *
+ * Call this once in your worker entry point. The wrapper receives the main
+ * handler function, its arguments, and the type ("action" or "query").
+ * Interruptors run *outside* the wrapper.
+ *
+ * Throws if called more than once.
+ *
+ * @example
+ * ```ts
+ * import { registerServerFunctionWrap } from "rwsdk/worker";
+ * import * as Sentry from "@sentry/cloudflare";
+ *
+ * registerServerFunctionWrap((fn, args, type) =>
+ *   Sentry.startSpan(
+ *     { name: fn.name, op: `function.rsc_${type}` },
+ *     () => fn(...args)
+ *   )
+ * );
+ * ```
+ */
+export declare function registerServerFunctionWrap(wrap: ServerFunctionWrap): void;
+/**
+ * @internal Reset the global wrap — only for tests.
+ */
+export declare function __resetServerFunctionWrap(): void;
 /**
  * Wrap a function to be used as a server query.
  *

package/dist/runtime/server.js

@@ -1,4 +1,40 @@
 import { requestInfo } from "./requestInfo/worker";
+let globalWrap;
+/**
+ * Register a wrapper that runs around every server action and query handler.
+ *
+ * Call this once in your worker entry point. The wrapper receives the main
+ * handler function, its arguments, and the type ("action" or "query").
+ * Interruptors run *outside* the wrapper.
+ *
+ * Throws if called more than once.
+ *
+ * @example
+ * ```ts
+ * import { registerServerFunctionWrap } from "rwsdk/worker";
+ * import * as Sentry from "@sentry/cloudflare";
+ *
+ * registerServerFunctionWrap((fn, args, type) =>
+ *   Sentry.startSpan(
+ *     { name: fn.name, op: `function.rsc_${type}` },
+ *     () => fn(...args)
+ *   )
+ * );
+ * ```
+ */
+export function registerServerFunctionWrap(wrap) {
+    if (globalWrap) {
+        throw new Error("registerServerFunctionWrap() has already been called. " +
+            "Only one wrapper can be registered.");
+    }
+    globalWrap = wrap;
+}
+/**
+ * @internal Reset the global wrap — only for tests.
+ */
+export function __resetServerFunctionWrap() {
+    globalWrap = undefined;
+}
 function createServerFunction(fns, mainFn, options) {
     const wrapped = async (...args) => {
         const { request, ctx } = requestInfo;
@@ -11,6 +47,9 @@ function createServerFunction(fns, mainFn, options) {
                 return result;
             }
         }
+        if (globalWrap) {
+            return globalWrap(mainFn, args, options?.__type ?? "action");
+        }
         return mainFn(...args);
     };
     wrapped.method = options?.method ?? "POST";
@@ -45,7 +84,7 @@ export function serverQuery(fnsOrFn, options) {
         mainFn = fnsOrFn;
     }
     const method = options?.method ?? "GET"; // Default to GET for query
-    const wrapped = createServerFunction(fns, mainFn, { ...options, method });
+    const wrapped = createServerFunction(fns, mainFn, { ...options, method, __type: "query" });
     wrapped.method = method;
     return wrapped;
 }
@@ -78,7 +117,7 @@ export function serverAction(fnsOrFn, options) {
         mainFn = fnsOrFn;
     }
     const method = options?.method ?? "POST"; // Default to POST for action
-    const wrapped = createServerFunction(fns, mainFn, { ...options, method });
+    const wrapped = createServerFunction(fns, mainFn, { ...options, method, __type: "action" });
     wrapped.method = method;
     return wrapped;
 }

package/dist/runtime/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server.test.js

@@ -0,0 +1,130 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+let mockRequestInfo;
+vi.mock("./requestInfo/worker", () => ({
+    get requestInfo() {
+        return mockRequestInfo;
+    },
+}));
+import { serverAction, serverQuery, registerServerFunctionWrap, __resetServerFunctionWrap, } from "./server";
+describe("registerServerFunctionWrap", () => {
+    beforeEach(() => {
+        __resetServerFunctionWrap();
+        mockRequestInfo = {
+            request: new Request("https://test.example/"),
+            ctx: {},
+        };
+    });
+    it("wraps serverAction handlers", async () => {
+        const wrapSpy = vi.fn((fn, args, _type) => fn(...args));
+        registerServerFunctionWrap(wrapSpy);
+        const action = serverAction(async function createThing(name) {
+            return `created ${name}`;
+        });
+        const result = await action("foo");
+        expect(wrapSpy).toHaveBeenCalledOnce();
+        expect(wrapSpy.mock.calls[0][2]).toBe("action");
+        expect(result).toBe("created foo");
+    });
+    it("wraps serverQuery handlers", async () => {
+        const wrapSpy = vi.fn((fn, args, _type) => fn(...args));
+        registerServerFunctionWrap(wrapSpy);
+        const query = serverQuery(async function getThings() {
+            return [1, 2, 3];
+        });
+        const result = await query();
+        expect(wrapSpy).toHaveBeenCalledOnce();
+        expect(wrapSpy.mock.calls[0][2]).toBe("query");
+        expect(result).toEqual([1, 2, 3]);
+    });
+    it("passes the main function and args to the wrapper", async () => {
+        const wrapSpy = vi.fn((fn, args, _type) => fn(...args));
+        registerServerFunctionWrap(wrapSpy);
+        const action = serverAction(async function multiply(a, b) {
+            return a * b;
+        });
+        await action(3, 7);
+        const [fn, args] = wrapSpy.mock.calls[0];
+        expect(fn.name).toBe("multiply");
+        expect(args).toEqual([3, 7]);
+    });
+    it("interruptors run outside the wrapper", async () => {
+        const order = [];
+        registerServerFunctionWrap((fn, args, _type) => {
+            order.push("wrap:start");
+            const result = fn(...args);
+            order.push("wrap:end");
+            return result;
+        });
+        const interruptor = async () => {
+            order.push("interruptor");
+        };
+        const action = serverAction([
+            interruptor,
+            async function doWork() {
+                order.push("handler");
+                return "done";
+            },
+        ]);
+        await action();
+        expect(order).toEqual([
+            "interruptor",
+            "wrap:start",
+            "handler",
+            "wrap:end",
+        ]);
+    });
+    it("wrapper is not called when an interruptor short-circuits", async () => {
+        const wrapSpy = vi.fn((fn, args, _type) => fn(...args));
+        registerServerFunctionWrap(wrapSpy);
+        const action = serverAction([
+            async () => new Response("blocked", { status: 403 }),
+            async function neverCalled() {
+                return "nope";
+            },
+        ]);
+        const result = await action();
+        expect(wrapSpy).not.toHaveBeenCalled();
+        expect(result).toBeInstanceOf(Response);
+    });
+    it("throws if called more than once", () => {
+        registerServerFunctionWrap(async (fn, args) => fn(...args));
+        expect(() => {
+            registerServerFunctionWrap(async (fn, args) => fn(...args));
+        }).toThrow("registerServerFunctionWrap() has already been called");
+    });
+    it("without registration, handlers work normally", async () => {
+        const action = serverAction(async function echo(msg) {
+            return msg;
+        });
+        const result = await action("hello");
+        expect(result).toBe("hello");
+    });
+    it("wrapper can transform the return value", async () => {
+        registerServerFunctionWrap(async (fn, args, _type) => {
+            const result = await fn(...args);
+            return { wrapped: true, result };
+        });
+        const action = serverAction(async function getValue() {
+            return 42;
+        });
+        const result = await action();
+        expect(result).toEqual({ wrapped: true, result: 42 });
+    });
+    it("works with array-style serverAction (interruptors + handler)", async () => {
+        const wrapSpy = vi.fn((fn, args, _type) => fn(...args));
+        registerServerFunctionWrap(wrapSpy);
+        const action = serverAction([
+            async ({ ctx }) => {
+                ctx.authed = true;
+            },
+            async function save(data) {
+                return `saved ${data}`;
+            },
+        ]);
+        const result = await action("test");
+        expect(result).toBe("saved test");
+        expect(wrapSpy).toHaveBeenCalledOnce();
+        const [fn] = wrapSpy.mock.calls[0];
+        expect(fn.name).toBe("save");
+    });
+});

package/package.json

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