rwsdk 0.1.16 → 0.1.17

package/dist/lib/smokeTests/development.mjs

@@ -0,0 +1,209 @@
+import { setTimeout } from "node:timers/promises";
+import { log, RETRIES } from "./constants.mjs";
+import { $ } from "../$.mjs";
+import { checkUrl, checkServerUp } from "./browser.mjs";
+import { fail } from "./utils.mjs";
+import { state } from "./state.mjs";
+/**
+ * Run the local development server and return the URL
+ */
+export async function runDevServer(cwd) {
+    console.log("🚀 Starting development server...");
+    // Function to stop the dev server - defined early so we can use it in error handling
+    let devProcess = null;
+    let isErrorExpected = false;
+    const stopDev = async () => {
+        isErrorExpected = true;
+        if (!devProcess) {
+            log("No dev process to stop");
+            return;
+        }
+        console.log("Stopping development server...");
+        try {
+            // Send a regular termination signal first
+            devProcess.kill();
+            // Wait for the process to terminate with a timeout
+            const terminationTimeout = 5000; // 5 seconds timeout
+            const terminationPromise = Promise.race([
+                // Wait for natural process termination
+                (async () => {
+                    try {
+                        await devProcess;
+                        log("Dev server process was terminated normally");
+                        return true;
+                    }
+                    catch (e) {
+                        // Expected error when the process is killed
+                        log("Dev server process was terminated");
+                        return true;
+                    }
+                })(),
+                // Or timeout
+                (async () => {
+                    await setTimeout(terminationTimeout);
+                    return false;
+                })(),
+            ]);
+            // Check if process terminated within timeout
+            const terminated = await terminationPromise;
+            // If not terminated within timeout, force kill
+            if (!terminated) {
+                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...");
+                // Try to kill with SIGKILL if the process still has a pid
+                if (devProcess.pid) {
+                    try {
+                        // Use process.kill with SIGKILL for a stronger termination
+                        process.kill(devProcess.pid, "SIGKILL");
+                        log("Sent SIGKILL to process %d", devProcess.pid);
+                    }
+                    catch (killError) {
+                        log("Error sending SIGKILL to process: %O", killError);
+                        // Non-fatal, as the process might already be gone
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Process might already have exited
+            log("Could not kill dev server process: %O", e);
+        }
+        console.log("Development server stopped");
+    };
+    try {
+        // Check if we're in CI mode
+        const inCIMode = process.env.CI === "true" || process.env.CI === "1";
+        // Start dev server with stdout pipe to capture URL
+        // Create environment variables object
+        const env = { ...process.env };
+        // Disable colors when running in CI mode to make URL parsing more reliable
+        if (inCIMode) {
+            log("Running in CI mode, disabling colors for dev server output");
+            env.NO_COLOR = "1";
+            env.FORCE_COLOR = "0";
+        }
+        // Use the provided cwd if available
+        devProcess = $({
+            stdio: ["inherit", "pipe", "pipe"], // Pipe stderr again to check both streams
+            detached: true,
+            cleanup: false, // Don't auto-kill on exit
+            cwd: cwd || process.cwd(), // Use provided directory or current directory
+            env, // Pass the updated environment variables
+        }) `npm run dev`;
+        devProcess.catch((error) => {
+            if (!isErrorExpected) {
+                // Use fail() directly here to properly handle errors from the dev process
+                fail(error, 1, "Development Server Process");
+            }
+        });
+        log("Development server process spawned in directory: %s", cwd || process.cwd());
+        // Store chunks to parse the URL
+        let url = "";
+        // Listen for stdout to get the URL
+        devProcess.stdout?.on("data", (data) => {
+            const output = data.toString();
+            console.log(output);
+            // Try to extract the URL from the server output with a more flexible regex
+            // Allow for variable amounts of whitespace between "Local:" and the URL
+            // And handle ANSI color codes by using a more robust pattern
+            const localMatch = output.match(/Local:.*?(http:\/\/localhost:\d+)/);
+            if (localMatch && localMatch[1] && !url) {
+                url = localMatch[1];
+                log("Found development server URL: %s", url);
+            }
+            else if (output.includes("Local:") &&
+                output.includes("http://localhost:")) {
+                // Log near-match for debugging
+                log("Found potential URL pattern but regex didn't match. Content: %s", output);
+                // Try an alternative, more general pattern that's more resilient to ANSI codes
+                const altMatch = output.match(/localhost:(\d+)/i);
+                if (altMatch && altMatch[1] && !url) {
+                    url = `http://localhost:${altMatch[1]}`;
+                    log("Found development server URL with alternative pattern: %s", url);
+                }
+            }
+        });
+        // Also listen for stderr to check for URL patterns there as well
+        devProcess.stderr?.on("data", (data) => {
+            const output = data.toString();
+            console.error(output); // Output error messages to console
+            // Check if we already found a URL
+            if (url)
+                return;
+            // Check for localhost URLs in stderr using the same resilient patterns as stdout
+            const urlMatch = output.match(/localhost:(\d+)/i);
+            if (urlMatch && urlMatch[1]) {
+                url = `http://localhost:${urlMatch[1]}`;
+                log("Found development server URL in stderr: %s", url);
+            }
+        });
+        // Wait for URL with timeout
+        const waitForUrl = async () => {
+            const start = Date.now();
+            const timeout = 60000; // 60 seconds
+            while (Date.now() - start < timeout) {
+                if (url) {
+                    return url;
+                }
+                // Check if the process is still running
+                if (devProcess.exitCode !== null) {
+                    log("ERROR: Development server process exited with code %d", devProcess.exitCode);
+                    throw new Error(`Development server process exited with code ${devProcess.exitCode}`);
+                }
+                await setTimeout(500); // Check every 500ms
+            }
+            log("ERROR: Timed out waiting for dev server URL");
+            throw new Error("Timed out waiting for dev server URL");
+        };
+        // Wait for the URL
+        const serverUrl = await waitForUrl();
+        console.log(`✅ Development server started at ${serverUrl}`);
+        return { url: serverUrl, stopDev };
+    }
+    catch (error) {
+        // Make sure to try to stop the server on error
+        log("Error during dev server startup: %O", error);
+        await stopDev().catch((e) => {
+            log("Failed to stop dev server during error handling: %O", e);
+        });
+        throw error;
+    }
+}
+/**
+ * Runs tests against the development server
+ */
+export async function runDevTest(url, artifactDir, customPath = "/", browserPath, headless = true, bail = false, skipClient = false, realtime = false, skipHmr = false) {
+    log("Starting dev server test with path: %s", customPath || "/");
+    console.log("🚀 Testing local development server");
+    try {
+        // DRY: check both root and custom path
+        await checkServerUp(url, customPath, RETRIES, bail);
+        // Now run the tests with the custom path
+        const testUrl = url +
+            (customPath === "/"
+                ? ""
+                : customPath.startsWith("/")
+                    ? customPath
+                    : "/" + customPath);
+        // Pass the target directory to checkUrl for HMR testing
+        const targetDir = state.resources.targetDir;
+        await checkUrl(testUrl, artifactDir, browserPath, headless, bail, skipClient, "Development", // Add environment context parameter
+        realtime, // Add realtime parameter
+        targetDir, // Add target directory for HMR testing
+        skipHmr);
+        log("Development server test completed successfully");
+    }
+    catch (error) {
+        // Add more context about the specific part that failed
+        if (error instanceof Error && error.message.includes("Server at")) {
+            state.failures.push({
+                step: "Development - Server Availability",
+                error: error.message,
+                details: error.stack,
+            });
+        }
+        log("Error during development server testing: %O", error);
+        // Make sure we throw the error so it's properly handled upstream
+        throw error;
+    }
+}

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

@@ -0,0 +1,14 @@
+import tmp from "tmp-promise";
+import { SmokeTestOptions, TestResources } from "./types.mjs";
+/**
+ * Sets up the test environment, preparing any resources needed for testing
+ */
+export declare function setupTestEnvironment(options?: SmokeTestOptions): Promise<TestResources>;
+/**
+ * Copy project to a temporary directory with a unique name
+ */
+export declare function copyProjectToTempDir(projectDir: string, sync: boolean | undefined, resourceUniqueKey: string): Promise<{
+    tempDir: tmp.DirectoryResult;
+    targetDir: string;
+    workerName: string;
+}>;

package/dist/lib/smokeTests/environment.mjs

@@ -0,0 +1,163 @@
+import { join } from "path";
+import { pathExists, copy } from "fs-extra";
+import * as fs from "fs/promises";
+import tmp from "tmp-promise";
+import ignore from "ignore";
+import { relative, basename, resolve } from "path";
+import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
+import { $ } from "../../lib/$.mjs";
+import { log } from "./constants.mjs";
+import { debugSync } from "../../scripts/debug-sync.mjs";
+import { createSmokeTestComponents } from "./codeUpdates.mjs";
+import { createHash } from "crypto";
+/**
+ * Sets up the test environment, preparing any resources needed for testing
+ */
+export async function setupTestEnvironment(options = {}) {
+    log("Setting up test environment with options: %O", options);
+    // Generate a resource unique key for this test run right at the start
+    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);
+    // Create a resource unique key even if we're not copying a project
+    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
+    const resources = {
+        tempDirCleanup: undefined,
+        workerName: undefined,
+        originalCwd: process.cwd(),
+        targetDir: undefined,
+        workerCreatedDuringTest: false,
+        stopDev: undefined,
+        resourceUniqueKey, // Set at initialization
+    };
+    log("Current working directory: %s", resources.originalCwd);
+    try {
+        // If a project dir is specified, copy it to a temp dir with a unique name
+        if (options.projectDir) {
+            log("Project directory specified: %s", options.projectDir);
+            const { tempDir, targetDir, workerName } = await copyProjectToTempDir(options.projectDir, options.sync !== false, // default to true if undefined
+            resourceUniqueKey);
+            // Store cleanup function
+            resources.tempDirCleanup = tempDir.cleanup;
+            resources.workerName = workerName;
+            resources.targetDir = targetDir;
+            log("Target directory: %s", targetDir);
+            // Create the smoke test components in the user's project
+            log("Creating smoke test components");
+            await createSmokeTestComponents(targetDir, options.skipClient);
+        }
+        else {
+            log("No project directory specified, using current directory");
+            // When no project dir is specified, we'll use the current directory
+            resources.targetDir = resources.originalCwd;
+        }
+        return resources;
+    }
+    catch (error) {
+        log("Error during test environment setup: %O", error);
+        throw error;
+    }
+}
+/**
+ * Copy project to a temporary directory with a unique name
+ */
+export async function copyProjectToTempDir(projectDir, sync = true, resourceUniqueKey) {
+    log("Creating temporary directory for project");
+    // Create a temporary directory
+    const tempDir = await tmp.dir({ unsafeCleanup: true });
+    // Create unique project directory name
+    const originalDirName = basename(projectDir);
+    const workerName = `${originalDirName}-smoke-test-${resourceUniqueKey}`;
+    const targetDir = resolve(tempDir.path, workerName);
+    console.log(`Copying project from ${projectDir} to ${targetDir}`);
+    // Read project's .gitignore if it exists
+    let ig = ignore();
+    const gitignorePath = join(projectDir, ".gitignore");
+    if (await pathExists(gitignorePath)) {
+        log("Found .gitignore file at %s", gitignorePath);
+        const gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+        ig = ig.add(gitignoreContent);
+    }
+    else {
+        log("No .gitignore found, using default ignore patterns");
+        // Add default ignores if no .gitignore exists
+        ig = ig.add([
+            "node_modules",
+            ".git",
+            "dist",
+            "build",
+            ".DS_Store",
+            "coverage",
+            ".cache",
+            ".wrangler",
+            ".env",
+        ].join("\n"));
+    }
+    // Copy the project directory, respecting .gitignore
+    log("Starting copy process with ignored patterns");
+    await copy(projectDir, targetDir, {
+        filter: (src) => {
+            // Get path relative to project directory
+            const relativePath = relative(projectDir, src);
+            if (!relativePath)
+                return true; // Include the root directory
+            // Check against ignore patterns
+            const result = !ig.ignores(relativePath);
+            return result;
+        },
+    });
+    log("Project copy completed successfully");
+    // Install dependencies in the target directory
+    await installDependencies(targetDir);
+    // Sync SDK to the temp dir if requested
+    if (sync) {
+        console.log(`🔄 Syncing SDK to ${targetDir} after installing dependencies...`);
+        await debugSync({ targetDir });
+    }
+    return { tempDir, targetDir, workerName };
+}
+/**
+ * Install project dependencies using pnpm
+ */
+async function installDependencies(targetDir) {
+    console.log(`📦 Installing project dependencies in ${targetDir}...`);
+    try {
+        // Run pnpm install in the target directory
+        log("Running pnpm install");
+        const result = await $({
+            cwd: targetDir,
+            stdio: "pipe", // Capture output
+        }) `pnpm install`;
+        console.log("✅ Dependencies installed successfully");
+        // Log installation details at debug level
+        if (result.stdout) {
+            log("pnpm install output: %s", result.stdout);
+        }
+    }
+    catch (error) {
+        log("ERROR: Failed to install dependencies: %O", error);
+        console.error(`❌ Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`);
+        // Try npm as fallback if pnpm fails
+        try {
+            console.log("⚠️ pnpm install failed, trying npm install as fallback...");
+            await $({
+                cwd: targetDir,
+                stdio: "pipe",
+            }) `npm install`;
+            console.log("✅ Dependencies installed successfully with npm");
+        }
+        catch (npmError) {
+            log("ERROR: Both pnpm and npm install failed: %O", npmError);
+            console.error(`❌ Failed to install dependencies with npm: ${npmError instanceof Error ? npmError.message : String(npmError)}`);
+            throw new Error(`Failed to install project dependencies. Please ensure the project can be installed with pnpm or npm.`);
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+import { TestResources } from "./types.mjs";
+interface ExpectOptions {
+    expect: string | RegExp;
+    send?: string;
+}
+interface ExpectResult {
+    stdout: string;
+    stderr: string;
+    code: number | null;
+}
+interface D1Database {
+    name: string;
+    uuid: string;
+    [key: string]: any;
+}
+/**
+ * A mini expect-like utility for handling interactive CLI prompts and verifying output
+ * @param command The command to execute
+ * @param expectations Array of {expect, send} objects for interactive responses and verification
+ * @param options Additional options for command execution including working directory and environment
+ * @returns Promise that resolves when the command completes
+ */
+export declare function $expect(command: string, expectations: Array<ExpectOptions>, options?: {
+    reject?: boolean;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): Promise<ExpectResult>;
+/**
+ * Ensures Cloudflare account ID is set in environment
+ * First checks wrangler cache, then environment variables, and finally guides the user
+ */
+export declare function ensureCloudflareAccountId(cwd?: string, projectDir?: string): Promise<void>;
+/**
+ * Run the release command to deploy to Cloudflare
+ */
+export declare function runRelease(cwd: string, projectDir: string, resourceUniqueKey: string): Promise<{
+    url: string;
+    workerName: string;
+}>;
+/**
+ * Runs tests against the production deployment
+ */
+export declare function runReleaseTest(customPath: string | undefined, artifactDir: string, resources: TestResources, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, projectDir?: string, realtime?: boolean, skipHmr?: boolean): Promise<void>;
+/**
+ * Check if a resource name includes a specific resource unique key
+ * This is used to identify resources created during our tests
+ */
+export declare function isRelatedToTest(resourceName: string, resourceUniqueKey: string): boolean;
+/**
+ * Delete the worker using wrangler
+ */
+export declare function deleteWorker(name: string, cwd: string, resourceUniqueKey: string): Promise<void>;
+/**
+ * List D1 databases using wrangler
+ */
+export declare function listD1Databases(cwd?: string): Promise<Array<D1Database>>;
+/**
+ * Delete a D1 database using wrangler
+ */
+export declare function deleteD1Database(name: string, cwd: string, resourceUniqueKey: string): Promise<void>;
+export {};