rwsdk 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/lib/e2e/testHarness.mjs

@@ -1,8 +1,10 @@
 import { test, beforeAll, afterAll, afterEach, } from "vitest";
+import { basename } from "path";
 import { setupTarballEnvironment } from "./tarball.mjs";
 import { runDevServer } from "./dev.mjs";
 import { runRelease, deleteWorker, deleteD1Database, isRelatedToTest, } from "./release.mjs";
 import { launchBrowser } from "./browser.mjs";
+const SETUP_PLAYGROUND_ENV_TIMEOUT = 10 * 60 * 1000;
 // Environment variable flags for skipping tests
 const SKIP_DEV_SERVER_TESTS = process.env.RWSDK_SKIP_DEV === "1";
 const SKIP_DEPLOYMENT_TESTS = process.env.RWSDK_SKIP_DEPLOY === "1";
@@ -107,13 +109,13 @@ export function setupPlaygroundEnvironment(sourceProjectDir) {
         console.log(`Setting up playground environment from ${projectDir}...`);
         const tarballEnv = await setupTarballEnvironment({
             projectDir,
-            packageManager: "pnpm",
+            packageManager: process.env.PACKAGE_MANAGER || "pnpm",
         });
         globalPlaygroundEnv = {
             projectDir: tarballEnv.targetDir,
             cleanup: tarballEnv.cleanup,
         };
-    });
+    }, SETUP_PLAYGROUND_ENV_TIMEOUT);
 }
 /**
  * Gets the current playground environment.
@@ -134,7 +136,8 @@ export async function createDevServer() {
         throw new Error("Dev server tests are skipped via RWSDK_SKIP_DEV=1");
     }
     const env = getPlaygroundEnvironment();
-    const devResult = await runDevServer("pnpm", env.projectDir);
+    const packageManager = process.env.PACKAGE_MANAGER || "pnpm";
+    const devResult = await runDevServer(packageManager, env.projectDir);
     const serverId = `devServer-${Date.now()}-${Math.random()
         .toString(36)
         .substring(2, 9)}`;
@@ -161,8 +164,26 @@ export async function createDeployment() {
         throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
     }
     const env = getPlaygroundEnvironment();
-    const resourceUniqueKey = Math.random().toString(36).substring(2, 15);
+    // Extract the unique key from the project directory name instead of generating a new one
+    // The directory name format is: {projectName}-e2e-test-{randomId}
+    const dirName = basename(env.projectDir);
+    const match = dirName.match(/-e2e-test-([a-f0-9]+)$/);
+    const resourceUniqueKey = match
+        ? match[1]
+        : Math.random().toString(36).substring(2, 15);
     const deployResult = await runRelease(env.projectDir, env.projectDir, resourceUniqueKey);
+    // Poll the URL to ensure it's live before proceeding
+    await poll(async () => {
+        try {
+            const response = await fetch(deployResult.url);
+            // We consider any response (even 4xx or 5xx) as success,
+            // as it means the worker is routable.
+            return response.status > 0;
+        }
+        catch (e) {
+            return false;
+        }
+    }, 60000);
     const deploymentId = `deployment-${Date.now()}-${Math.random()
         .toString(36)
         .substring(2, 9)}`;
@@ -189,6 +210,7 @@ export async function createDeployment() {
         url: deployResult.url,
         workerName: deployResult.workerName,
         resourceUniqueKey,
+        projectDir: env.projectDir,
     };
 }
 /**
@@ -238,26 +260,91 @@ export async function createBrowser() {
     };
     return browser;
 }
+/**
+ * Executes a test function with a retry mechanism for specific error codes.
+ * @param name - The name of the test, used for logging.
+ * @param attemptFn - A function that executes one attempt of the test.
+ *                     It should set up resources, run the test logic, and
+ *                     return a cleanup function. The cleanup function will be
+ *                     called automatically on failure.
+ */
+export async function runTestWithRetries(name, attemptFn) {
+    const MAX_RETRIES_PER_CODE = 6;
+    const retryCounts = {};
+    let attempt = 0;
+    while (true) {
+        attempt++;
+        let cleanup;
+        try {
+            const res = await attemptFn();
+            cleanup = res.cleanup;
+            if (attempt > 1) {
+                console.log(`[runTestWithRetries] Test "${name}" succeeded on attempt ${attempt}.`);
+            }
+            // On success, we don't run cleanup here. It will be handled by afterEach.
+            return; // Success
+        }
+        catch (e) {
+            // On failure, run the cleanup from the failed attempt.
+            // The cleanup function is attached to the error object on failure.
+            const errorCleanup = e.cleanup;
+            if (typeof errorCleanup === "function") {
+                await errorCleanup().catch((err) => console.warn(`[runTestWithRetries] Cleanup failed for "${name}" during retry:`, err));
+            }
+            const errorCode = e?.code;
+            if (typeof errorCode === "string" && errorCode) {
+                const count = (retryCounts[errorCode] || 0) + 1;
+                retryCounts[errorCode] = count;
+                if (count <= MAX_RETRIES_PER_CODE) {
+                    console.log(`[runTestWithRetries] Attempt ${attempt} for "${name}" failed with code ${errorCode}. Retrying (failure ${count}/${MAX_RETRIES_PER_CODE} for this code)...`);
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    continue; // Next attempt
+                }
+                else {
+                    console.error(`[runTestWithRetries] Test "${name}" failed with code ${errorCode} after ${MAX_RETRIES_PER_CODE} retries for this code.`);
+                    throw e; // Give up
+                }
+            }
+            else {
+                console.error(`[runTestWithRetries] Test "${name}" failed on attempt ${attempt} with a non-retryable error:`, e);
+                throw e;
+            }
+        }
+    }
+}
 /**
  * High-level test wrapper for dev server tests.
  * Automatically skips if RWSDK_SKIP_DEV=1
  */
 export function testDev(name, testFn) {
     if (SKIP_DEV_SERVER_TESTS) {
-        test.skip(name, () => { });
+        test.skip(name, testFn);
         return;
     }
     test(name, async () => {
-        const devServer = await createDevServer();
-        const browser = await createBrowser();
-        const page = await browser.newPage();
-        await testFn({
-            devServer,
-            browser,
-            page,
-            url: devServer.url,
+        await runTestWithRetries(name, async () => {
+            const devServer = await createDevServer();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            const cleanup = async () => {
+                await browser.close();
+                await devServer.stopDev();
+            };
+            try {
+                await testFn({
+                    devServer,
+                    browser,
+                    page,
+                    url: devServer.url,
+                });
+                return { cleanup };
+            }
+            catch (error) {
+                // Ensure cleanup is available to the retry wrapper even if testFn fails.
+                // We re-throw the error to be handled by runTestWithRetries.
+                throw Object.assign(error, { cleanup });
+            }
         });
-        // Automatic cleanup handled by afterEach hooks
     });
 }
 /**
@@ -266,26 +353,70 @@ export function testDev(name, testFn) {
 testDev.skip = (name, testFn) => {
     test.skip(name, testFn || (() => { }));
 };
+testDev.only = (name, testFn) => {
+    if (SKIP_DEV_SERVER_TESTS) {
+        test.skip(name, () => { });
+        return;
+    }
+    test.only(name, async () => {
+        await runTestWithRetries(name, async () => {
+            const devServer = await createDevServer();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            const cleanup = async () => {
+                await browser.close();
+                await devServer.stopDev();
+            };
+            try {
+                await testFn({
+                    devServer,
+                    browser,
+                    page,
+                    url: devServer.url,
+                });
+                return { cleanup };
+            }
+            catch (error) {
+                // Ensure cleanup is available to the retry wrapper even if testFn fails.
+                // We re-throw the error to be handled by runTestWithRetries.
+                throw Object.assign(error, { cleanup });
+            }
+        });
+    });
+};
 /**
  * High-level test wrapper for deployment tests.
  * Automatically skips if RWSDK_SKIP_DEPLOY=1
  */
 export function testDeploy(name, testFn) {
     if (SKIP_DEPLOYMENT_TESTS) {
-        test.skip(name, () => { });
+        test.skip(name, testFn);
         return;
     }
     test(name, async () => {
-        const deployment = await createDeployment();
-        const browser = await createBrowser();
-        const page = await browser.newPage();
-        await testFn({
-            deployment,
-            browser,
-            page,
-            url: deployment.url,
+        await runTestWithRetries(name, async () => {
+            const deployment = await createDeployment();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            const cleanup = async () => {
+                // We don't await this because we want to let it run in the background
+                // The afterEach hook for deployments already does this.
+                await cleanupDeployment(deployment);
+                await browser.close();
+            };
+            try {
+                await testFn({
+                    deployment,
+                    browser,
+                    page,
+                    url: deployment.url,
+                });
+                return { cleanup };
+            }
+            catch (error) {
+                throw Object.assign(error, { cleanup });
+            }
         });
-        // Automatic cleanup handled by afterEach hooks
     });
 }
 /**
@@ -294,88 +425,60 @@ export function testDeploy(name, testFn) {
 testDeploy.skip = (name, testFn) => {
     test.skip(name, testFn || (() => { }));
 };
-/**
- * Unified test function that runs the same test against both dev server and deployment.
- * Automatically skips based on environment variables.
- */
-export function testDevAndDeploy(name, testFn) {
-    if (SKIP_DEV_SERVER_TESTS) {
-        test.skip(`${name} (dev)`, () => { });
-    }
-    else {
-        test(`${name} (dev)`, async () => {
-            const devServer = await createDevServer();
-            const browser = await createBrowser();
-            const page = await browser.newPage();
-            await testFn({
-                devServer,
-                browser,
-                page,
-                url: devServer.url,
-            });
-            // Automatic cleanup handled by afterEach hooks
-        });
-    }
+testDeploy.only = (name, testFn) => {
     if (SKIP_DEPLOYMENT_TESTS) {
-        test.skip(`${name} (deployment)`, () => { });
+        test.skip(name, () => { });
+        return;
     }
-    else {
-        test(`${name} (deployment)`, async () => {
+    test.only(name, async () => {
+        await runTestWithRetries(name, async () => {
             const deployment = await createDeployment();
             const browser = await createBrowser();
             const page = await browser.newPage();
-            await testFn({
-                deployment,
-                browser,
-                page,
-                url: deployment.url,
-            });
-            // Automatic cleanup handled by afterEach hooks
+            const cleanup = async () => {
+                // We don't await this because we want to let it run in the background
+                // The afterEach hook for deployments already does this.
+                await cleanupDeployment(deployment);
+                await browser.close();
+            };
+            try {
+                await testFn({
+                    deployment,
+                    browser,
+                    page,
+                    url: deployment.url,
+                });
+                return { cleanup };
+            }
+            catch (error) {
+                throw Object.assign(error, { cleanup });
+            }
         });
-    }
+    });
+};
+/**
+ * Unified test function that runs the same test against both dev server and deployment.
+ * Automatically skips based on environment variables.
+ */
+export function testDevAndDeploy(name, testFn) {
+    testDev(`${name} (dev)`, testFn);
+    testDeploy(`${name} (deployment)`, testFn);
 }
 /**
  * Skip version of testDevAndDeploy
  */
 testDevAndDeploy.skip = (name, testFn) => {
-    test.skip(`${name} (dev)`, testFn || (() => { }));
-    test.skip(`${name} (deployment)`, testFn || (() => { }));
+    test.skip(name, testFn || (() => { }));
 };
-/**
- * Only version of testDevAndDeploy
- */
 testDevAndDeploy.only = (name, testFn) => {
-    if (!SKIP_DEV_SERVER_TESTS) {
-        test.only(`${name} (dev)`, async () => {
-            const devServer = await createDevServer();
-            const browser = await createBrowser();
-            const page = await browser.newPage();
-            await testFn({
-                devServer,
-                browser,
-                page,
-                url: devServer.url,
-            });
-        });
-    }
-    if (!SKIP_DEPLOYMENT_TESTS) {
-        test.only(`${name} (deployment)`, async () => {
-            const deployment = await createDeployment();
-            const browser = await createBrowser();
-            const page = await browser.newPage();
-            await testFn({
-                deployment,
-                browser,
-                page,
-                url: deployment.url,
-            });
-        });
-    }
+    testDev.only(`${name} (dev)`, testFn);
+    testDeploy.only(`${name} (deployment)`, testFn);
 };
 /**
  * Utility function for polling/retrying assertions
  */
-export async function poll(fn, timeout = 5000, interval = 100) {
+export async function poll(fn, timeout = 2 * 60 * 1000, // 2 minutes
+interval = 100) {
     const startTime = Date.now();
     while (Date.now() - startTime < timeout) {
         try {

package/dist/lib/e2e/types.d.mts

@@ -16,6 +16,7 @@ export interface SmokeTestOptions {
     realtime?: boolean;
     skipHmr?: boolean;
     skipStyleTests?: boolean;
+    tarballPath?: string;
 }
 /**
  * Resources created during a test run that need to be cleaned up

package/dist/runtime/lib/router.js

@@ -180,8 +180,14 @@ export function index(handler) {
 export function prefix(prefixPath, routes) {
     return routes.map((r) => {
         if (typeof r === "function") {
-            // Pass through middleware as-is
-            return r;
+            const middleware = (requestInfo) => {
+                const url = new URL(requestInfo.request.url);
+                if (url.pathname.startsWith(prefixPath)) {
+                    return r(requestInfo);
+                }
+                return;
+            };
+            return middleware;
         }
         if (Array.isArray(r)) {
             // Recursively process nested route arrays

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import React from "react";
-import { matchPath, defineRoutes, route, render, layout } from "./router";
+import { matchPath, defineRoutes, route, render, layout, prefix, } from "./router";
 describe("matchPath", () => {
     // Test case 1: Static paths
     it("should match static paths", () => {
@@ -209,6 +209,90 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(await response.text()).toBe("Rendered: Element");
         });
     });
+    describe("Prefix Handling", () => {
+        it("should only run middleware within the specified prefix", async () => {
+            const executionOrder = [];
+            const prefixedMiddleware = () => {
+                executionOrder.push("prefixedMiddleware");
+            };
+            const PageComponent = () => {
+                executionOrder.push("PageComponent");
+                return React.createElement("div", {}, "Page");
+            };
+            const AdminPageComponent = () => {
+                executionOrder.push("AdminPageComponent");
+                return React.createElement("div", {}, "Admin Page");
+            };
+            const router = defineRoutes([
+                ...prefix("/admin", [
+                    prefixedMiddleware,
+                    route("/", AdminPageComponent),
+                ]),
+                route("/", PageComponent),
+            ]);
+            const deps = createMockDependencies();
+            // Test 1: Request to a path outside the prefix
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/");
+            const request1 = new Request("http://localhost:3000/");
+            await router.handle({
+                request: request1,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["PageComponent"]);
+            // Reset execution order
+            executionOrder.length = 0;
+            // Test 2: Request to a path inside the prefix
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/admin/");
+            const request2 = new Request("http://localhost:3000/admin/");
+            await router.handle({
+                request: request2,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual([
+                "prefixedMiddleware",
+                "AdminPageComponent",
+            ]);
+        });
+        it("should short-circuit from a prefixed middleware", async () => {
+            const executionOrder = [];
+            const prefixedMiddleware = () => {
+                executionOrder.push("prefixedMiddleware");
+                return new Response("From prefixed middleware");
+            };
+            const AdminPageComponent = () => {
+                executionOrder.push("AdminPageComponent");
+                return React.createElement("div", {}, "Admin Page");
+            };
+            const router = defineRoutes([
+                ...prefix("/admin", [
+                    prefixedMiddleware,
+                    route("/", AdminPageComponent),
+                ]),
+            ]);
+            const deps = createMockDependencies();
+            // Request to a path inside the prefix
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/admin/");
+            const request = new Request("http://localhost:3000/admin/");
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["prefixedMiddleware"]);
+            expect(await response.text()).toBe("From prefixed middleware");
+        });
+    });
     describe("RSC Action Handling", () => {
         it("should handle RSC actions before the first route definition", async () => {
             const executionOrder = [];

package/dist/vite/buildApp.d.mts

@@ -6,10 +6,11 @@ import type { ViteBuilder } from "vite";
  *
  * @see docs/architecture/productionBuildProcess.md
  */
-export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }: {
+export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }: {
     builder: ViteBuilder;
     clientEntryPoints: Set<string>;
     clientFiles: Set<string>;
     serverFiles: Set<string>;
     projectRootDir: string;
+    workerEntryPathname: string;
 }): Promise<void>;

package/dist/vite/buildApp.mjs

@@ -9,13 +9,14 @@ const log = debug("rwsdk:vite:build-app");
  *
  * @see docs/architecture/productionBuildProcess.md
  */
-export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }) {
+export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) {
     const workerEnv = builder.environments.worker;
     await runDirectivesScan({
         rootConfig: builder.config,
         environments: builder.environments,
         clientFiles,
         serverFiles,
+        entries: [workerEntryPathname],
     });
     console.log("Building worker to discover used client components...");
     process.env.RWSDK_BUILD_PASS = "worker";
@@ -42,11 +43,14 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     // Re-configure the worker environment for the linking pass
     const workerConfig = workerEnv.config;
     workerConfig.build.emptyOutDir = false;
+    // context(justinvdm, 22 Sep 2025): This is a workaround to satisfy the
+    // Cloudflare plugin's expectation of an entry chunk named `index`. The plugin
+    // now manages the worker build, so we no longer set rollup options
+    // directly. Instead, we re-point the original entry to the intermediate
+    // worker bundle from the first pass. This allows the linker pass to re-use
+    // the same plugin-driven configuration while bundling the final worker.
     workerConfig.build.rollupOptions.input = {
-        worker: resolve(projectRootDir, "dist", "worker", "worker.js"),
-    };
-    workerConfig.build.rollupOptions.output = {
-        entryFileNames: "worker.js",
+        index: resolve(projectRootDir, "dist", "worker", "index.js"),
     };
     await builder.build(workerEnv);
     console.log("Build complete!");

package/dist/vite/configPlugin.mjs

@@ -1,13 +1,11 @@
 import path, { resolve } from "node:path";
 import enhancedResolve from "enhanced-resolve";
-import debug from "debug";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { buildApp } from "./buildApp.mjs";
 import { externalModules } from "./constants.mjs";
-const log = debug("rwsdk:vite:config");
 export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clientFiles, serverFiles, clientEntryPoints, }) => ({
     name: "rwsdk:config",
-    config: async (_) => {
+    config: async (_, { command }) => {
         const mode = process.env.NODE_ENV;
         const workerConfig = {
             resolve: {
@@ -49,14 +47,6 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                 emitAssets: true,
                 emptyOutDir: false,
                 ssr: true,
-                rollupOptions: {
-                    output: {
-                        inlineDynamicImports: true,
-                    },
-                    input: {
-                        worker: workerEntryPathname,
-                    },
-                },
             },
         };
         const baseConfig = {
@@ -176,6 +166,7 @@ export const configPlugin = ({ silent, projectRootDir, workerEntryPathname, clie
                         clientEntryPoints,
                         clientFiles,
                         serverFiles,
+                        workerEntryPathname,
                     });
                 },
             },

package/dist/vite/directiveModulesDevPlugin.d.mts

@@ -1,8 +1,9 @@
 import { Plugin } from "vite";
 export declare const generateVendorBarrelContent: (files: Set<string>, projectRootDir: string) => string;
 export declare const generateAppBarrelContent: (files: Set<string>, projectRootDir: string) => string;
-export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, }: {
+export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }: {
     clientFiles: Set<string>;
     serverFiles: Set<string>;
     projectRootDir: string;
+    workerEntryPathname: string;
 }) => Plugin;

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -30,7 +30,7 @@ export const generateAppBarrelContent = (files, projectRootDir) => {
     })
         .join("\n");
 };
-export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) => {
     const { promise: scanPromise, resolve: resolveScanPromise } = Promise.withResolvers();
     const tempDir = mkdtempSync(path.join(os.tmpdir(), "rwsdk-"));
     const APP_CLIENT_BARREL_PATH = path.join(tempDir, "app-client-barrel.js");
@@ -47,6 +47,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 environments: server.environments,
                 clientFiles,
                 serverFiles,
+                entries: [workerEntryPathname],
             }).then(() => {
                 // context(justinvdm, 11 Sep 2025): For vendor barrels, we write the
                 // files directly to disk after the scan. For app barrels, we use a

package/dist/vite/hasDirective.d.mts

@@ -1,7 +1,10 @@
 /**
  * Efficiently checks if a React directive (e.g., "use server", "use client")
- * is present in the code. Optimized for performance with a two-step approach:
- * 1. Quick string search to see if directive exists anywhere
- * 2. Line-by-line check only if the directive might be present
+ * is present in the code.
+ *
+ * This function is optimized for performance by only checking the first few
+ * lines of the code, as directives must appear at the very top of a file.
+ * It handles comments, whitespace, and any valid directive prologue
+ * (e.g., "use strict").
  */
 export declare function hasDirective(code: string, directive: string): boolean;