rwsdk 1.0.0-alpha.8 → 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/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;

package/dist/vite/hasDirective.mjs

@@ -1,54 +1,70 @@
 /**
  * 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 function hasDirective(code, directive) {
-    // Quick performance check: if directive doesn't exist anywhere, skip line checking
-    const singleQuoteDirective = `'${directive}'`;
-    const doubleQuoteDirective = `"${directive}"`;
-    if (!code.includes(singleQuoteDirective) &&
-        !code.includes(doubleQuoteDirective)) {
-        return false;
-    }
-    // Split into lines and check each one
-    const lines = code.split("\n");
+    const lines = code.slice(0, 512).split("\n"); // Check first ~512 chars
     let inMultiLineComment = false;
+    let foundUseClient = false;
+    let foundTargetDirective = false;
+    const doubleQuoteDirective = `"${directive}"`;
+    const singleQuoteDirective = `'${directive}'`;
+    const doubleQuoteUseClient = `"use client"`;
+    const singleQuoteUseClient = `'use client'`;
     for (const line of lines) {
         const trimmedLine = line.trim();
-        // Skip empty lines
         if (trimmedLine.length === 0) {
             continue;
         }
-        // Handle multi-line comments
-        if (trimmedLine.startsWith("/*")) {
-            inMultiLineComment = true;
-            // Check if the comment ends on the same line
+        if (inMultiLineComment) {
             if (trimmedLine.includes("*/")) {
                 inMultiLineComment = false;
             }
             continue;
         }
-        if (inMultiLineComment) {
-            // Check if this line ends the multi-line comment
-            if (trimmedLine.includes("*/")) {
-                inMultiLineComment = false;
+        if (trimmedLine.startsWith("/*")) {
+            if (!trimmedLine.includes("*/")) {
+                inMultiLineComment = true;
             }
             continue;
         }
-        // Skip single-line comments
         if (trimmedLine.startsWith("//")) {
             continue;
         }
-        // Check if this line starts with the directive
+        const cleanedLine = trimmedLine.endsWith(";")
+            ? trimmedLine.slice(0, -1)
+            : trimmedLine;
+        if (trimmedLine.startsWith(doubleQuoteUseClient) ||
+            trimmedLine.startsWith(singleQuoteUseClient)) {
+            foundUseClient = true;
+            if (directive === "use client") {
+                return true;
+            }
+        }
         if (trimmedLine.startsWith(doubleQuoteDirective) ||
             trimmedLine.startsWith(singleQuoteDirective)) {
-            return true;
+            foundTargetDirective = true;
+            if (directive !== "use server") {
+                return true;
+            }
         }
-        // If we hit a non-empty, non-comment line that's not a directive, we can stop
-        // (directives must be at the top of the file/scope, after comments)
+        // Any other string literal is part of a valid directive prologue.
+        // We can continue searching.
+        if (trimmedLine.startsWith('"') || trimmedLine.startsWith("'")) {
+            continue;
+        }
+        // If we encounter any other non-directive, non-comment, non-string-literal
+        // line of code, the directive prologue is over. Stop.
         break;
     }
-    return false;
+    // If looking for 'use server' and 'use client' was found, return false (client takes priority)
+    if (directive === "use server" && foundUseClient) {
+        return false;
+    }
+    return foundTargetDirective;
 }