rwsdk 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/lib/e2e/poll.mjs

@@ -0,0 +1,31 @@
+import { setTimeout } from "node:timers/promises";
+const POLL_TIMEOUT = process.env.RWSDK_POLL_TIMEOUT
+    ? parseInt(process.env.RWSDK_POLL_TIMEOUT, 10)
+    : 2 * 60 * 1000;
+export async function poll(fn, options = {}) {
+    const { timeout = POLL_TIMEOUT, interval = 100, minTries = 3, onRetry, } = options;
+    const startTime = Date.now();
+    let tries = 0;
+    while (Date.now() - startTime < timeout || tries < minTries) {
+        tries++;
+        try {
+            if (await fn()) {
+                return;
+            }
+        }
+        catch (error) {
+            onRetry?.(error, tries);
+            // Continue polling on errors
+        }
+        await setTimeout(interval);
+    }
+    throw new Error(`Polling timed out after ${Date.now() - startTime}ms and ${tries} attempts`);
+}
+export async function pollValue(fn, options = {}) {
+    let value;
+    await poll(async () => {
+        value = await fn();
+        return true;
+    }, options);
+    return value;
+}

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

@@ -44,7 +44,7 @@ export declare function isRelatedToTest(resourceName: string, resourceUniqueKey:
 /**
  * Delete the worker using wrangler
  */
-export declare function deleteWorker(name: string, cwd: string, resourceUniqueKey: string): Promise<void>;
+export declare function deleteWorker(workerName: string, projectDir: string, resourceUniqueKey: string): Promise<void>;
 /**
  * List D1 databases using wrangler
  */

package/dist/lib/e2e/release.mjs

@@ -1,12 +1,12 @@
-import { join, basename, dirname, resolve } from "path";
-import { setTimeout } from "node:timers/promises";
 import debug from "debug";
-import { $ } from "../../lib/$.mjs";
 import { execaCommand } from "execa";
 import { existsSync, readFileSync } from "fs";
 import { pathExists } from "fs-extra";
-import { parse as parseJsonc } from "jsonc-parser";
 import * as fs from "fs/promises";
+import { parse as parseJsonc } from "jsonc-parser";
+import { setTimeout } from "node:timers/promises";
+import { basename, dirname, join, resolve } from "path";
+import { $ } from "../../lib/$.mjs";
 import { extractLastJson, parseJson } from "../../lib/jsonUtils.mjs";
 const log = debug("rwsdk:e2e:release");
 /**
@@ -412,44 +412,53 @@ export function isRelatedToTest(resourceName, resourceUniqueKey) {
 /**
  * Delete the worker using wrangler
  */
-export async function deleteWorker(name, cwd, resourceUniqueKey) {
-    console.log(`Cleaning up: Deleting worker ${name}...`);
-    // Safety check: if we have a resourceUniqueKey, verify this worker name contains it
-    if (resourceUniqueKey && !isRelatedToTest(name, resourceUniqueKey)) {
-        log(`Worker ${name} does not contain unique key ${resourceUniqueKey}, not deleting for safety`);
-        console.log(`⚠️ Worker ${name} does not seem to be created by this test, skipping deletion for safety`);
+export async function deleteWorker(workerName, projectDir, resourceUniqueKey) {
+    console.log(`Cleaning up: Deleting worker ${workerName}...`);
+    // We are extra careful here to not delete workers that are not related to
+    // the current test run. We check if the worker name contains the resource
+    // unique key, and if the project directory also contains the resource unique
+    // key.
+    if (!isRelatedToTest(workerName, resourceUniqueKey)) {
+        console.warn(`⚠️ Worker name "${workerName}" does not contain resource unique key "${resourceUniqueKey}". Skipping delete.`);
+        return;
+    }
+    if (!isRelatedToTest(projectDir, resourceUniqueKey)) {
+        console.warn(`⚠️ Project dir "${projectDir}" does not contain resource unique key "${resourceUniqueKey}". Skipping delete.`);
+        return;
+    }
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+    if (!accountId || !apiToken) {
+        console.error("❌ CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN env vars must be set to delete worker");
         return;
     }
+    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/scripts/${workerName}`;
+    console.log(`Running API call: DELETE ${url}`);
     try {
-        // Use our $expect utility to handle any confirmation prompts
-        log("Running wrangler delete command with interactive prompts");
-        await $expect(`npx wrangler delete ${name}`, [
-            {
-                expect: "Are you sure you want to delete",
-                send: "y\r",
+        const response = await fetch(url, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${apiToken}`,
+                "Content-Type": "application/json",
             },
-        ], {
-            cwd,
         });
-        console.log(`✅ Worker ${name} deleted successfully`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Cloudflare API request failed with status ${response.status}: ${errorText}`);
+        }
+        const responseData = (await response.json());
+        if (!responseData.success) {
+            throw new Error(`Cloudflare API returned an error: ${JSON.stringify(responseData.errors)}`);
+        }
+        console.log(`✅ Successfully deleted worker "${workerName}"`);
     }
     catch (error) {
-        console.error(`Failed to delete worker ${name}: ${error}`);
-        // Retry with force flag if the first attempt failed
-        try {
-            console.log("Retrying with force flag...");
-            await $expect(`npx wrangler delete ${name} --yes --force`, [
-                {
-                    expect: "Are you sure you want to delete",
-                    send: "y\r",
-                },
-            ], {
-                cwd,
-            });
-            console.log(`✅ Worker ${name} force deleted successfully`);
+        console.error(`❌ Failed to delete worker "${workerName}"`);
+        if (error instanceof Error) {
+            console.error(`Error message: ${error.message}`);
         }
-        catch (retryError) {
-            console.error(`Failed to force delete worker ${name}: ${retryError}`);
+        else {
+            console.error("An unknown error occurred:", error);
         }
     }
 }
@@ -487,6 +496,19 @@ export async function listD1Databases(cwd) {
  * Delete a D1 database using wrangler
  */
 export async function deleteD1Database(name, cwd, resourceUniqueKey) {
+    // Check wrangler.jsonc to see if a database is configured
+    const wranglerConfigPath = resolve(cwd, "wrangler.jsonc");
+    try {
+        const configContent = await fs.readFile(wranglerConfigPath, "utf-8");
+        const config = parseJsonc(configContent);
+        if (!config.d1_databases || config.d1_databases.length === 0) {
+            log("No D1 databases configured in wrangler.jsonc, skipping deletion.");
+            return;
+        }
+    }
+    catch (error) {
+        log(`Could not read or parse wrangler.jsonc at ${wranglerConfigPath}, proceeding with deletion attempt anyway.`, error);
+    }
     console.log(`Cleaning up: Deleting D1 database ${name}...`);
     try {
         // First check if the database exists

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

@@ -0,0 +1,4 @@
+export declare function retry<T>(fn: () => Promise<T>, options: {
+    retries: number;
+    delay: number;
+}): Promise<T>;

package/dist/lib/e2e/retry.mjs

@@ -0,0 +1,16 @@
+import { setTimeout } from "node:timers/promises";
+const log = console.log;
+export async function retry(fn, options) {
+    let lastError;
+    for (let i = 0; i < options.retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            lastError = e;
+            log(`Attempt ${i + 1} failed. Retrying in ${options.delay}ms...`);
+            await setTimeout(options.delay);
+        }
+    }
+    throw lastError;
+}

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

@@ -0,0 +1,2 @@
+export type { Browser } from "puppeteer-core";
+export { launchBrowser } from "./browser.mjs";

package/dist/lib/e2e/setup.mjs

@@ -0,0 +1 @@
+export { launchBrowser } from "./browser.mjs";

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

@@ -1,14 +1,14 @@
 interface SetupTarballOptions {
     projectDir: string;
-    packageManager?: "pnpm" | "npm" | "yarn";
+    monorepoRoot?: string;
+    packageManager?: "pnpm" | "npm" | "yarn" | "yarn-classic";
 }
 interface TarballEnvironment {
     targetDir: string;
     cleanup: () => Promise<void>;
-    tarballPath: string;
 }
 /**
  * Creates a tarball-based test environment similar to the release script approach
  */
-export declare function setupTarballEnvironment({ projectDir, packageManager, }: SetupTarballOptions): Promise<TarballEnvironment>;
+export declare function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager, }: SetupTarballOptions): Promise<TarballEnvironment>;
 export {};

package/dist/lib/e2e/tarball.mjs

@@ -1,8 +1,10 @@
+import { createHash } from "crypto";
 import { $ } from "execa";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
-import crypto from "node:crypto";
+import { adjectives, animals, uniqueNamesGenerator, } from "unique-names-generator";
+import { ROOT_DIR } from "../constants.mjs";
+import { copyProjectToTempDir } from "./environment.mjs";
 const log = (message) => console.log(message);
 /**
  * Copies wrangler cache from monorepo to temp directory for deployment tests
@@ -61,129 +63,37 @@ async function copyWranglerCache(targetDir, sdkRoot) {
 /**
  * Creates a tarball-based test environment similar to the release script approach
  */
-export async function setupTarballEnvironment({ projectDir, packageManager = "pnpm", }) {
-    // Generate unique temp directory name
-    const randomId = crypto.randomBytes(4).toString("hex");
-    const projectName = path.basename(projectDir);
-    const tempDirName = `${projectName}-e2e-test-${randomId}`;
-    const targetDir = path.join(os.tmpdir(), tempDirName);
-    log(`📁 Creating temp directory: ${targetDir}`);
-    // Create temp directory
-    await fs.promises.mkdir(targetDir, { recursive: true });
+export async function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager = "pnpm", }) {
+    log(`🚀 Setting up tarball environment for ${projectDir}`);
+    // Generate a resource unique key for this test run
+    const uniqueNameSuffix = uniqueNamesGenerator({
+        dictionaries: [adjectives, animals],
+        separator: "-",
+        length: 2,
+        style: "lowerCase",
+    });
+    // Create a short unique hash based on the timestamp
+    const hash = createHash("md5")
+        .update(Date.now().toString())
+        .digest("hex")
+        .substring(0, 8);
+    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
     try {
-        // Copy project to temp directory
-        log(`📋 Copying project from ${projectDir} to ${targetDir}`);
-        await $ `cp -a ${projectDir}/. ${targetDir}/`;
-        // Configure temp project to not use frozen lockfile
-        log(`⚙️  Configuring temp project to not use frozen lockfile...`);
-        const npmrcPath = path.join(targetDir, ".npmrc");
-        await fs.promises.writeFile(npmrcPath, "frozen-lockfile=false\n");
-        // Replace workspace:* dependencies with placeholder versions
-        log(`🔄 Replacing workspace dependencies...`);
-        const packageJsonPath = path.join(targetDir, "package.json");
-        const packageJsonContent = await fs.promises.readFile(packageJsonPath, "utf8");
-        const packageJson = JSON.parse(packageJsonContent);
-        // Replace workspace:* dependencies with a placeholder version
-        const replaceWorkspaceDeps = (deps) => {
-            if (!deps)
-                return;
-            for (const [name, version] of Object.entries(deps)) {
-                if (version === "workspace:*") {
-                    deps[name] = "0.0.80"; // Use a placeholder version that exists on npm
-                }
-            }
-        };
-        replaceWorkspaceDeps(packageJson.dependencies);
-        replaceWorkspaceDeps(packageJson.devDependencies);
-        replaceWorkspaceDeps(packageJson.peerDependencies);
-        await fs.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-        // Find SDK root directory (relative to current working directory)
-        const currentDir = process.cwd();
-        const sdkRoot = currentDir.includes("/playground")
-            ? path.join(currentDir, "../sdk")
-            : currentDir;
-        // Pack the SDK
-        log(`📦 Packing SDK from ${sdkRoot}...`);
-        const packResult = await $({ cwd: sdkRoot }) `npm pack`;
-        const tarballName = packResult.stdout.trim();
-        const tarballPath = path.join(sdkRoot, tarballName);
-        // Install the tarball in the temp project
-        log(`💿 Installing tarball ${tarballName} in ${targetDir}...`);
-        if (packageManager === "pnpm") {
-            await $({ cwd: targetDir }) `pnpm add ${tarballPath}`;
-        }
-        else if (packageManager === "npm") {
-            await $({ cwd: targetDir }) `npm install ${tarballPath}`;
-        }
-        else if (packageManager === "yarn") {
-            await $({ cwd: targetDir }) `yarn add ${tarballPath}`;
-        }
-        else {
-            throw new Error(`Unsupported package manager: ${packageManager}`);
-        }
-        // Verify installation
-        const sdkPackageJson = JSON.parse(await fs.promises.readFile(path.join(sdkRoot, "package.json"), "utf8"));
-        const packageName = sdkPackageJson.name;
-        const installedDistPath = path.join(targetDir, "node_modules", packageName, "dist");
-        log(`🔍 Verifying installed package contents...`);
-        if (!fs.existsSync(installedDistPath)) {
-            throw new Error(`dist/ directory not found in installed package at ${installedDistPath}`);
-        }
-        // Compare checksums like the release script does
-        const originalDistPath = path.join(sdkRoot, "dist");
-        if (fs.existsSync(originalDistPath)) {
-            const getDistChecksum = async (distPath) => {
-                const findResult = await $({ cwd: distPath }) `find . -type f`;
-                const sortedFiles = findResult.stdout
-                    .trim()
-                    .split("\n")
-                    .sort()
-                    .join("\n");
-                return crypto.createHash("md5").update(sortedFiles).digest("hex");
-            };
-            const originalChecksum = await getDistChecksum(originalDistPath);
-            const installedChecksum = await getDistChecksum(installedDistPath);
-            log(`  - Original dist checksum: ${originalChecksum}`);
-            log(`  - Installed dist checksum: ${installedChecksum}`);
-            if (originalChecksum !== installedChecksum) {
-                throw new Error("File list in installed dist/ does not match original dist/");
-            }
-            log(`  ✅ Installed package contents match the local build`);
-        }
-        // Copy wrangler cache from monorepo to temp directory for deployment tests
+        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot);
+        // Copy wrangler cache to improve deployment performance
+        const sdkRoot = ROOT_DIR;
         await copyWranglerCache(targetDir, sdkRoot);
-        // Cleanup function
-        const cleanup = async () => {
-            try {
-                // Remove tarball
-                if (fs.existsSync(tarballPath)) {
-                    await fs.promises.unlink(tarballPath);
-                }
-                // Remove temp directory
-                if (fs.existsSync(targetDir)) {
-                    await fs.promises.rm(targetDir, { recursive: true, force: true });
-                }
-            }
-            catch (error) {
-                console.warn(`Warning: Failed to cleanup temp files: ${error.message}`);
-            }
-        };
+        log(`✅ Tarball environment setup complete`);
         return {
             targetDir,
-            cleanup,
-            tarballPath,
+            cleanup: async () => {
+                log(`🧹 Cleaning up tarball environment: ${tempDir.path}`);
+                await tempDir.cleanup();
+            },
         };
     }
     catch (error) {
-        // Cleanup on error
-        try {
-            if (fs.existsSync(targetDir)) {
-                await fs.promises.rm(targetDir, { recursive: true, force: true });
-            }
-        }
-        catch (cleanupError) {
-            console.warn(`Warning: Failed to cleanup after error: ${cleanupError.message}`);
-        }
+        // Cleanup tarball on error
         throw error;
     }
 }

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

@@ -1,8 +1,6 @@
-import type { Browser, Page } from "puppeteer-core";
-interface PlaygroundEnvironment {
-    projectDir: string;
-    cleanup: () => Promise<void>;
-}
+import { type Browser, type Page } from "puppeteer-core";
+import { test } from "vitest";
+export type { Browser, Page } from "puppeteer-core";
 interface DevServerInstance {
     url: string;
     stopDev: () => Promise<void>;
@@ -11,64 +9,94 @@ interface DeploymentInstance {
     url: string;
     workerName: string;
     resourceUniqueKey: string;
+    projectDir: string;
+    cleanup: () => Promise<void>;
+}
+export interface SetupPlaygroundEnvironmentOptions {
+    /**
+     * The directory of the playground project to set up.
+     * Can be an absolute path, or a `import.meta.url` `file://` string.
+     * If not provided, it will be inferred from the test file's path.
+     */
+    sourceProjectDir?: string;
+    /**
+     * The root directory of the monorepo, if the project is part of one.
+     * This is used to correctly set up the test environment for monorepo projects.
+     */
+    monorepoRoot?: string;
+    /**
+     * Whether to provision a dev server for the test suite.
+     * @default true
+     */
+    dev?: boolean;
+    /**
+     * Whether to provision a deployment for the test suite.
+     * @default true
+     */
+    deploy?: boolean;
 }
 /**
- * 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 declare function setupPlaygroundEnvironment(sourceProjectDir?: string): void;
-/**
- * Gets the current playground environment.
- * Throws if no environment has been set up.
+ * A Vitest hook that sets up a playground environment for a test file.
+ * It creates a temporary directory, copies the playground project into it,
+ * and installs dependencies using a tarball of the SDK.
+ * This ensures that tests run in a clean, isolated environment.
  */
-export declare function getPlaygroundEnvironment(): PlaygroundEnvironment;
+export declare function setupPlaygroundEnvironment(options?: string | SetupPlaygroundEnvironmentOptions): void;
 /**
  * Creates a dev server instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export declare function createDevServer(): Promise<DevServerInstance>;
+export declare function createDevServer(projectDir: string): Promise<DevServerInstance>;
 /**
  * Creates a deployment instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export declare function createDeployment(): Promise<DeploymentInstance>;
-/**
- * Manually cleans up a deployment instance (deletes worker and D1 database).
- * This is optional since cleanup happens automatically after each test.
- */
-export declare function cleanupDeployment(deployment: DeploymentInstance): Promise<void>;
+export declare function createDeployment(projectDir: string): Promise<DeploymentInstance>;
 /**
- * Creates a browser instance for testing.
- * Automatically registers cleanup to run after the test.
+ * 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 declare function createBrowser(): Promise<Browser>;
+export declare function runTestWithRetries(name: string, attemptFn: () => Promise<void>): Promise<void>;
+declare function createTestRunner(testFn: (typeof test | typeof test.only)["concurrent"], envType: "dev" | "deploy"): (name: string, testLogic: (context: {
+    devServer?: DevServerInstance;
+    deployment?: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>) => void;
 /**
  * High-level test wrapper for dev server tests.
  * Automatically skips if RWSDK_SKIP_DEV=1
  */
-export declare function testDev(name: string, testFn: (context: {
-    devServer: DevServerInstance;
-    browser: Browser;
-    page: Page;
-    url: string;
-}) => Promise<void>): void;
+export declare function testDev(...args: Parameters<ReturnType<typeof createTestRunner>>): void;
 export declare namespace testDev {
     var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testLogic: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
 }
 /**
  * High-level test wrapper for deployment tests.
  * Automatically skips if RWSDK_SKIP_DEPLOY=1
  */
-export declare function testDeploy(name: string, testFn: (context: {
-    deployment: DeploymentInstance;
-    browser: Browser;
-    page: Page;
-    url: string;
-}) => Promise<void>): void;
+export declare function testDeploy(...args: Parameters<ReturnType<typeof createTestRunner>>): void;
 export declare namespace testDeploy {
     var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testLogic: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
 }
 /**
  * Unified test function that runs the same test against both dev server and deployment.
@@ -92,7 +120,13 @@ export declare namespace testDevAndDeploy {
     }) => Promise<void>) => void;
 }
 /**
- * Utility function for polling/retrying assertions
+ * Waits for the page to be fully loaded and hydrated.
+ * This should be used before any user interaction is simulated.
  */
-export declare function poll(fn: () => Promise<boolean>, timeout?: number, interval?: number): Promise<void>;
-export {};
+export declare function waitForHydration(page: Page): Promise<void>;
+export declare function trackPageErrors(page: Page): {
+    get: () => {
+        consoleErrors: string[];
+        failedRequests: string[];
+    };
+};