rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20-test.20250929144616

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

@@ -0,0 +1,32 @@
+export type PackageManager = "pnpm" | "npm" | "yarn" | "yarn-classic";
+/**
+ * Options for smoke tests
+ */
+export interface SmokeTestOptions {
+    projectDir?: string;
+    artifactDir?: string;
+    headless?: boolean;
+    keep?: boolean;
+    sync?: boolean;
+    bail?: boolean;
+    skipDev?: boolean;
+    skipRelease?: boolean;
+    skipClient?: boolean;
+    packageManager?: PackageManager;
+    realtime?: boolean;
+    skipHmr?: boolean;
+    skipStyleTests?: boolean;
+    tarballPath?: string;
+}
+/**
+ * Resources created during a test run that need to be cleaned up
+ */
+export interface TestResources {
+    tempDirCleanup?: () => Promise<void>;
+    workerName?: string;
+    targetDir?: string;
+    originalCwd: string;
+    workerCreatedDuringTest: boolean;
+    stopDev?: () => Promise<void>;
+    resourceUniqueKey: string;
+}

package/dist/lib/getShortName.mjs

@@ -1,2 +1,6 @@
-import { relative } from "node:path";
-export const getShortName = (file, root) => file.startsWith(root) ? relative(root, file) : file;
+import path, { relative } from "node:path";
+export const getShortName = (file, root) => file === root
+    ? ""
+    : file.startsWith(root + path.sep)
+        ? relative(root, file)
+        : file;

package/dist/lib/getShortName.test.d.mts

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

package/dist/lib/getShortName.test.mjs

@@ -0,0 +1,25 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { getShortName } from "./getShortName.mjs";
+describe("getShortName", () => {
+    it("should return the relative path if the file is inside the root", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join(root, "src", "index.ts");
+        expect(getShortName(file, root)).toBe(path.join("src", "index.ts"));
+    });
+    it("should return the original path if the file is outside the root", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join("/Users", "test", "another", "project", "src", "index.ts");
+        expect(getShortName(file, root)).toBe(file);
+    });
+    it("should return an empty string if the paths are identical", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join("/Users", "test", "project");
+        expect(getShortName(file, root)).toBe("");
+    });
+    it("should handle paths that are substrings of each other correctly", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join("/Users", "test", "project-longer", "src", "index.ts");
+        expect(getShortName(file, root)).toBe(file);
+    });
+});

package/dist/lib/getSrcPaths.js

@@ -1,6 +1,6 @@
-import ts from "typescript";
-import path from "path";
 import { glob } from "glob";
+import path from "path";
+import ts from "typescript";
 /**
  * Gets all source file paths by parsing tsconfig.json using TypeScript's compiler API.
  * Falls back to a glob pattern if tsconfig parsing fails.

package/dist/lib/hasPkgScript.d.mts

@@ -1 +1,4 @@
-export declare const hasPkgScript: (projectRootDir: string, script: string) => Promise<any>;
+import { readFile as fsReadFile } from "fs/promises";
+export declare let _pkgCache: Record<string, any> | undefined;
+export declare const hasPkgScript: (projectRootDir: string, script: string, readFile?: typeof fsReadFile) => Promise<any>;
+export declare const _resetPkgCache: () => void;

package/dist/lib/hasPkgScript.mjs

@@ -1,9 +1,12 @@
-import { readFile } from "fs/promises";
+import { readFile as fsReadFile } from "fs/promises";
 import { resolve } from "path";
-let pkg;
-export const hasPkgScript = async (projectRootDir, script) => {
-    if (!pkg) {
-        pkg = JSON.parse(await readFile(resolve(projectRootDir, "package.json"), "utf-8"));
+export let _pkgCache;
+export const hasPkgScript = async (projectRootDir, script, readFile = fsReadFile) => {
+    if (!_pkgCache) {
+        _pkgCache = JSON.parse((await readFile(resolve(projectRootDir, "package.json"))).toString());
     }
-    return pkg.scripts?.[script];
+    return _pkgCache?.scripts?.[script];
+};
+export const _resetPkgCache = () => {
+    _pkgCache = undefined;
 };

package/dist/lib/hasPkgScript.test.d.mts

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

package/dist/lib/hasPkgScript.test.mjs

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { _resetPkgCache, hasPkgScript } from "./hasPkgScript.mjs";
+// Manually reset the cache before each test
+beforeEach(() => {
+    _resetPkgCache();
+});
+describe("hasPkgScript", () => {
+    it("should return the script if it exists", async () => {
+        const fakeReadFile = async () => JSON.stringify({ scripts: { "dev:init": "command" } });
+        const result = await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(result).toBe("command");
+    });
+    it("should return undefined if the script does not exist", async () => {
+        const fakeReadFile = async () => JSON.stringify({ scripts: { test: "command" } });
+        const result = await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(result).toBeUndefined();
+    });
+    it("should return undefined if scripts block does not exist", async () => {
+        const fakeReadFile = async () => JSON.stringify({});
+        const result = await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(result).toBeUndefined();
+    });
+    it("should cache the package.json read", async () => {
+        let readCount = 0;
+        const fakeReadFile = async () => {
+            readCount++;
+            return JSON.stringify({ scripts: { "dev:init": "command" } });
+        };
+        await hasPkgScript("/test", "dev:init", fakeReadFile);
+        await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(readCount).toBe(1);
+    });
+});

package/dist/lib/jsonUtils.mjs

@@ -158,6 +158,9 @@ export function parseJson(input, defaultValue, findUuid = false) {
                 }
             }
         }
+        if (lastJson !== null) {
+            return lastJson;
+        }
         return defaultValue;
     }
     catch (error) {

package/dist/lib/jsonUtils.test.d.mts

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

package/dist/lib/jsonUtils.test.mjs

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { extractAllJson, extractLastJson, parseJson } from "./jsonUtils.mjs";
+describe("jsonUtils", () => {
+    describe("extractLastJson", () => {
+        it("should extract the last JSON object from a string", () => {
+            const output = 'some text {"a":1} some other text {"b":2, "c": {"d": 3}} end';
+            expect(extractLastJson(output)).toEqual({ b: 2, c: { d: 3 } });
+        });
+        it("should extract the last JSON array from a string", () => {
+            const output = "start [1, 2] middle [3, 4, [5]] end";
+            expect(extractLastJson(output)).toEqual([3, 4, [5]]);
+        });
+        it("should return the object if the string is just JSON", () => {
+            const output = '{"a":1}';
+            expect(extractLastJson(output)).toEqual({ a: 1 });
+        });
+        it("should handle nested structures correctly", () => {
+            const output = '{"a":{"b":{"c":"d"}}}';
+            expect(extractLastJson(output)).toEqual({ a: { b: { c: "d" } } });
+        });
+        it("should return null if no valid JSON is found", () => {
+            const output = "this is just some text without json";
+            expect(extractLastJson(output)).toBeNull();
+        });
+        it("should return null for malformed JSON", () => {
+            const output = '{"a":1, "b":}';
+            expect(extractLastJson(output)).toBeNull();
+        });
+        it("should handle undefined and empty string input", () => {
+            expect(extractLastJson(undefined)).toBeNull();
+            expect(extractLastJson("")).toBeNull();
+        });
+    });
+    describe("extractAllJson", () => {
+        it("should extract all JSON objects from a string", () => {
+            const output = '{"a":1} some text {"b":2} and then {"c":3, "d": [4]}';
+            expect(extractAllJson(output)).toEqual([
+                { a: 1 },
+                { b: 2 },
+                { c: 3, d: [4] },
+            ]);
+        });
+        it("should extract all JSON arrays from a string", () => {
+            const output = "[1,2] then [3,4]";
+            expect(extractAllJson(output)).toEqual([
+                [1, 2],
+                [3, 4],
+            ]);
+        });
+        it("should handle a mix of objects and arrays", () => {
+            const output = '{"a":1} [2,3] {"b":4}';
+            expect(extractAllJson(output)).toEqual([{ a: 1 }, [2, 3], { b: 4 }]);
+        });
+        it("should return an empty array if no JSON is found", () => {
+            const output = "no json here";
+            expect(extractAllJson(output)).toEqual([]);
+        });
+        it("should ignore malformed JSON", () => {
+            const output = '{"a":1} {"b":2,} [3,4]';
+            expect(extractAllJson(output)).toEqual([{ a: 1 }, [3, 4]]);
+        });
+    });
+    describe("parseJson", () => {
+        it("should parse the last JSON object by default", () => {
+            const output = '{"a":1} {"b":2}';
+            expect(parseJson(output, {})).toEqual({ b: 2 });
+        });
+        it("should return the default value if no JSON is found", () => {
+            const output = "no json";
+            expect(parseJson(output, { default: true })).toEqual({ default: true });
+        });
+        it("should find an object with a uuid property when requested", () => {
+            const output = '{"a":1} {"uuid":"123-abc", "data": "yes"} {"c":3}';
+            expect(parseJson(output, {}, true)).toEqual({
+                uuid: "123-abc",
+                data: "yes",
+            });
+        });
+        it("should return the last object if findUuid is true but no object with uuid is found", () => {
+            const output = '{"a":1} {"b":2}';
+            expect(parseJson(output, {}, true)).toEqual({ b: 2 });
+        });
+        it("should return the default value if findUuid is true and no JSON is found", () => {
+            const output = "no json";
+            expect(parseJson(output, { default: true }, true)).toEqual({
+                default: true,
+            });
+        });
+    });
+});

package/dist/lib/normalizeModulePath.d.mts

@@ -1,3 +1,8 @@
+/**
+ * Find the number of common ancestor segments between two absolute paths.
+ * Returns the count of shared directory segments from the root.
+ */
+export declare function findCommonAncestorDepth(path1: string, path2: string): number;
 /**
  * Normalize a module path to a consistent form.
  * Returns slash-prefixed paths for files within project root,

package/dist/lib/normalizeModulePath.mjs

@@ -4,7 +4,7 @@ import { normalizePath as normalizePathSeparators } from "vite";
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
  */
-function findCommonAncestorDepth(path1, path2) {
+export function findCommonAncestorDepth(path1, path2) {
     const segments1 = path1.split("/").filter(Boolean);
     const segments2 = path2.split("/").filter(Boolean);
     let commonLength = 0;

package/dist/lib/normalizeModulePath.test.d.mts

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

package/dist/lib/{normalizeModulePath.test.js → normalizeModulePath.test.mjs}

@@ -1,5 +1,24 @@
-import { describe, it, expect } from "vitest";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { describe, expect, it } from "vitest";
+import { findCommonAncestorDepth, normalizeModulePath, } from "./normalizeModulePath.mjs";
+describe("findCommonAncestorDepth", () => {
+    it("should return the correct depth for common paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/d")).toBe(2);
+    });
+    it("should return 0 for completely different paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/d/e/f")).toBe(0);
+    });
+    it("should handle identical paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/c")).toBe(3);
+    });
+    it("should handle paths of different lengths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/c/d/e")).toBe(3);
+    });
+    it("should handle the root path", () => {
+        expect(findCommonAncestorDepth("/", "/a/b")).toBe(0);
+        expect(findCommonAncestorDepth("/a", "/")).toBe(0);
+        expect(findCommonAncestorDepth("/", "/")).toBe(0);
+    });
+});
 describe("normalizeModulePath", () => {
     describe("1. Project-local paths", () => {
         it("Relative file", () => {

package/dist/lib/setupEnvFiles.mjs

@@ -1,6 +1,6 @@
-import { resolve } from "node:path";
-import { symlink, copyFile } from "node:fs/promises";
 import { pathExists } from "fs-extra";
+import { copyFile, symlink } from "node:fs/promises";
+import { resolve } from "node:path";
 export async function setupEnvFiles({ rootDir, }) {
     const envPath = resolve(rootDir, ".env");
     const devVarsPath = resolve(rootDir, ".dev.vars");

package/dist/lib/smokeTests/artifacts.mjs

@@ -1,7 +1,7 @@
+import { createWriteStream, existsSync, mkdirSync } from "fs";
+import { mkdirp, pathExists } from "fs-extra";
 import * as fs from "fs/promises";
 import { join } from "path";
-import { mkdirp, pathExists } from "fs-extra";
-import { createWriteStream, existsSync, mkdirSync } from "fs";
 import { log } from "./constants.mjs";
 // Stream capturer for logging
 export const capturer = {

package/dist/lib/smokeTests/browser.d.mts

@@ -1,5 +1,5 @@
+import type { Browser, Page } from "puppeteer-core";
 import { SmokeTestOptions, SmokeTestResult } from "./types.mjs";
-import type { Page, Browser } from "puppeteer-core";
 export declare function checkUrlStyles(page: Page, expectedColor: "red" | "green"): Promise<void>;
 export declare function checkClientModuleStyles(page: Page, expectedColor: "blue" | "green"): Promise<void>;
 /**

package/dist/lib/smokeTests/browser.mjs

@@ -1,19 +1,14 @@
-import * as os from "os";
+import * as fs from "fs/promises";
 import { join } from "path";
-import { pathExists } from "fs-extra";
-import { log } from "./constants.mjs";
-import { mkdirp } from "fs-extra";
-import { install, resolveBuildId, computeExecutablePath, detectBrowserPlatform, Browser as PuppeteerBrowser, } from "@puppeteer/browsers";
-import puppeteer from "puppeteer-core";
-import { takeScreenshot } from "./artifacts.mjs";
-import { RETRIES } from "./constants.mjs";
 import { $ } from "../$.mjs";
-import { fail, withRetries } from "./utils.mjs";
+import { getBrowserPath as getE2EBrowserPath, launchBrowser as launchE2EBrowser, } from "../../lib/e2e/browser.mjs";
+import { takeScreenshot } from "./artifacts.mjs";
+import { log, RETRIES } from "./constants.mjs";
 import { reportSmokeTestResult } from "./reporting.mjs";
 import { updateTestStatus } from "./state.mjs";
-import * as fs from "fs/promises";
-import { template as urlStylesTemplate } from "./templates/smokeTestUrlStyles.css.template";
 import { template as clientStylesTemplate } from "./templates/smokeTestClientStyles.module.css.template";
+import { template as urlStylesTemplate } from "./templates/smokeTestUrlStyles.css.template";
+import { fail, withRetries } from "./utils.mjs";
 export async function checkUrlStyles(page, expectedColor) {
     const selector = '[data-testid="smoke-test-url-styles"]';
     log(`Checking for element with selector: ${selector}`);
@@ -86,100 +81,13 @@ export async function checkClientModuleStyles(page, expectedColor) {
  * Launch a browser instance
  */
 export async function launchBrowser(browserPath, headless = true) {
-    // Get browser path if not provided
-    if (!browserPath) {
-        log("Getting browser executable path");
-        browserPath = await getBrowserPath();
-    }
-    console.log(`🚀 Launching browser from ${browserPath} (headless: ${headless})`);
-    log("Starting browser with puppeteer");
-    return await puppeteer.launch({
-        executablePath: browserPath,
-        headless,
-        args: ["--no-sandbox", "--disable-setuid-sandbox"],
-    });
+    return launchE2EBrowser(browserPath, headless);
 }
 /**
  * Get the browser executable path
  */
 export async function getBrowserPath(testOptions) {
-    console.log("Finding Chrome executable...");
-    // First try using environment variable if set
-    if (process.env.CHROME_PATH) {
-        console.log(`Using Chrome from environment variable: ${process.env.CHROME_PATH}`);
-        return process.env.CHROME_PATH;
-    }
-    // Detect platform
-    log("Detecting platform");
-    const platform = detectBrowserPlatform();
-    if (!platform) {
-        log("ERROR: Failed to detect browser platform");
-        throw new Error("Failed to detect browser platform");
-    }
-    log("Detected platform: %s", platform);
-    // Define a consistent cache directory path in system temp folder
-    const rwCacheDir = join(os.tmpdir(), "redwoodjs-smoke-test-cache");
-    await mkdirp(rwCacheDir);
-    log("Using cache directory: %s", rwCacheDir);
-    // Determine browser type based on headless option
-    const browser = testOptions?.headless === false
-        ? PuppeteerBrowser.CHROME
-        : PuppeteerBrowser.CHROMEHEADLESSSHELL;
-    log(`Using browser type: ${browser}`);
-    // Resolve the buildId for the stable Chrome version - do this once
-    log("Resolving Chrome buildId for stable channel");
-    const buildId = await resolveBuildId(browser, platform, "stable");
-    log("Resolved buildId: %s", buildId);
-    // Create installation options - use them consistently
-    const installOptions = {
-        browser,
-        platform,
-        cacheDir: rwCacheDir,
-        buildId,
-        unpack: true,
-    };
-    try {
-        // Try to compute the path first (this will check if it's installed)
-        log("Attempting to find existing Chrome installation");
-        const path = computeExecutablePath(installOptions);
-        if (await pathExists(path)) {
-            console.log(`Found existing Chrome at: ${path}`);
-            return path;
-        }
-        else {
-            throw new Error("Chrome not found at: " + path);
-        }
-    }
-    catch (error) {
-        // If path computation fails, install Chrome
-        console.log("No Chrome installation found. Installing Chrome...");
-        // Add better error handling for the install step
-        try {
-            console.log("Downloading Chrome (this may take a few minutes)...");
-            await install(installOptions);
-            console.log("✅ Chrome installation completed successfully");
-            // Now compute the path for the installed browser
-            const path = computeExecutablePath(installOptions);
-            console.log(`Installed and using Chrome at: ${path}`);
-            return path;
-        }
-        catch (installError) {
-            // Provide more detailed error about the browser download failure
-            log("ERROR: Failed to download/install Chrome: %O", installError);
-            console.error(`❌ Failed to download/install Chrome browser.`);
-            console.error(`This is likely a network issue or the browser download URL is unavailable.`);
-            console.error(`Error details: ${installError instanceof Error ? installError.message : String(installError)}`);
-            // For debug builds, show the full error stack if available
-            if (installError instanceof Error && installError.stack) {
-                log("Error stack: %s", installError.stack);
-            }
-            console.log("\nPossible solutions:");
-            console.log("1. Check your internet connection");
-            console.log("2. Set CHROME_PATH environment variable to an existing Chrome installation");
-            console.log("3. Install Chrome manually and run the tests again");
-            throw new Error(`Failed to install Chrome browser: ${installError instanceof Error ? installError.message : String(installError)}`);
-        }
-    }
+    return getE2EBrowserPath(testOptions);
 }
 /**
  * Check a URL by performing smoke tests and realtime upgrade

package/dist/lib/smokeTests/cleanup.mjs

@@ -1,16 +1,13 @@
-import { join } from "path";
-import { setTimeout } from "node:timers/promises";
-import { pathExists } from "fs-extra";
-import { mkdirp } from "fs-extra";
+import { copy, mkdirp, pathExists } from "fs-extra";
 import * as fs from "fs/promises";
-import { copy } from "fs-extra";
-import { relative } from "path";
 import ignore from "ignore";
-import { log } from "./constants.mjs";
-import { deleteWorker, listD1Databases, deleteD1Database } from "./release.mjs";
-import { isRunningInCI } from "./utils.mjs";
+import { setTimeout } from "node:timers/promises";
+import { join, relative } from "path";
 import { capturer } from "./artifacts.mjs";
+import { log } from "./constants.mjs";
+import { deleteD1Database, deleteWorker, listD1Databases } from "./release.mjs";
 import { state } from "./state.mjs";
+import { isRunningInCI } from "./utils.mjs";
 /**
  * Cleans up any resources used during testing
  */

package/dist/lib/smokeTests/codeUpdates.mjs

@@ -1,13 +1,13 @@
-import { join } from "path";
 import * as fs from "fs/promises";
+import { parse as parseJsonc } from "jsonc-parser";
+import MagicString from "magic-string";
+import { join } from "path";
 import { log } from "./constants.mjs";
-import { getSmokeTestFunctionsTemplate } from "./templates/smokeTestFunctions.template";
 import { getSmokeTestTemplate } from "./templates/SmokeTest.template";
 import { getSmokeTestClientTemplate } from "./templates/SmokeTestClient.template";
-import { template as smokeTestUrlStylesCssTemplate } from "./templates/smokeTestUrlStyles.css.template";
 import { template as smokeTestClientStylesCssTemplate } from "./templates/smokeTestClientStyles.module.css.template";
-import MagicString from "magic-string";
-import { parse as parseJsonc } from "jsonc-parser";
+import { getSmokeTestFunctionsTemplate } from "./templates/smokeTestFunctions.template";
+import { template as smokeTestUrlStylesCssTemplate } from "./templates/smokeTestUrlStyles.css.template";
 /**
  * Creates the smoke test components in the target project directory
  */