rwsdk 1.0.8 → 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/normalizeModulePath.d.mts

@@ -1,3 +1,4 @@
+import path from "node:path";
 /**
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
@@ -28,4 +29,4 @@ export declare function findCommonAncestorDepth(path1: string, path2: string): n
 export declare function normalizeModulePath(modulePath: string, projectRootDir: string, options?: {
     absolute?: boolean;
     isViteStyle?: boolean;
-}): string;
+}, _path?: typeof path): string;

package/dist/lib/normalizeModulePath.mjs

@@ -1,5 +1,10 @@
-import { posix as path } from "node:path";
-import { normalizePath as normalizePathSeparators } from "vite";
+import path from "node:path";
+import { normalizePath } from "vite";
+const windowsDriveAbsoluteRE = /^[A-Za-z]:\//;
+// Vite's normalizePath only converts backslashes on Windows. This wrapper
+// ensures forward slashes regardless of platform, which matters when win32
+// path functions are injected for testing on Linux.
+const normalizePathSeparators = (p) => normalizePath(p.replace(/\\/g, "/"));
 /**
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
@@ -41,16 +46,16 @@ export function findCommonAncestorDepth(path1, path2) {
  *   /opt/tools/logger.ts                  → /opt/tools/logger.ts (resolved as Vite-style)
  *   /src/page.tsx, { absolute: true }     → /Users/justin/my-app/src/page.tsx
  */
-export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
+export function normalizeModulePath(modulePath, projectRootDir, options = {}, _path = path) {
     modulePath = normalizePathSeparators(modulePath);
-    projectRootDir = normalizePathSeparators(path.resolve(projectRootDir));
+    projectRootDir = normalizePathSeparators(_path.resolve(projectRootDir));
     // Handle empty string or current directory
     if (modulePath === "" || modulePath === ".") {
         return options.absolute ? projectRootDir : "/";
     }
     // For relative paths, resolve them first
     let resolved;
-    if (path.isAbsolute(modulePath)) {
+    if (_path.isAbsolute(modulePath)) {
         if (modulePath.startsWith(projectRootDir + "/") ||
             modulePath === projectRootDir) {
             // Path starts with project root - it's a real absolute path inside project
@@ -61,7 +66,7 @@ export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
             if (options.isViteStyle !== undefined) {
                 // User explicitly specified whether this should be treated as Vite-style
                 if (options.isViteStyle) {
-                    resolved = path.resolve(projectRootDir, modulePath.slice(1));
+                    resolved = _path.resolve(projectRootDir, modulePath.slice(1));
                 }
                 else {
                     resolved = modulePath;
@@ -70,19 +75,20 @@ export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
             else {
                 // Fall back to heuristics using common ancestor depth
                 const commonDepth = findCommonAncestorDepth(modulePath, projectRootDir);
-                if (commonDepth > 0) {
-                    // Paths share meaningful common ancestor - treat as real absolute path
+                if (commonDepth > 0 || windowsDriveAbsoluteRE.test(modulePath)) {
+                    // Paths share meaningful common ancestor, or this is a Windows absolute
+                    // path on a different drive — treat as a real external absolute path
                     resolved = modulePath;
                 }
                 else {
                     // No meaningful common ancestor - assume Vite-style path within project
-                    resolved = path.resolve(projectRootDir, modulePath.slice(1));
+                    resolved = _path.resolve(projectRootDir, modulePath.slice(1));
                 }
             }
         }
     }
     else {
-        resolved = path.resolve(projectRootDir, modulePath);
+        resolved = _path.resolve(projectRootDir, modulePath);
     }
     resolved = normalizePathSeparators(resolved);
     // If absolute option is set, always return absolute paths
@@ -90,9 +96,10 @@ export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
         return resolved;
     }
     // Check if the resolved path is within the project root
-    const relative = path.relative(projectRootDir, resolved);
-    // If the path goes outside the project root (starts with ..), return absolute
-    if (relative.startsWith("..")) {
+    const relative = _path.relative(projectRootDir, resolved);
+    // If the path goes outside the project root (starts with ..) or is on a
+    // different drive (Windows: path.relative returns an absolute path), return absolute
+    if (relative.startsWith("..") || _path.isAbsolute(relative)) {
         return resolved;
     }
     // Path is within project root, return as Vite-style relative path

package/dist/lib/normalizeModulePath.test.mjs

@@ -1,3 +1,4 @@
+import { win32 as windowsPath } from "node:path";
 import { describe, expect, it } from "vitest";
 import { findCommonAncestorDepth, normalizeModulePath, } from "./normalizeModulePath.mjs";
 describe("findCommonAncestorDepth", () => {
@@ -220,3 +221,21 @@ describe("normalizeModulePath", () => {
         });
     });
 });
+describe("Windows paths (path.win32)", () => {
+    const root = "C:/Projects/app";
+    it("Windows absolute path inside project", () => {
+        expect(normalizeModulePath("C:/Projects/app/src/page.tsx", root, {}, windowsPath)).toBe("/src/page.tsx");
+    });
+    it("Windows absolute path outside project (same drive)", () => {
+        expect(normalizeModulePath("C:/other/utils.ts", root, {}, windowsPath)).toBe("C:/other/utils.ts");
+    });
+    it("Cross-drive path is treated as external", () => {
+        expect(normalizeModulePath("D:/other/utils.ts", root, {}, windowsPath)).toBe("D:/other/utils.ts");
+    });
+    it("Relative path resolves correctly", () => {
+        expect(normalizeModulePath("src/page.tsx", root, {}, windowsPath)).toBe("/src/page.tsx");
+    });
+    it("Windows absolute path inside project with absolute option", () => {
+        expect(normalizeModulePath("C:/Projects/app/src/page.tsx", root, { absolute: true }, windowsPath)).toBe("C:/Projects/app/src/page.tsx");
+    });
+});

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/dist/vite/redwoodPlugin.mjs

@@ -1,5 +1,6 @@
 import { cloudflare } from "@cloudflare/vite-plugin";
-import { resolve } from "node:path/posix";
+import { resolve } from "node:path";
+import { normalizePath } from "vite";
 import { unstable_readConfig } from "wrangler";
 import { devServerConstantPlugin } from "./devServerConstant.mjs";
 import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
@@ -32,10 +33,10 @@ import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
 import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
 export const determineWorkerEntryPathname = async ({ projectRootDir, workerConfigPath, options, readConfig = unstable_readConfig, }) => {
     if (options.entry?.worker) {
-        return resolve(projectRootDir, options.entry.worker);
+        return normalizePath(resolve(projectRootDir, options.entry.worker));
     }
     const workerConfig = readConfig({ config: workerConfigPath });
-    return resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx");
+    return normalizePath(resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx"));
 };
 const clientFiles = new Set();
 const serverFiles = new Set();

package/package.json

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