rwsdk 1.0.0-beta.5 → 1.0.0-beta.50

package/bin/rw-scripts.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
+import { execa } from "execa";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { $ as $base } from "execa";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -12,19 +12,19 @@ const BIN_DIR = path.resolve(ROOT_DIR, "node_modules", ".bin");
 const ARGS = process.argv.slice(2);
 const SCRIPT_NAME = ARGS[0];
 
-const $ = $base({
-  shell: true,
-  stdio: "inherit",
-  reject: false,
-  env: {
-    PATH: `${process.env.PATH}:${BIN_DIR}`,
-  },
-});
-
 const main = async () => {
-  const result =
-    await $`node ${path.resolve(ROOT_DIR, "dist", "scripts", SCRIPT_NAME)}.mjs ${ARGS.slice(1).join(" ")}`;
-
+  const scriptPath =
+    path.resolve(ROOT_DIR, "dist", "scripts", SCRIPT_NAME) + ".mjs";
+  const args = ARGS.slice(1);
+
+  const result = await execa("node", [scriptPath, ...args], {
+    stdio: "inherit",
+    reject: false,
+    env: {
+      ...process.env,
+      PATH: `${process.env.PATH}:${BIN_DIR}`,
+    },
+  });
   process.exitCode = result.exitCode;
 };
 

package/dist/lib/constants.d.mts

@@ -7,5 +7,6 @@ export declare const VENDOR_CLIENT_BARREL_PATH: string;
 export declare const VENDOR_SERVER_BARREL_PATH: string;
 export declare const VENDOR_CLIENT_BARREL_EXPORT_PATH = "rwsdk/__vendor_client_barrel";
 export declare const VENDOR_SERVER_BARREL_EXPORT_PATH = "rwsdk/__vendor_server_barrel";
+export declare const RW_STATE_EXPORT_PATH = "rwsdk/__state";
 export declare const INTERMEDIATE_SSR_BRIDGE_PATH: string;
 export declare const CLIENT_MANIFEST_RELATIVE_PATH: string;

package/dist/lib/constants.mjs

@@ -1,13 +1,16 @@
-import path, { resolve } from "node:path";
-const __dirname = new URL(".", import.meta.url).pathname;
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 export const ROOT_DIR = resolve(__dirname, "..", "..");
 export const SRC_DIR = resolve(ROOT_DIR, "src");
 export const DIST_DIR = resolve(ROOT_DIR, "dist");
 export const VITE_DIR = resolve(ROOT_DIR, "src", "vite");
 export const INTERMEDIATES_OUTPUT_DIR = resolve(DIST_DIR, "__intermediate_builds");
-export const VENDOR_CLIENT_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-client-barrel.js");
-export const VENDOR_SERVER_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-server-barrel.js");
+export const VENDOR_CLIENT_BARREL_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-client-barrel.js");
+export const VENDOR_SERVER_BARREL_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-server-barrel.js");
 export const VENDOR_CLIENT_BARREL_EXPORT_PATH = "rwsdk/__vendor_client_barrel";
 export const VENDOR_SERVER_BARREL_EXPORT_PATH = "rwsdk/__vendor_server_barrel";
+export const RW_STATE_EXPORT_PATH = "rwsdk/__state";
 export const INTERMEDIATE_SSR_BRIDGE_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "ssr", "ssr_bridge.js");
 export const CLIENT_MANIFEST_RELATIVE_PATH = resolve("dist", "client", ".vite", "manifest.json");

package/dist/lib/e2e/browser.mjs

@@ -1,14 +1,18 @@
 import { computeExecutablePath, detectBrowserPlatform, install, Browser as PuppeteerBrowser, resolveBuildId, } from "@puppeteer/browsers";
 import debug from "debug";
 import { mkdirp, pathExists } from "fs-extra";
-import * as os from "os";
 import { join } from "path";
 import puppeteer from "puppeteer-core";
+import { ensureTmpDir } from "./utils.mjs";
 const log = debug("rwsdk:e2e:browser");
 /**
  * Launch a browser instance
  */
 export async function launchBrowser(browserPath, headless = true) {
+    // Define a consistent cache directory path in system temp folder
+    const rwCacheDir = join(await ensureTmpDir(), "redwoodjs-smoke-test-cache");
+    await mkdirp(rwCacheDir);
+    log("Using cache directory: %s", rwCacheDir);
     // Get browser path if not provided
     if (!browserPath) {
         log("Getting browser executable path");
@@ -41,7 +45,7 @@ export async function getBrowserPath(testOptions) {
     }
     log("Detected platform: %s", platform);
     // Define a consistent cache directory path in system temp folder
-    const rwCacheDir = join(os.tmpdir(), "redwoodjs-smoke-test-cache");
+    const rwCacheDir = join(await ensureTmpDir(), "redwoodjs-smoke-test-cache");
     await mkdirp(rwCacheDir);
     log("Using cache directory: %s", rwCacheDir);
     // Determine browser type based on headless option

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

@@ -1,3 +1,7 @@
+export declare const IS_CI: boolean;
+export declare const RWSDK_SKIP_DEV: boolean;
+export declare const RWSDK_SKIP_DEPLOY: boolean;
+export declare const IS_DEBUG_MODE: boolean;
 export declare const SETUP_PLAYGROUND_ENV_TIMEOUT: number;
 export declare const DEPLOYMENT_TIMEOUT: number;
 export declare const DEPLOYMENT_MIN_TRIES: number;

package/dist/lib/e2e/constants.mjs

@@ -1,40 +1,77 @@
+export const IS_CI = !!((process.env.CI && !process.env.NOT_CI) ||
+    process.env.GITHUB_ACTIONS ||
+    process.env.GITLAB_CI ||
+    process.env.CIRCLECI ||
+    process.env.TRAVIS ||
+    process.env.JENKINS_URL ||
+    process.env.NETLIFY);
+export const RWSDK_SKIP_DEV = Boolean(process.env.RWSDK_SKIP_DEV);
+export const RWSDK_SKIP_DEPLOY = process.env.RWSDK_SKIP_DEPLOY === "true" ||
+    process.env.RWSDK_SKIP_DEPLOY === "1";
+export const IS_DEBUG_MODE = process.env.RWSDK_E2E_DEBUG
+    ? process.env.RWSDK_E2E_DEBUG === "true"
+    : !IS_CI;
 export const SETUP_PLAYGROUND_ENV_TIMEOUT = process.env
     .RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT
     ? parseInt(process.env.RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT, 10)
-    : 15 * 60 * 1000;
+    : IS_DEBUG_MODE
+        ? 10 * 60 * 1000
+        : 15 * 60 * 1000;
 export const DEPLOYMENT_TIMEOUT = process.env.RWSDK_DEPLOYMENT_TIMEOUT
     ? parseInt(process.env.RWSDK_DEPLOYMENT_TIMEOUT, 10)
-    : 5 * 60 * 1000;
+    : IS_DEBUG_MODE
+        ? 5 * 30 * 1000
+        : 5 * 60 * 1000;
 export const DEPLOYMENT_MIN_TRIES = process.env.RWSDK_DEPLOYMENT_MIN_TRIES
     ? parseInt(process.env.RWSDK_DEPLOYMENT_MIN_TRIES, 10)
-    : 5;
+    : IS_DEBUG_MODE
+        ? 1
+        : 5;
 export const DEPLOYMENT_CHECK_TIMEOUT = process.env
     .RWSDK_DEPLOYMENT_CHECK_TIMEOUT
     ? parseInt(process.env.RWSDK_DEPLOYMENT_CHECK_TIMEOUT, 10)
-    : 5 * 60 * 1000;
+    : IS_DEBUG_MODE
+        ? 30 * 1000
+        : 5 * 60 * 1000;
 export const PUPPETEER_TIMEOUT = process.env.RWSDK_PUPPETEER_TIMEOUT
     ? parseInt(process.env.RWSDK_PUPPETEER_TIMEOUT, 10)
-    : 60 * 1000 * 2;
+    : IS_DEBUG_MODE
+        ? 30 * 1000
+        : 60 * 1000 * 2;
 export const HYDRATION_TIMEOUT = process.env.RWSDK_HYDRATION_TIMEOUT
     ? parseInt(process.env.RWSDK_HYDRATION_TIMEOUT, 10)
-    : 5000;
+    : IS_DEBUG_MODE
+        ? 2000
+        : 5000;
 export const DEV_SERVER_TIMEOUT = process.env.RWSDK_DEV_SERVER_TIMEOUT
     ? parseInt(process.env.RWSDK_DEV_SERVER_TIMEOUT, 10)
-    : 5 * 60 * 1000;
+    : IS_DEBUG_MODE
+        ? 60 * 1000
+        : 5 * 60 * 1000;
 export const DEV_SERVER_MIN_TRIES = process.env.RWSDK_DEV_SERVER_MIN_TRIES
     ? parseInt(process.env.RWSDK_DEV_SERVER_MIN_TRIES, 10)
-    : 5;
+    : IS_DEBUG_MODE
+        ? 1
+        : 5;
 export const SETUP_WAIT_TIMEOUT = process.env.RWSDK_SETUP_WAIT_TIMEOUT
     ? parseInt(process.env.RWSDK_SETUP_WAIT_TIMEOUT, 10)
-    : 10 * 60 * 1000;
+    : IS_DEBUG_MODE
+        ? 60 * 1000
+        : 10 * 60 * 1000;
 export const TEST_MAX_RETRIES = process.env.RWSDK_TEST_MAX_RETRIES
     ? parseInt(process.env.RWSDK_TEST_MAX_RETRIES, 10)
-    : 10;
+    : IS_DEBUG_MODE
+        ? 1
+        : 10;
 export const TEST_MAX_RETRIES_PER_CODE = process.env
     .RWSDK_TEST_MAX_RETRIES_PER_CODE
     ? parseInt(process.env.RWSDK_TEST_MAX_RETRIES_PER_CODE, 10)
-    : 6;
+    : IS_DEBUG_MODE
+        ? 0
+        : 6;
 export const INSTALL_DEPENDENCIES_RETRIES = process.env
     .RWSDK_INSTALL_DEPENDENCIES_RETRIES
     ? parseInt(process.env.RWSDK_INSTALL_DEPENDENCIES_RETRIES, 10)
-    : 10;
+    : IS_DEBUG_MODE
+        ? 1
+        : 10;

package/dist/lib/e2e/dev.mjs

@@ -1,7 +1,8 @@
 import debug from "debug";
 import { setTimeout as sleep } from "node:timers/promises";
-import { $ } from "../../lib/$.mjs";
+import { $, $sh } from "../../lib/$.mjs";
 import { poll } from "./poll.mjs";
+import { IS_DEBUG_MODE } from "./constants.mjs";
 const DEV_SERVER_CHECK_TIMEOUT = process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT
     ? parseInt(process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT, 10)
     : 5 * 60 * 1000;
@@ -21,43 +22,30 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
             return;
         }
         console.log("Stopping development server...");
-        try {
-            // Send a regular termination signal to the entire process group first
-            process.kill(-devProcess.pid, "SIGTERM");
-        }
-        catch (e) {
-            log("Could not send SIGTERM to dev server process group: %O", e);
-        }
-        // Wait for the process to terminate with a timeout
-        const terminationTimeout = 5000; // 5 seconds
-        const processExitPromise = devProcess.catch(() => {
-            // We expect this promise to reject when the process is killed,
-            // so we catch and ignore the error.
-        });
-        const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(undefined), terminationTimeout));
-        await Promise.race([processExitPromise, timeoutPromise]);
-        // Check if the process is still alive. We can't reliably check exitCode
-        // on a detached process, so we try sending a signal 0, which errors
-        // if the process doesn't exist.
-        let isAlive = true;
-        try {
-            // Sending signal 0 doesn't kill the process, but checks if it exists
-            process.kill(-devProcess.pid, 0);
-        }
-        catch (e) {
-            isAlive = false;
+        if (process.platform === "win32") {
+            try {
+                await $sh(`taskkill /pid ${devProcess.pid} /f /t`);
+            }
+            catch (err) {
+                log("Failed to kill process tree with taskkill:", err);
+            }
         }
-        // If not terminated within timeout, force kill the entire process group
-        if (isAlive) {
-            log("Dev server process did not terminate within timeout, force killing with SIGKILL");
-            console.log("⚠️ Development server not responding after 5 seconds timeout, force killing...");
+        else {
+            // On Unix-like systems, we kill the entire process group by sending a signal
+            // to the negative PID. This is the equivalent of the `/t` flag for `taskkill` on Windows.
+            // This relies on `detached: true` being set in the execa options, which makes
+            // the child process the leader of a new process group.
             try {
                 process.kill(-devProcess.pid, "SIGKILL");
             }
             catch (e) {
-                log("Could not send SIGKILL to dev server process group: %O", e);
+                log("Failed to kill process group. This may happen if the process already exited. %O", e);
             }
         }
+        await devProcess.catch(() => {
+            // We expect this promise to reject when the process is killed,
+            // so we catch and ignore the error.
+        });
         console.log("Development server stopped");
     };
     try {
@@ -86,20 +74,23 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         };
         const pm = getPackageManagerCommand(packageManager);
         // Use the provided cwd if available
-        devProcess = $({
+        devProcess = $(pm, ["run", "dev"], {
             all: true,
-            detached: true, // Run in a new process group so we can kill the entire group
-            cleanup: false, // Don't auto-kill on exit
+            // On Windows, detached: true prevents stdio from being captured.
+            // On Unix, it's required for reliable cleanup by killing the process group.
+            detached: process.platform !== "win32",
+            cleanup: true, // Let execa handle cleanup
+            forceKillAfterTimeout: 2000, // Force kill if graceful shutdown fails
             cwd: cwd || process.cwd(), // Use provided directory or current directory
             env, // Pass the updated environment variables
             stdio: "pipe", // Ensure streams are piped
-        }) `${pm} run dev`;
+        });
         devProcess.catch((error) => {
             if (!isErrorExpected) {
                 // Don't re-throw. The error will be handled gracefully by the polling
                 // logic in `waitForUrl`, which will detect that the process has exited.
                 // Re-throwing here would cause an unhandled promise rejection.
-                log("Dev server process exited unexpectedly:", error.shortMessage);
+                log("Dev server process exited unexpectedly: %O", error);
             }
         });
         log("Development server process spawned in directory: %s", cwd || process.cwd());
@@ -109,9 +100,11 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Listen for all output to get the URL
         const handleOutput = (data, source) => {
             const output = data.toString();
-            console.log(output);
+            // Raw output for debugging - only in debug mode
+            if (IS_DEBUG_MODE) {
+                process.stdout.write(`[dev:${source}] ` + output);
+            }
             allOutput += output; // Accumulate all output
-            log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
             if (!url) {
                 // Multiple patterns to catch different package manager outputs
                 const patterns = [
@@ -131,40 +124,40 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
                 ];
                 for (const pattern of patterns) {
                     const match = output.match(pattern);
-                    log("Testing pattern %s against output: %s", pattern.source, output.replace(/\n/g, "\\n"));
                     if (match) {
-                        log("Pattern matched: %s, groups: %o", pattern.source, match);
                         if (match[1] && match[1].startsWith("http")) {
                             url = match[1];
-                            log("Found development server URL with pattern %s: %s", pattern.source, url);
                             break;
                         }
                         else if (match[1] && /^\d+$/.test(match[1])) {
                             url = `http://localhost:${match[1]}`;
-                            log("Found development server URL with port pattern %s: %s", pattern.source, url);
                             break;
                         }
                     }
                 }
-                // Log potential matches for debugging
-                if (!url &&
-                    (output.includes("localhost") ||
-                        output.includes("Local") ||
-                        output.includes("server"))) {
-                    log("Potential URL pattern found but not matched: %s", output.trim());
-                }
             }
         };
         // Listen to all possible output streams
         log("Setting up stream listeners. Available streams: all=%s, stdout=%s, stderr=%s", !!devProcess.all, !!devProcess.stdout, !!devProcess.stderr);
-        devProcess.all?.on("data", (data) => handleOutput(data, "all"));
-        devProcess.stdout?.on("data", (data) => handleOutput(data, "stdout"));
-        devProcess.stderr?.on("data", (data) => handleOutput(data, "stderr"));
-        // Also try listening to the raw process output
+        if (devProcess.all) {
+            devProcess.all.on("data", (data) => handleOutput(data, "all"));
+        }
+        else {
+            devProcess.stdout?.on("data", (data) => handleOutput(data, "stdout"));
+            devProcess.stderr?.on("data", (data) => handleOutput(data, "stderr"));
+        }
+        // Also try listening to the raw process events
         if (devProcess.child) {
-            log("Setting up child process stream listeners");
-            devProcess.child.stdout?.on("data", (data) => handleOutput(data, "child.stdout"));
-            devProcess.child.stderr?.on("data", (data) => handleOutput(data, "child.stderr"));
+            log("Setting up child process events listeners");
+            devProcess.child.on("spawn", () => {
+                log("Child process spawned successfully.");
+            });
+            devProcess.child.on("error", (err) => {
+                log("Child process error: %O", err);
+            });
+            devProcess.child.on("exit", (code, signal) => {
+                log("Child process exited with code %s and signal %s", code, signal);
+            });
         }
         // Wait for URL with timeout
         const waitForUrl = async () => {
@@ -176,7 +169,6 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
                 }
                 // Fallback: check accumulated output if stream listeners aren't working
                 if (!url && allOutput) {
-                    log("Checking accumulated output for URL patterns: %s", allOutput.replace(/\n/g, "\\n"));
                     const patterns = [
                         /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
                         /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,

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

@@ -1,5 +1,7 @@
 import tmp from "tmp-promise";
 import { PackageManager } from "./types.mjs";
+export declare function getFilesRecursively(directory: string): Promise<string[]>;
+export declare function getDirectoryHash(directory: string): Promise<string>;
 /**
  * Copy project to a temporary directory with a unique name
  */