rwsdk 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/lib/e2e/testHarness.mjs

@@ -0,0 +1,507 @@
+import { test, beforeAll, afterAll, afterEach, } from "vitest";
+import { basename, join as pathJoin, dirname } from "path";
+import fs from "node:fs";
+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;
+const PUPPETEER_TIMEOUT = process.env.RWSDK_PUPPETEER_TIMEOUT
+    ? parseInt(process.env.RWSDK_PUPPETEER_TIMEOUT, 10)
+    : 60 * 1000; // 60 seconds
+// 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";
+// Global test environment state
+let globalPlaygroundEnv = null;
+const cleanupTasks = [];
+let hooksRegistered = false;
+/**
+ * Registers global cleanup hooks automatically
+ */
+function ensureHooksRegistered() {
+    if (hooksRegistered)
+        return;
+    // Register global afterEach to clean up resources created during tests
+    afterEach(async () => {
+        const tasksToCleanup = [...cleanupTasks];
+        cleanupTasks.length = 0; // Clear the array
+        for (const task of tasksToCleanup) {
+            try {
+                await task.cleanup();
+            }
+            catch (error) {
+                console.warn(`Failed to cleanup ${task.type} ${task.id}:`, error);
+            }
+        }
+    });
+    // Register global afterAll to clean up the playground environment
+    afterAll(async () => {
+        if (globalPlaygroundEnv) {
+            try {
+                await globalPlaygroundEnv.cleanup();
+                globalPlaygroundEnv = null;
+            }
+            catch (error) {
+                console.warn("Failed to cleanup playground environment:", error);
+            }
+        }
+    });
+    hooksRegistered = true;
+}
+/**
+ * Registers a cleanup task to be executed automatically
+ */
+function registerCleanupTask(task) {
+    ensureHooksRegistered();
+    cleanupTasks.push(task);
+}
+/**
+ * Removes a cleanup task from the registry (when manually cleaned up)
+ */
+function unregisterCleanupTask(id) {
+    const index = cleanupTasks.findIndex((task) => task.id === id);
+    if (index !== -1) {
+        cleanupTasks.splice(index, 1);
+    }
+}
+/**
+ * Get the project directory for the current test by looking at the call stack
+ */
+function getProjectDirectory() {
+    // For now, let's hardcode this to '../playground/hello-world' since we only have one project
+    // TODO: Make this more dynamic when we have multiple playground projects
+    return "../playground/hello-world";
+}
+/**
+ * Derive the playground directory from import.meta.url by finding the nearest package.json
+ */
+function getPlaygroundDirFromImportMeta(importMetaUrl) {
+    const url = new URL(importMetaUrl);
+    const testFilePath = url.pathname;
+    let currentDir = dirname(testFilePath);
+    // Walk up the tree from the test file's directory
+    while (currentDir !== "/") {
+        // Check if a package.json exists in the current directory
+        if (fs.existsSync(pathJoin(currentDir, "package.json"))) {
+            return currentDir;
+        }
+        currentDir = dirname(currentDir);
+    }
+    throw new Error(`Could not determine playground directory from import.meta.url: ${importMetaUrl}. ` +
+        `Failed to find a package.json in any parent directory.`);
+}
+/**
+ * Sets up a playground environment for the entire test suite.
+ * Automatically registers beforeAll and afterAll hooks.
+ *
+ * @param sourceProjectDir - Explicit path to playground directory, or import.meta.url to auto-detect
+ */
+export function setupPlaygroundEnvironment(sourceProjectDir) {
+    ensureHooksRegistered();
+    beforeAll(async () => {
+        let projectDir;
+        if (!sourceProjectDir) {
+            projectDir = getProjectDirectory();
+        }
+        else if (sourceProjectDir.startsWith("file://")) {
+            // This is import.meta.url, derive the playground directory
+            projectDir = getPlaygroundDirFromImportMeta(sourceProjectDir);
+        }
+        else {
+            // This is an explicit path
+            projectDir = sourceProjectDir;
+        }
+        console.log(`Setting up playground environment from ${projectDir}...`);
+        const tarballEnv = await setupTarballEnvironment({
+            projectDir,
+            packageManager: process.env.PACKAGE_MANAGER || "pnpm",
+        });
+        globalPlaygroundEnv = {
+            projectDir: tarballEnv.targetDir,
+            cleanup: tarballEnv.cleanup,
+        };
+    }, SETUP_PLAYGROUND_ENV_TIMEOUT);
+}
+/**
+ * Gets the current playground environment.
+ * Throws if no environment has been set up.
+ */
+export function getPlaygroundEnvironment() {
+    if (!globalPlaygroundEnv) {
+        throw new Error("No playground environment set up. Call setupPlaygroundEnvironment() in beforeAll()");
+    }
+    return globalPlaygroundEnv;
+}
+/**
+ * Creates a dev server instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export async function createDevServer() {
+    if (SKIP_DEV_SERVER_TESTS) {
+        throw new Error("Dev server tests are skipped via RWSDK_SKIP_DEV=1");
+    }
+    const env = getPlaygroundEnvironment();
+    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)}`;
+    // Register automatic cleanup
+    registerCleanupTask({
+        id: serverId,
+        type: "devServer",
+        cleanup: devResult.stopDev,
+    });
+    return {
+        url: devResult.url,
+        stopDev: async () => {
+            await devResult.stopDev();
+            unregisterCleanupTask(serverId); // Remove from auto-cleanup since manually cleaned
+        },
+    };
+}
+/**
+ * Creates a deployment instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export async function createDeployment() {
+    if (SKIP_DEPLOYMENT_TESTS) {
+        throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
+    }
+    const env = getPlaygroundEnvironment();
+    // 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)}`;
+    // Register automatic cleanup (non-blocking for deployments)
+    registerCleanupTask({
+        id: deploymentId,
+        type: "deployment",
+        cleanup: async () => {
+            // Run deployment cleanup in background without blocking
+            const performCleanup = async () => {
+                if (isRelatedToTest(deployResult.workerName, resourceUniqueKey)) {
+                    await deleteWorker(deployResult.workerName, env.projectDir, resourceUniqueKey);
+                }
+                await deleteD1Database(resourceUniqueKey, env.projectDir, resourceUniqueKey);
+            };
+            // Start cleanup in background and return immediately
+            performCleanup().catch((error) => {
+                console.warn(`Warning: Background deployment cleanup failed: ${error.message}`);
+            });
+            return Promise.resolve();
+        },
+    });
+    return {
+        url: deployResult.url,
+        workerName: deployResult.workerName,
+        resourceUniqueKey,
+        projectDir: env.projectDir,
+    };
+}
+/**
+ * Manually cleans up a deployment instance (deletes worker and D1 database).
+ * This is optional since cleanup happens automatically after each test.
+ */
+export async function cleanupDeployment(deployment) {
+    console.log(`🧹 Cleaning up deployment: ${deployment.workerName} (${deployment.resourceUniqueKey})`);
+    const env = getPlaygroundEnvironment();
+    if (isRelatedToTest(deployment.workerName, deployment.resourceUniqueKey)) {
+        await deleteWorker(deployment.workerName, env.projectDir, deployment.resourceUniqueKey);
+    }
+    await deleteD1Database(deployment.resourceUniqueKey, env.projectDir, deployment.resourceUniqueKey);
+    // Remove from auto-cleanup registry since manually cleaned
+    const deploymentId = cleanupTasks.find((task) => task.type === "deployment" &&
+        task.id.includes(deployment.resourceUniqueKey))?.id;
+    if (deploymentId) {
+        unregisterCleanupTask(deploymentId);
+    }
+}
+/**
+ * Creates a browser instance for testing.
+ * Automatically registers cleanup to run after the test.
+ */
+export async function createBrowser() {
+    // Check if we should run in headed mode for debugging
+    const headless = process.env.RWSDK_HEADLESS !== "false";
+    const browser = await launchBrowser(undefined, headless);
+    const browserId = `browser-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    // Register automatic cleanup
+    registerCleanupTask({
+        id: browserId,
+        type: "browser",
+        cleanup: async () => {
+            try {
+                await browser.close();
+            }
+            catch (error) {
+                // Browser might already be closed, ignore the error
+            }
+        },
+    });
+    // Wrap the close method to handle cleanup registration
+    const originalClose = browser.close.bind(browser);
+    browser.close = async () => {
+        await originalClose();
+        unregisterCleanupTask(browserId); // Remove from auto-cleanup since manually closed
+    };
+    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, testFn);
+        return;
+    }
+    test(name, async () => {
+        await runTestWithRetries(name, async () => {
+            const devServer = await createDevServer();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            page.setDefaultTimeout(PUPPETEER_TIMEOUT);
+            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 });
+            }
+        });
+    });
+}
+/**
+ * Skip version of testDev
+ */
+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();
+            page.setDefaultTimeout(PUPPETEER_TIMEOUT);
+            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, testFn);
+        return;
+    }
+    test(name, async () => {
+        await runTestWithRetries(name, async () => {
+            const deployment = await createDeployment();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            page.setDefaultTimeout(PUPPETEER_TIMEOUT);
+            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 });
+            }
+        });
+    });
+}
+/**
+ * Skip version of testDeploy
+ */
+testDeploy.skip = (name, testFn) => {
+    test.skip(name, testFn || (() => { }));
+};
+testDeploy.only = (name, testFn) => {
+    if (SKIP_DEPLOYMENT_TESTS) {
+        test.skip(name, () => { });
+        return;
+    }
+    test.only(name, async () => {
+        await runTestWithRetries(name, async () => {
+            const deployment = await createDeployment();
+            const browser = await createBrowser();
+            const page = await browser.newPage();
+            page.setDefaultTimeout(PUPPETEER_TIMEOUT);
+            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, testFn || (() => { }));
+};
+testDevAndDeploy.only = (name, testFn) => {
+    testDev.only(`${name} (dev)`, testFn);
+    testDeploy.only(`${name} (deployment)`, testFn);
+};
+/**
+ * Utility function for polling/retrying assertions
+ */
+export async function poll(fn, timeout = 2 * 60 * 1000, // 2 minutes
+interval = 100) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        try {
+            const result = await fn();
+            if (result) {
+                return;
+            }
+        }
+        catch (error) {
+            // Continue polling on errors
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error(`Polling timed out after ${timeout}ms`);
+}

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,7 @@
 import { relative } from "node:path";
-export const getShortName = (file, root) => file.startsWith(root) ? relative(root, file) : file;
+import path 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 { describe, it, expect } from "vitest";
+import { getShortName } from "./getShortName.mjs";
+import path from "node:path";
+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/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 { describe, it, expect, beforeEach } from "vitest";
+import { hasPkgScript, _resetPkgCache } 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 {};