rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/scripts/ensure-deploy-env.mjs

@@ -0,0 +1,271 @@
+import { $ } from "../lib/$.mjs";
+import { readFile, writeFile } from "fs/promises";
+import { resolve, basename, join } from "path";
+import { randomBytes } from "crypto";
+import { glob } from "glob";
+import { parse as parseJsonc } from "jsonc-parser";
+import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
+import * as readline from "readline";
+import { pathExists } from "fs-extra";
+import { parseJson, extractAllJson } from "../lib/jsonUtils.mjs";
+const promptForDeployment = async () => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        // Handle Ctrl+C (SIGINT)
+        rl.on('SIGINT', () => {
+            rl.close();
+            console.log('\nDeployment cancelled.');
+            process.exit(1);
+        });
+        rl.question("Do you want to proceed with deployment? (y/N): ", (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+};
+const generateSecretKey = () => {
+    return randomBytes(32).toString("base64");
+};
+const hasWebAuthn = async () => {
+    const files = await glob("src/**/*.{ts,tsx}", { ignore: "node_modules/**" });
+    for (const file of files) {
+        const content = await readFile(file, "utf-8");
+        if (content.includes("WEBAUTHN")) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasD1Database = async () => {
+    const files = await glob("src/**/*.{ts,tsx}", { ignore: "node_modules/**" });
+    for (const file of files) {
+        const content = await readFile(file, "utf-8");
+        if (content.includes("env.DB")) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasAuthUsage = async () => {
+    const files = await glob("src/**/*.{ts,tsx}", { ignore: "node_modules/**" });
+    for (const file of files) {
+        const content = await readFile(file, "utf-8");
+        if (content.includes("rwsdk/auth")) {
+            return true;
+        }
+    }
+    return false;
+};
+export const ensureDeployEnv = async () => {
+    const shouldDeploy = await promptForDeployment();
+    if (!shouldDeploy) {
+        console.log("Deployment cancelled.");
+        process.exit(1);
+    }
+    console.log("Ensuring deployment environment is ready...");
+    const pkg = JSON.parse(await readFile(resolve(process.cwd(), "package.json"), "utf-8"));
+    // Read wrangler config
+    const wranglerPath = resolve(process.cwd(), "wrangler.jsonc");
+    const wranglerConfig = parseJsonc(await readFile(wranglerPath, "utf-8"));
+    // Update wrangler name if needed
+    if (wranglerConfig.name === "__change_me__" ||
+        process.env.RWSDK_RENAME_WORKER === "1") {
+        const dirName = basename(process.cwd());
+        wranglerConfig.name = dirName;
+        console.log(`Set wrangler name to ${dirName}`);
+        await writeFile(wranglerPath, JSON.stringify(wranglerConfig, null, 2));
+        console.log("Updated wrangler.jsonc configuration");
+    }
+    if (process.env.CLOUDFLARE_ACCOUNT_ID == null ||
+        process.env.CLOUDFLARE_API_TOKEN == null) {
+        // Trigger account selection prompt if needed
+        console.log("Checking Cloudflare account setup...");
+        const accountCachePath = join(process.cwd(), "node_modules/.cache/wrangler/wrangler-account.json");
+        // todo(justinvdm): this is a hack to force the account selection prompt,
+        // we need to find a better way
+        if (!(await pathExists(accountCachePath))) {
+            await $({ stdio: "inherit" }) `npx wrangler d1 list --json`;
+        }
+    }
+    // Create a no-op secret to ensure worker exists
+    console.log(`Ensuring worker ${wranglerConfig.name} exists...`);
+    await $({ stdio: "pipe" }) `echo "true"`
+        .pipe `npx wrangler secret put TMP_WORKER_CREATED`;
+    // Check D1 database setup
+    const needsDatabase = await hasD1Database();
+    if (!needsDatabase) {
+        console.log("Skipping D1 setup - no env.DB usage detected in codebase");
+    }
+    else {
+        console.log("Found env.DB usage, checking D1 database setup...");
+        try {
+            const existingDb = wranglerConfig.d1_databases?.find((db) => db.binding === "DB");
+            if (existingDb &&
+                existingDb.database_id !== "__change_me__" &&
+                process.env.RWSDK_RENAME_DB !== "1") {
+                console.log("D1 database already configured in wrangler.jsonc, skipping creation");
+            }
+            else {
+                const suffix = uniqueNamesGenerator({
+                    dictionaries: [adjectives, animals],
+                    separator: "-",
+                    length: 2,
+                    style: "lowerCase",
+                });
+                const dbName = `${wranglerConfig.name}-${suffix}`;
+                try {
+                    // Create the database with real-time output so the user can see progress
+                    console.log(`Creating D1 database: ${dbName}...`);
+                    const createResult = await $({
+                        stdio: "pipe",
+                    }) `npx wrangler d1 create ${dbName}`;
+                    // Log the result to the console
+                    console.log(createResult.stdout);
+                    // Parse all JSON objects from the output
+                    const allJsonObjects = extractAllJson(createResult.stdout);
+                    // First look for object with uuid directly
+                    let dbInfo = { uuid: undefined, name: undefined };
+                    for (const obj of allJsonObjects) {
+                        if (obj && obj.uuid) {
+                            dbInfo = obj;
+                            break;
+                        }
+                    }
+                    // If not found, look for the d1_databases structure
+                    if (!dbInfo.uuid) {
+                        for (const obj of allJsonObjects) {
+                            if (obj && obj.d1_databases && Array.isArray(obj.d1_databases)) {
+                                const dbConfig = obj.d1_databases.find((db) => db.binding === "DB" || db.database_name === dbName);
+                                if (dbConfig && dbConfig.database_id) {
+                                    dbInfo.uuid = dbConfig.database_id;
+                                    dbInfo.name = dbConfig.database_name || dbName;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!dbInfo.uuid) {
+                        throw new Error("Failed to extract database ID from wrangler output");
+                    }
+                    // Update wrangler config with database info, preserving other databases
+                    const existingDatabases = wranglerConfig.d1_databases || [];
+                    wranglerConfig.d1_databases = [
+                        ...existingDatabases.filter((db) => db.binding !== "DB"),
+                        {
+                            binding: "DB",
+                            database_name: dbName,
+                            database_id: dbInfo.uuid,
+                        },
+                    ];
+                    await writeFile(wranglerPath, JSON.stringify(wranglerConfig, null, 2));
+                    console.log("Updated wrangler.jsonc configuration");
+                    console.log(`D1 database configured: ${dbName} with ID: ${dbInfo.uuid}`);
+                }
+                catch (error) {
+                    console.error("Failed to create D1 database:", error instanceof Error ? error.message : String(error));
+                    console.error("Please create it manually:");
+                    console.error("1. Run: npx wrangler d1 create <your-db-name>");
+                    console.error("2. Update wrangler.jsonc with the database details");
+                    process.exit(1);
+                }
+            }
+        }
+        catch (error) {
+            console.error("Failed to create D1 database. Please create it manually:");
+            console.error("1. Run: npx wrangler d1 create <your-db-name>");
+            console.error("2. Update wrangler.jsonc with the database details");
+            process.exit(1);
+        }
+    }
+    // Check AUTH_SECRET_KEY setup
+    if (!(await hasAuthUsage())) {
+        console.log("Skipping AUTH_SECRET_KEY setup - no auth usage detected in codebase");
+    }
+    else {
+        console.log("Found auth usage, checking secret setup...");
+        try {
+            // Get list of all secrets
+            const secretsResult = await $ `npx wrangler secret list --format=json`;
+            const existingSecrets = parseJson(secretsResult.stdout, []).map((secret) => secret.name);
+            // Check if AUTH_SECRET_KEY already exists
+            if (existingSecrets.includes("AUTH_SECRET_KEY")) {
+                console.log("AUTH_SECRET_KEY secret already exists in Cloudflare, skipping");
+            }
+            else {
+                // Secret doesn't exist, create it
+                const secretKey = generateSecretKey();
+                // Use the same pattern as TMP_WORKER_CREATED for consistency
+                await $({ stdio: "pipe" }) `echo "${secretKey}"`
+                    .pipe `npx wrangler secret put AUTH_SECRET_KEY`;
+                console.log("Set AUTH_SECRET_KEY secret");
+            }
+        }
+        catch (error) {
+            console.error("Failed to set up AUTH_SECRET_KEY. Please configure it manually:");
+            console.error("1. Generate a secret key: node -e \"console.log(require('crypto').randomBytes(32).toString('base64'))\"");
+            console.error("2. Set the secret: npx wrangler secret put AUTH_SECRET_KEY");
+            process.exit(1);
+        }
+    }
+    // Check WebAuthn setup
+    const needsWebAuthn = await hasWebAuthn();
+    if (!needsWebAuthn) {
+        console.log("Skipping WebAuthn setup - no WEBAUTHN usage detected in codebase");
+    }
+    else {
+        console.log("Found WEBAUTHN usage, checking WebAuthn setup...");
+        try {
+            wranglerConfig.vars = wranglerConfig.vars || {};
+            if (wranglerConfig.vars.WEBAUTHN_APP_NAME === wranglerConfig.name) {
+                console.log(`WEBAUTHN_APP_NAME already set to "${wranglerConfig.name}" in wrangler.jsonc`);
+            }
+            else {
+                wranglerConfig.vars.WEBAUTHN_APP_NAME = wranglerConfig.name;
+                await writeFile(wranglerPath, JSON.stringify(wranglerConfig, null, 2));
+                console.log("Updated wrangler.jsonc configuration");
+                console.log(`Set WEBAUTHN_APP_NAME to ${wranglerConfig.name}`);
+            }
+        }
+        catch (error) {
+            console.error("Failed to set up WebAuthn. Please configure it manually:");
+            console.error("Add to wrangler.jsonc vars:");
+            console.error(`   "vars": { "WEBAUTHN_APP_NAME": "${wranglerConfig.name}" }`);
+            process.exit(1);
+        }
+    }
+    if (pkg.scripts?.["migrate:prd"]) {
+        console.log("Checking migration status...");
+        try {
+            // Get the database name from wrangler config
+            const dbConfig = wranglerConfig.d1_databases?.find((db) => db.binding === "DB");
+            if (!dbConfig) {
+                throw new Error("No D1 database configuration found in wrangler.jsonc");
+            }
+            // Check remote migrations status
+            const migrationStatus = await $ `npx wrangler d1 migrations list ${dbConfig.database_name} --remote`;
+            // If stdout includes "No migrations found", this is a fresh database
+            if (migrationStatus.stdout?.includes("No migrations present")) {
+                console.log("No migrations found.");
+            }
+            else if (migrationStatus.stdout?.includes("Migrations to be applied")) {
+                await $({ stdio: "inherit" }) `npm run migrate:prd`;
+            }
+            else {
+                console.log("Migrations are up to date.");
+            }
+        }
+        catch (error) {
+            console.error("\n❌ Error checking migration status:");
+            console.error(error);
+            process.exit(1);
+        }
+    }
+    console.log("\nDeployment initialization complete!");
+    process.exit(0);
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    ensureDeployEnv();
+}

package/dist/scripts/ensure-env.d.mts

@@ -0,0 +1 @@
+export declare const ensureEnv: () => Promise<void>;

package/dist/scripts/ensure-env.mjs

@@ -0,0 +1,9 @@
+import { setupEnvFiles } from "../lib/setupEnvFiles.mjs";
+export const ensureEnv = async () => {
+    await setupEnvFiles({
+        rootDir: process.cwd(),
+    });
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    ensureEnv();
+}

package/dist/scripts/migrate-new.d.mts

@@ -0,0 +1 @@
+export declare const migrateNew: (name: string, skipApply?: boolean) => Promise<void>;

package/dist/scripts/migrate-new.mjs

@@ -0,0 +1,51 @@
+import snakeCase from "lodash/snakeCase.js";
+import { $ } from "../lib/$.mjs";
+import { readdir } from "fs/promises";
+import { resolve } from "path";
+import { mkdirp } from "fs-extra";
+import { writeFile } from "fs/promises";
+const getNextMigrationNumber = async () => {
+    await mkdirp(resolve(process.cwd(), "./migrations"));
+    const files = await readdir(resolve(process.cwd(), "./migrations"));
+    const numbers = files
+        .map((file) => parseInt(file.split("_")[0]))
+        .filter((num) => !isNaN(num));
+    const lastNumber = Math.max(0, ...numbers);
+    return String(lastNumber + 1).padStart(4, "0");
+};
+export const migrateNew = async (name, skipApply = false) => {
+    if (!name) {
+        console.log("Usage: npm run migrate:new <migration-name> [--no-apply]");
+        console.log("Example: npm run migrate:new add a user");
+        process.exit(1);
+    }
+    const nextNum = await getNextMigrationNumber();
+    const filepath = `./migrations/${nextNum}_${snakeCase(name.toLowerCase())}.sql`;
+    const raw = await $ `npx prisma migrate diff --from-local-d1 --to-schema-datamodel ./prisma/schema.prisma --script`;
+    const cleaned = raw.stdout
+        ?.split("\n")
+        .filter((line) => !line.includes("_cf_METADATA") && !line.includes("_cf_metadata"))
+        .join("\n");
+    if (!cleaned) {
+        console.error("No changes to apply");
+        process.exitCode = 1;
+        return;
+    }
+    await writeFile(filepath, cleaned);
+    console.log("Generated migration:", filepath);
+    if (!skipApply) {
+        console.log("Applying migration in development...");
+        await $ `npm run migrate:dev`;
+        console.log("Generating Prisma Client");
+        await $ `npx prisma generate`;
+    }
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    const args = process.argv.slice(2);
+    // Separate flags from other arguments
+    const flags = new Set(args.filter((arg) => arg.startsWith("--")));
+    const nonFlags = args.filter((arg) => !arg.startsWith("--"));
+    const skipApply = flags.has("--no-apply");
+    const name = nonFlags.join("_").toLocaleLowerCase();
+    migrateNew(name, skipApply);
+}

package/dist/scripts/smoke-test.d.mts

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

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/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;