rwsdk 0.1.16 → 0.1.17

package/dist/scripts/smoke-test.mjs

@@ -0,0 +1,166 @@
+import { fileURLToPath } from "url";
+import { join } from "path";
+import debug from "debug";
+import { runSmokeTests } from "../lib/smokeTests/runSmokeTests.mjs";
+import { isRunningInCI } from "../lib/smokeTests/utils.mjs";
+// Set up debug logging
+if (!process.env.DEBUG) {
+    debug.enable("rwsdk:smoke");
+}
+const log = debug("rwsdk:smoke");
+// Run the smoke test if this file is executed directly
+if (fileURLToPath(import.meta.url) === process.argv[1]) {
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    log("Command line arguments: %O", args);
+    // Check for CI flag first
+    const ciFlag = args.includes("--ci");
+    // Set initial default values (sync will be determined below)
+    const options = {
+        customPath: "/", // Default path
+        skipDev: false,
+        skipRelease: false,
+        skipClient: false,
+        projectDir: undefined,
+        artifactDir: join(process.cwd(), ".artifacts"), // Default to .artifacts in current directory
+        keep: isRunningInCI(ciFlag), // Default to true in CI environments
+        headless: true,
+        ci: ciFlag,
+        bail: false, // Default to false - continue tests even if some fail
+        copyProject: false, // Default to false - don't copy project to artifacts
+        realtime: false, // Default to false - don't just test realtime
+        skipHmr: false, // Default to false - run HMR tests
+        // sync: will be set below
+    };
+    // Log if we're in CI
+    if (isRunningInCI(ciFlag)) {
+        log("Running in CI environment, keeping test directory by default");
+    }
+    // Track if user explicitly set sync or no-sync
+    let syncExplicit = undefined;
+    // Process arguments in order
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--skip-dev") {
+            options.skipDev = true;
+        }
+        else if (arg === "--skip-release") {
+            options.skipRelease = true;
+        }
+        else if (arg === "--skip-client") {
+            options.skipClient = true;
+        }
+        else if (arg === "--skip-hmr") {
+            options.skipHmr = true;
+        }
+        else if (arg === "--keep") {
+            options.keep = true;
+        }
+        else if (arg === "--no-headless") {
+            options.headless = false;
+        }
+        else if (arg === "--copy-project") {
+            options.copyProject = true;
+        }
+        else if (arg === "--no-sync") {
+            syncExplicit = false;
+        }
+        else if (arg === "--sync") {
+            syncExplicit = true;
+        }
+        else if (arg === "--ci") {
+            // Already handled above, just skip
+        }
+        else if (arg === "--bail") {
+            options.bail = true;
+        }
+        else if (arg === "--realtime") {
+            options.realtime = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            // Display help text
+            console.log(`
+Smoke Test Usage:
+  node smoke-test.mjs [options]
+
+Options:
+  --url=PATH              Custom URL path to test (e.g., "/login")
+  --skip-dev              Skip testing the local development server
+  --skip-release          Skip testing the release/production deployment
+  --skip-client           Skip client-side tests, only run server-side checks
+  --skip-hmr              Skip hot module replacement (HMR) tests
+  --path=PATH             Project directory to test
+  --artifact-dir=DIR      Directory to store test artifacts (default: .artifacts)
+  --keep                  Keep temporary test directory after tests complete
+  --no-headless           Run browser tests with GUI (not headless)
+  --sync                  Force syncing SDK code to test project
+  --no-sync               Disable syncing SDK code to test project
+  --ci                    Run in CI mode (keeps temp dirs, sets headless)
+  --bail                  Stop on first test failure
+  --copy-project          Copy the project to the artifacts directory
+  --realtime              Only run realtime smoke tests, skip initial tests
+  --help                  Show this help message
+`);
+            process.exit(0);
+        }
+        else if (arg.startsWith("--path=")) {
+            options.projectDir = arg.substring(7);
+        }
+        else if (arg.startsWith("--artifact-dir=")) {
+            options.artifactDir = arg.substring(15);
+        }
+        else if (arg.startsWith("--url=")) {
+            options.customPath = arg.substring(6);
+        }
+        else if (!arg.startsWith("--")) {
+            // For backwards compatibility, any non-flag argument is treated as the custom path
+            console.log(`Setting URL path to "${arg}" (use --url= format in the future)`);
+            options.customPath = arg;
+        }
+        else {
+            // Throw error for unknown options instead of just warning
+            log("Unknown option: %s", arg);
+            throw new Error(`Unknown option: ${arg}. Use --help to see available options.`);
+        }
+    }
+    // Async IIFE to determine sync default and run main
+    (async () => {
+        if (syncExplicit !== undefined) {
+            options.sync = syncExplicit;
+        }
+        else {
+            // Determine default for sync: true if cwd has package.json with name 'rwsdk', otherwise false
+            let syncDefault = false;
+            const pkgPath = join(process.cwd(), "package.json");
+            log(`[sync default] Checking for package.json at: %s`, pkgPath);
+            try {
+                const pkgRaw = await import("fs/promises").then((fs) => fs.readFile(pkgPath, "utf8"));
+                log(`[sync default] Read package.json: %s`, pkgRaw);
+                const pkg = JSON.parse(pkgRaw);
+                if (pkg && pkg.name === "rwsdk") {
+                    log(`[sync default] package.json name is 'rwsdk', setting syncDefault = true`);
+                    syncDefault = true;
+                }
+                else {
+                    log(`[sync default] package.json name is not 'rwsdk', setting syncDefault = false`);
+                }
+            }
+            catch (e) {
+                log(`[sync default] Could not read package.json or parse name: %O`, e);
+                log(`[sync default] Defaulting syncDefault = false`);
+            }
+            log(`[sync default] Final syncDefault value: %s`, syncDefault);
+            options.sync = syncDefault;
+        }
+        log("Parsed options: %O", options);
+        // Run the smoke tests with the parsed options
+        try {
+            await runSmokeTests(options);
+        }
+        catch (error) {
+            log("Error running smoke tests: %O", error);
+            console.error(`Error running smoke tests: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    })();
+}

package/dist/scripts/worker-run.d.mts

@@ -0,0 +1 @@
+export declare const runWorkerScript: (relativeScriptPath: string) => Promise<never>;

package/dist/scripts/worker-run.mjs

@@ -0,0 +1,82 @@
+import { resolve } from "path";
+import { writeFile } from "fs/promises";
+import { unstable_readConfig } from "wrangler";
+import { createServer as createViteServer } from "vite";
+import tmp from "tmp-promise";
+import baseDebug from "debug";
+import { redwood } from "../vite/index.mjs";
+import { findWranglerConfig } from "../lib/findWranglerConfig.mjs";
+const debug = baseDebug("rwsdk:worker-run");
+export const runWorkerScript = async (relativeScriptPath) => {
+    if (!relativeScriptPath) {
+        console.error("Error: Script path is required");
+        console.log("\nUsage:");
+        console.log("  npm run worker:run <script-path>");
+        console.log("\nExample:");
+        console.log("  npm run worker:run src/scripts/seed.ts\n");
+        process.exit(1);
+    }
+    const scriptPath = resolve(process.cwd(), relativeScriptPath);
+    debug("Running worker script: %s", scriptPath);
+    const workerConfigPath = await findWranglerConfig(process.cwd());
+    debug("Using wrangler config: %s", workerConfigPath);
+    const workerConfig = unstable_readConfig({
+        config: workerConfigPath,
+    });
+    const tmpWorkerPath = await tmp.file({
+        postfix: ".json",
+    });
+    const scriptWorkerConfig = {
+        ...workerConfig,
+        configPath: tmpWorkerPath.path,
+        userConfigPath: tmpWorkerPath.path,
+        main: scriptPath,
+    };
+    try {
+        await writeFile(tmpWorkerPath.path, JSON.stringify(scriptWorkerConfig, null, 2));
+        debug("Worker config written to: %s", tmpWorkerPath.path);
+        process.env.RWSDK_WORKER_RUN = "1";
+        const server = await createViteServer({
+            configFile: false,
+            plugins: [
+                redwood({
+                    configPath: tmpWorkerPath.path,
+                    includeCloudflarePlugin: true,
+                    entry: {
+                        worker: scriptPath,
+                    },
+                }),
+            ],
+            server: {
+                port: 0,
+            },
+        });
+        debug("Vite server created");
+        try {
+            await server.listen();
+            const address = server.httpServer?.address();
+            debug("Server listening on address: %o", address);
+            if (!address || typeof address === "string") {
+                throw new Error("Dev server address is invalid");
+            }
+            debug("Fetching worker...");
+            await fetch(`http://localhost:${address.port}/`);
+            debug("Worker fetched successfully");
+        }
+        finally {
+            debug("Closing server...");
+            await server.close();
+            debug("Server closed");
+        }
+    }
+    finally {
+        debug("Closing inspector servers...");
+        await tmpWorkerPath.cleanup();
+        debug("Temporary files cleaned up");
+    }
+    // todo(justinvdm, 01 Apr 2025): Investigate what handles are remaining open
+    process.exit(0);
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    runWorkerScript(process.argv[2]);
+}

package/dist/vite/aliasByEnvPlugin.d.mts

@@ -0,0 +1,2 @@
+import { Plugin } from "vite";
+export declare const aliasByEnvPlugin: (aliasesByEnv: Record<string, Record<string, string>>) => Plugin;

package/dist/vite/aliasByEnvPlugin.mjs

@@ -0,0 +1,11 @@
+export const aliasByEnvPlugin = (aliasesByEnv) => ({
+    name: "rw-sdk-env-alias",
+    enforce: "pre",
+    resolveId(id, importer) {
+        const aliases = aliasesByEnv[this.environment.name] ?? {};
+        const alias = aliases[id];
+        if (alias) {
+            return alias;
+        }
+    },
+});

package/dist/vite/asyncSetupPlugin.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+export declare const asyncSetupPlugin: ({ setup, }: {
+    setup: ({ command }: {
+        command: "serve" | "build";
+    }) => Promise<unknown>;
+}) => Plugin[];

package/dist/vite/asyncSetupPlugin.mjs

@@ -0,0 +1,23 @@
+export const asyncSetupPlugin = ({ setup, }) => {
+    let taskPromise = Promise.resolve(null);
+    return [
+        {
+            name: "rw-sdk-async-setup:serve",
+            apply: "serve",
+            configureServer(server) {
+                taskPromise = setup({ command: "serve" });
+                server.middlewares.use(async (_req, _res, next) => {
+                    await taskPromise;
+                    next();
+                });
+            },
+        },
+        {
+            name: "rw-sdk-async-setup:build",
+            apply: "build",
+            async buildStart() {
+                await setup({ command: "build" });
+            },
+        },
+    ];
+};

package/dist/vite/checkIsUsingPrisma.d.mts

@@ -0,0 +1,6 @@
+export type PrismaCheckResult = {
+    isUsingPrisma: boolean;
+};
+export declare const checkPrismaStatus: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => PrismaCheckResult;

package/dist/vite/checkIsUsingPrisma.mjs

@@ -0,0 +1,18 @@
+import enhancedResolve from "enhanced-resolve";
+const isUsingPrisma = ({ projectRootDir }) => {
+    try {
+        const prismaClientPath = enhancedResolve.sync(projectRootDir, "@prisma/client");
+        if (!prismaClientPath) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const checkPrismaStatus = ({ projectRootDir, }) => {
+    return {
+        isUsingPrisma: isUsingPrisma({ projectRootDir }),
+    };
+};

package/dist/vite/configPlugin.d.mts

@@ -0,0 +1,9 @@
+import { Plugin } from "vite";
+export declare const cloudflareBuiltInModules: string[];
+export declare const externalModules: string[];
+export declare const configPlugin: ({ silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }: {
+    silent: boolean;
+    projectRootDir: string;
+    clientEntryPathnames: string[];
+    workerEntryPathname: string;
+}) => Plugin;

package/dist/vite/configPlugin.mjs

@@ -0,0 +1,169 @@
+import path, { resolve } from "node:path";
+import { builtinModules } from "node:module";
+import enhancedResolve from "enhanced-resolve";
+import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+// port(justinvdm, 09 Jun 2025):
+// https://github.com/cloudflare/workers-sdk/blob/d533f5ee7da69c205d8d5e2a5f264d2370fc612b/packages/vite-plugin-cloudflare/src/cloudflare-environment.ts#L123-L128
+export const cloudflareBuiltInModules = [
+    "cloudflare:email",
+    "cloudflare:sockets",
+    "cloudflare:workers",
+    "cloudflare:workflows",
+];
+export const externalModules = [
+    ...cloudflareBuiltInModules,
+    ...builtinModules,
+    ...builtinModules.map((m) => `node:${m}`),
+];
+export const configPlugin = ({ silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }) => ({
+    name: "rwsdk:config",
+    config: async (_) => {
+        const mode = process.env.NODE_ENV;
+        const baseConfig = {
+            appType: "custom",
+            mode,
+            logLevel: silent ? "silent" : "info",
+            build: {
+                minify: mode !== "development",
+                sourcemap: true,
+            },
+            define: {
+                "process.env.NODE_ENV": JSON.stringify(mode),
+            },
+            ssr: {
+                target: "webworker",
+            },
+            environments: {
+                client: {
+                    consumer: "client",
+                    build: {
+                        outDir: resolve(projectRootDir, "dist", "client"),
+                        manifest: true,
+                        rollupOptions: {
+                            input: clientEntryPathnames,
+                        },
+                    },
+                    define: {
+                        "import.meta.env.RWSDK_ENV": JSON.stringify("client"),
+                    },
+                    optimizeDeps: {
+                        noDiscovery: false,
+                        include: ["rwsdk/client"],
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
+                        },
+                    },
+                    resolve: {
+                        conditions: ["browser", "module"],
+                    },
+                },
+                ssr: {
+                    resolve: {
+                        conditions: ["workerd", "module", "browser"],
+                        noExternal: true,
+                    },
+                    define: {
+                        "import.meta.env.RWSDK_ENV": JSON.stringify("ssr"),
+                    },
+                    optimizeDeps: {
+                        noDiscovery: false,
+                        entries: [workerEntryPathname],
+                        exclude: externalModules,
+                        include: ["rwsdk/__ssr", "rwsdk/__ssr_bridge"],
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
+                        },
+                    },
+                    build: {
+                        lib: {
+                            entry: {
+                                [path.basename(SSR_BRIDGE_PATH, ".js")]: enhancedResolve.sync(projectRootDir, "rwsdk/__ssr_bridge"),
+                            },
+                            formats: ["es"],
+                            fileName: () => path.basename(SSR_BRIDGE_PATH),
+                        },
+                        outDir: path.dirname(SSR_BRIDGE_PATH),
+                    },
+                },
+                worker: {
+                    resolve: {
+                        conditions: [
+                            "workerd",
+                            "react-server",
+                            "module",
+                            // context(justinvdm, 11 Jun 2025): Some packages meant for cloudflare workers, yet
+                            // their deps have only node import conditions, e.g. `agents` package (meant for CF),
+                            // has `pkce-challenge` package as a dep, which has only node import conditions.
+                            // https://github.com/crouchcd/pkce-challenge/blob/master/package.json#L17
+                            //
+                            // @cloudflare/vite-plugin should take care of any relevant polyfills for deps with
+                            // node builtins imports that can be polyfilled though, so it is worth us including this condition here.
+                            // However, it does mean we will try to run packages meant for node that cannot be run on cloudflare workers.
+                            // That's the trade-off, but arguably worth it.
+                            "node",
+                        ],
+                        noExternal: true,
+                    },
+                    define: {
+                        "import.meta.env.RWSDK_ENV": JSON.stringify("worker"),
+                    },
+                    optimizeDeps: {
+                        noDiscovery: false,
+                        include: ["rwsdk/worker"],
+                        exclude: [],
+                        entries: [workerEntryPathname],
+                        esbuildOptions: {
+                            jsx: "automatic",
+                            jsxImportSource: "react",
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
+                        },
+                    },
+                    build: {
+                        outDir: resolve(projectRootDir, "dist", "worker"),
+                        emitAssets: true,
+                        ssr: true,
+                        rollupOptions: {
+                            output: {
+                                inlineDynamicImports: true,
+                            },
+                            input: {
+                                worker: workerEntryPathname,
+                            },
+                        },
+                    },
+                },
+            },
+            server: {
+                hmr: true,
+            },
+            builder: {
+                buildApp: async (builder) => {
+                    // note(justinvdm, 27 May 2025): **Ordering is important**:
+                    // * When building, client needs to be build first, so that we have a
+                    //   manifest file to map to when looking at asset references in JSX
+                    //   (e.g. Document.tsx)
+                    // * When bundling, the RSC build imports the SSR build - this way
+                    //   they each can have their own environments (e.g. with their own
+                    //   import conditions), while still having all worker-run code go
+                    //   through the processing done by `@cloudflare/vite-plugin`
+                    await builder.build(builder.environments["client"]);
+                    await builder.build(builder.environments["ssr"]);
+                    await builder.build(builder.environments["worker"]);
+                },
+            },
+        };
+        return baseConfig;
+    },
+});

package/dist/vite/copyPrismaWasmPlugin.d.mts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+export declare const copyPrismaWasmPlugin: ({ rootDir, }: {
+    rootDir: string;
+}) => Plugin;

package/dist/vite/copyPrismaWasmPlugin.mjs

@@ -0,0 +1,32 @@
+import { copy, pathExists } from "fs-extra";
+import { resolve } from "node:path";
+import MagicString from "magic-string";
+import path from "path";
+export const copyPrismaWasmPlugin = ({ rootDir, }) => ({
+    name: "rwsdk:copy-prisma-wasm",
+    enforce: "post",
+    apply: "build",
+    async writeBundle() {
+        const wasmFilePath = resolve(rootDir, "node_modules/.prisma/client/query_engine_bg.wasm");
+        const fileName = path.basename(wasmFilePath);
+        const outputPath = path.resolve(rootDir, "dist", "worker", fileName);
+        if (await pathExists(wasmFilePath)) {
+            await copy(wasmFilePath, outputPath);
+            console.log(`✅ Copied ${fileName} from ${wasmFilePath} to ${outputPath}`);
+        }
+    },
+    renderChunk(code) {
+        if (!code.includes(".wasm")) {
+            return;
+        }
+        const s = new MagicString(code);
+        s.replace(/import\(["'](.+?\.wasm)["']\)/g, (_, filePath) => {
+            const fileName = path.basename(filePath);
+            return `import("./${fileName}")`;
+        });
+        return {
+            code: s.toString(),
+            map: s.generateMap(),
+        };
+    },
+});

package/dist/vite/createDirectiveLookupPlugin.d.mts

@@ -0,0 +1,21 @@
+import { Plugin } from "vite";
+interface DirectiveLookupConfig {
+    kind: "client" | "server";
+    directive: "use client" | "use server";
+    virtualModuleName: string;
+    exportName: string;
+    pluginName: string;
+    optimizeForEnvironments?: string[];
+}
+export declare const findFilesContainingDirective: ({ projectRootDir, files, directive, debugNamespace, }: {
+    projectRootDir: string;
+    files: Set<string>;
+    directive: string;
+    debugNamespace: string;
+}) => Promise<void>;
+export declare const createDirectiveLookupPlugin: ({ projectRootDir, files, config, }: {
+    projectRootDir: string;
+    files: Set<string>;
+    config: DirectiveLookupConfig;
+}) => Promise<Plugin>;
+export {};