@cedarjs/cli 4.1.1-next.14 → 4.1.1-next.64

package/dist/commands/build/buildHandler.js

@@ -11,6 +11,7 @@ import {
 } from "@cedarjs/cli-helpers/packageManager/display";
 import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
 import {
+  buildApi,
   buildApiWithVite,
   cleanApiBuild
 } from "@cedarjs/internal/dist/build/api";
@@ -20,6 +21,7 @@ import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
 import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
 import {} from "@cedarjs/project-config";
 import { timedTelemetry } from "@cedarjs/telemetry";
+import { buildCedarApp } from "@cedarjs/vite/build";
 import { buildUDApiServer } from "@cedarjs/vite/buildUDApiServer";
 import { generatePrismaCommand } from "../../lib/generatePrismaClient.js";
 import { getPaths, getConfig } from "../../lib/index.js";
@@ -163,25 +165,59 @@ Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspac
       title: "Verifying graphql schema...",
       task: loadAndValidateSdls
     },
-    // The API build has two sequential steps:
-    // 1. esbuild compiles api/src/** → api/dist/ (functions, services, etc.)
-    // 2. Vite wraps api/dist/functions/ into a self-contained UD Node server
-    //    entry at api/dist/ud/index.js for `cedar serve api`
-    // Step 2 depends on step 1 having completed.
-    workspace.includes("api") && {
+    // When streaming SSR is enabled, fall back to the legacy separate build
+    // paths because streaming SSR has its own complex build orchestration.
+    // Phase 7 (SSR/RSC rebuild) will address unifying this path.
+    workspace.includes("api") && getConfig().experimental?.streamingSsr?.enabled && {
       title: "Building API...",
       task: async () => {
         await cleanApiBuild();
         await buildApiWithVite();
       }
     },
-    ud && workspace.includes("api") && {
-      title: "Bundling API server entry (Universal Deploy)...",
+    workspace.includes("web") && getConfig().experimental?.streamingSsr?.enabled && {
+      title: "Building Web...",
       task: async () => {
-        await buildUDApiServer({ verbose });
+        process.env.VITE_CJS_IGNORE_WARNING = "true";
+        const createdRequire = createRequire(import.meta.url);
+        const buildBinPath = createdRequire.resolve(
+          "@cedarjs/vite/bins/cedar-vite-build.mjs"
+        );
+        await execa(
+          `node ${buildBinPath} --webDir="${cedarPaths.web.base}" --verbose=${verbose}`,
+          {
+            stdio: verbose ? "inherit" : "pipe",
+            shell: true,
+            cwd: cedarPaths.web.base
+          }
+        );
+        if (!getConfig().experimental?.streamingSsr?.enabled) {
+          console.log("Creating 200.html...");
+          const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
+          fs.copyFileSync(
+            indexHtmlPath,
+            path.join(getPaths().web.dist, "200.html")
+          );
+        }
+      }
+    },
+    // Legacy separate build path (default when not --ud, non-streaming-SSR)
+    workspace.includes("api") && !ud && !getConfig().experimental?.streamingSsr?.enabled && {
+      title: "Building API...",
+      task: async () => {
+        await cleanApiBuild();
+        const { errors, warnings } = await buildApi();
+        if (warnings.length) {
+          console.warn(warnings);
+        }
+        if (errors.length) {
+          throw new Error(
+            `API build failed with ${errors.length} error(s). See output above for details.`
+          );
+        }
       }
     },
-    workspace.includes("web") && {
+    workspace.includes("web") && !ud && !getConfig().experimental?.streamingSsr?.enabled && {
       title: "Building Web...",
       task: async () => {
         process.env.VITE_CJS_IGNORE_WARNING = "true";
@@ -200,7 +236,30 @@ Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspac
             cwd: cedarPaths.web.base
           }
         );
-        if (!getConfig().experimental?.streamingSsr?.enabled) {
+        console.log("Creating 200.html...");
+        const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
+        fs.copyFileSync(
+          indexHtmlPath,
+          path.join(getPaths().web.dist, "200.html")
+        );
+      }
+    },
+    // Unified build path (experimental, non-streaming-SSR, --ud)
+    (workspace.includes("api") || workspace.includes("web")) && ud && !getConfig().experimental?.streamingSsr?.enabled && {
+      title: workspace.includes("api") && workspace.includes("web") ? "Building App..." : workspace.includes("api") ? "Building API..." : "Building Web...",
+      task: async () => {
+        process.env.VITE_CJS_IGNORE_WARNING = "true";
+        if (workspace.includes("api")) {
+          await cleanApiBuild();
+        }
+        const originalCwd = process.cwd();
+        process.chdir(cedarPaths.web.base);
+        try {
+          await buildCedarApp({ verbose, workspace });
+        } finally {
+          process.chdir(originalCwd);
+        }
+        if (workspace.includes("web")) {
           console.log("Creating 200.html...");
           const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
           fs.copyFileSync(
@@ -209,6 +268,12 @@ Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspac
           );
         }
       }
+    },
+    ud && workspace.includes("api") && {
+      title: "Bundling API server entry (Universal Deploy)...",
+      task: async () => {
+        await buildUDApiServer({ verbose });
+      }
     }
   ].filter((t) => Boolean(t));
   const triggerPrerender = async () => {

package/dist/commands/dev/devHandler.js

@@ -68,27 +68,64 @@ const handler = async ({
     }
     webPortChangeNeeded = webAvailablePort !== webPreferredPort;
   }
-  if (webPortChangeNeeded) {
-    const message = [
-      "The currently configured port for the development server is",
-      "unavailable. Suggested change to your port, which can be changed in",
-      "cedar.toml (or redwood.toml):\n",
-      ` - Web to use port ${webAvailablePort} instead`,
-      "of your currently configured",
-      `${webPreferredPort}
+  if (ud) {
+    if (webPortChangeNeeded) {
+      const message = [
+        "The currently configured port for the development server is",
+        "unavailable. Suggested change to your port, which can be changed in",
+        "cedar.toml (or redwood.toml):\n",
+        ` - Web to use port ${webAvailablePort} instead`,
+        "of your currently configured",
+        `${webPreferredPort}
 `,
-      "\nCannot run the development server until your configured port is",
-      "changed or becomes available."
-    ].filter(Boolean).join(" ");
-    exitWithError(void 0, { message });
+        "\nCannot run the development server until your configured port is",
+        "changed or becomes available."
+      ].filter(Boolean).join(" ");
+      exitWithError(void 0, { message });
+    }
+  } else {
+    if (apiPortChangeNeeded || webPortChangeNeeded) {
+      const message = [
+        "The currently configured ports for the development server are",
+        "unavailable. Suggested changes to your ports, which can be changed in",
+        "cedar.toml (or redwood.toml), are:\n",
+        apiPortChangeNeeded && ` - API to use port ${apiAvailablePort} instead`,
+        apiPortChangeNeeded && "of your currently configured",
+        apiPortChangeNeeded && `${apiPreferredPort}
+`,
+        webPortChangeNeeded && ` - Web to use port ${webAvailablePort} instead`,
+        webPortChangeNeeded && "of your currently configured",
+        webPortChangeNeeded && `${webPreferredPort}
+`,
+        "\nCannot run the development server until your configured ports are",
+        "changed or become available."
+      ].filter(Boolean).join(" ");
+      exitWithError(void 0, { message });
+    }
   }
   if (workspace.includes("api")) {
-    try {
-      await generatePrismaClient({ verbose: false, force: false });
-    } catch (e) {
-      const message = getErrorMessage(e);
-      errorTelemetry(process.argv, `Error generating prisma client: ${message}`);
-      console.error(c.error(message));
+    if (generate) {
+      try {
+        await generatePrismaClient({ verbose: false });
+      } catch (e) {
+        const message = getErrorMessage(e);
+        errorTelemetry(
+          process.argv,
+          `Error generating prisma client: ${message}`
+        );
+        console.error(c.error(message));
+      }
+    }
+    if (!ud && !serverFile) {
+      try {
+        await shutdownPort(apiAvailablePort);
+      } catch (e) {
+        const message = getErrorMessage(e);
+        errorTelemetry(process.argv, `Error shutting down "api": ${message}`);
+        console.error(
+          `Error whilst shutting down "api" port: ${c.error(message)}`
+        );
+      }
     }
   }
   if (workspace.includes("web") && webAvailablePort !== void 0) {

package/dist/commands/execHandler.js

@@ -65,7 +65,6 @@ No script called \`${name}\` in the ./scripts folder.
       title: "Generating Prisma client",
       enabled: () => !!prisma,
       task: () => generatePrismaClient({
-        force: false,
         verbose: !args.silent,
         silent: !!args.silent
       })

package/dist/commands/serve.js

@@ -1,5 +1,6 @@
 import { fork } from "node:child_process";
 import fs from "node:fs";
+import net from "node:net";
 import path from "node:path";
 import { terminalLink } from "termi-link";
 import * as apiServerCLIConfig from "@cedarjs/api-server/apiCliConfig";
@@ -18,7 +19,14 @@ const builder = async (yargs) => {
   yargs.command({
     command: "$0",
     description: bothServerCLIConfig.description,
-    builder: bothServerCLIConfig.builder,
+    builder: (yargs2) => {
+      bothServerCLIConfig.builder(yargs2);
+      return yargs2.option("ud", {
+        description: "Use the Universal Deploy server for the API side. The web side is served by the existing static file server. Pass --ud to opt in; the default is Fastify for both sides.",
+        type: "boolean",
+        default: false
+      });
+    },
     handler: async (argv) => {
       recordTelemetryAttributes({
         command: "serve",
@@ -26,6 +34,110 @@ const builder = async (yargs) => {
         host: argv.host,
         socket: argv.socket
       });
+      if (argv.ud) {
+        if (argv.port) {
+          console.error(
+            c.error(
+              "\n The --port flag is not supported with --ud. Use --web-port and --api-port instead.\n"
+            )
+          );
+          process.exit(1);
+        }
+        const udEntryPath = path.join(getPaths().api.dist, "ud", "index.js");
+        if (!fs.existsSync(udEntryPath)) {
+          console.error(
+            c.error(
+              `
+ Universal Deploy server entry not found at ${udEntryPath}.
+ Please run \`yarn cedar build --ud\` before serving.
+`
+            )
+          );
+          process.exit(1);
+        }
+        const webDistIndexHtml = path.join(getPaths().web.dist, "index.html");
+        if (!fs.existsSync(webDistIndexHtml)) {
+          console.error(
+            c.error(
+              "\n Web build artifacts not found.\n Please run `yarn cedar build` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+        if (serverFileExists()) {
+          console.warn(
+            c.warning(
+              "\n Note: api/src/server.ts was detected. This file is a Fastify concept and will be ignored when using --ud. You are testing the experimental UD support, so the behavior will not match your production Fastify setup.\n"
+            )
+          );
+        }
+        const { getAPIHost, getAPIPort, getWebHost, getWebPort } = await import("@cedarjs/api-server/cliHelpers");
+        const apiPort = argv.apiPort ?? getAPIPort();
+        const apiHost = argv.apiHost ?? getAPIHost();
+        const webPort = argv.webPort ?? getWebPort();
+        const webHost = argv.webHost ?? getWebHost();
+        const apiRootPath = argv.apiRootPath ?? "/";
+        const apiProxyTarget = [
+          "http://",
+          apiHost.includes(":") ? `[${apiHost}]` : apiHost,
+          ":",
+          apiPort,
+          apiRootPath
+        ].join("");
+        const { redwoodFastifyWeb } = await import("@cedarjs/fastify-web");
+        const { createFastifyInstance } = await import("@cedarjs/api-server/fastify");
+        const webFastify = await createFastifyInstance();
+        webFastify.register(redwoodFastifyWeb, {
+          redwood: {
+            apiProxyTarget
+          }
+        });
+        await webFastify.listen({
+          port: webPort,
+          host: webHost
+        });
+        const child = fork(
+          udEntryPath,
+          ["--port", String(apiPort), "--host", apiHost],
+          {
+            execArgv: process.execArgv,
+            env: {
+              ...process.env,
+              NODE_ENV: process.env.NODE_ENV ?? "production",
+              PORT: String(apiPort),
+              HOST: apiHost
+            }
+          }
+        );
+        child.on("error", (err) => {
+          console.error(
+            c.error(`
+ Failed to start UD API server: ${err.message}
+`)
+          );
+          process.exit(1);
+        });
+        child.on("exit", (code) => {
+          if (code !== 0) {
+            console.error(
+              c.error(`
+ UD API server exited with code ${code}
+`)
+            );
+            process.exit(1);
+          }
+        });
+        console.log(`Web server listening at http://${webHost}:${webPort}`);
+        process.stdout.write(
+          `API server starting at http://${apiHost}:${apiPort}...`
+        );
+        await waitForPort(apiHost, apiPort);
+        process.stdout.write(
+          `\rAPI server listening at http://${apiHost}:${apiPort}
+`
+        );
+        return;
+      }
       if (serverFileExists()) {
         const serveBothHandlers = await import("./serveBothHandler.js");
         await serveBothHandlers.bothServerFileHandler(argv);
@@ -51,7 +163,7 @@ const builder = async (yargs) => {
       return yargs2.option("ud", {
         // UD serving is opt-in. Pass --ud to use the new srvx server instead
         // of the legacy Fastify server.
-        description: "Use the Universal Deploy server (srvx). Pass --ud to opt in; the default is Fastify.",
+        description: "Use the Universal Deploy server. Pass --ud to opt in; the default is Fastify.",
         type: "boolean",
         default: false
       });
@@ -71,7 +183,7 @@ const builder = async (yargs) => {
             c.error(
               `
  Universal Deploy server entry not found at ${udEntryPath}.
- Please run \`yarn cedar build api\` before serving.
+ Please run \`yarn cedar build --ud\` before serving.
 `
             )
           );
@@ -84,17 +196,34 @@ const builder = async (yargs) => {
         if (argv.host) {
           udArgs.push("--host", argv.host);
         }
+        const child = fork(udEntryPath, udArgs, {
+          execArgv: process.execArgv,
+          env: {
+            ...process.env,
+            NODE_ENV: process.env.NODE_ENV ?? "production",
+            PORT: argv.port ? String(argv.port) : process.env.PORT,
+            HOST: argv.host ?? process.env.HOST
+          }
+        });
+        child.on("error", (err) => {
+          console.error(
+            c.error(`
+ Failed to start UD server: ${err.message}
+`)
+          );
+          process.exit(1);
+        });
+        const apiPort = argv.port ?? parseInt(process.env.PORT ?? "8911", 10);
+        const apiHost = argv.host ?? process.env.HOST ?? "localhost";
+        process.stdout.write(
+          `API server starting at http://${apiHost}:${apiPort}...`
+        );
+        await waitForPort(apiHost, apiPort);
+        process.stdout.write(
+          `\rAPI server listening at http://${apiHost}:${apiPort}
+`
+        );
         await new Promise((resolve, reject) => {
-          const child = fork(udEntryPath, udArgs, {
-            execArgv: process.execArgv,
-            env: {
-              ...process.env,
-              NODE_ENV: process.env.NODE_ENV ?? "production",
-              PORT: argv.port ? String(argv.port) : process.env.PORT,
-              HOST: argv.host ?? process.env.HOST
-            }
-          });
-          child.on("error", reject);
           child.on("exit", (code) => {
             if (code !== 0) {
               reject(new Error(`UD server exited with code ${code}`));
@@ -166,6 +295,20 @@ const builder = async (yargs) => {
         );
         process.exit(1);
       }
+      if (argv.ud) {
+        const udEntryPath = path.join(getPaths().api.dist, "ud", "index.js");
+        if (!fs.existsSync(udEntryPath)) {
+          console.error(
+            c.error(
+              `
+ Universal Deploy server entry not found at ${udEntryPath}.
+ Please run \`yarn cedar build --ud\` before serving.
+`
+            )
+          );
+          process.exit(1);
+        }
+      }
     }
     if (positionalArgs.length === 1) {
       if (!apiSideExists && !rscEnabled) {
@@ -176,14 +319,38 @@ const builder = async (yargs) => {
         );
         process.exit(1);
       }
-      const apiExistsButIsNotBuilt = apiSideExists && !fs.existsSync(getPaths().api.dist);
-      if (apiExistsButIsNotBuilt || !webSideIsBuilt(streamingEnabled || rscEnabled)) {
-        console.error(
-          c.error(
-            "\nPlease run `yarn cedar build` before trying to serve your Cedar app.\n"
-          )
-        );
-        process.exit(1);
+      if (argv.ud) {
+        const udEntryPath = path.join(getPaths().api.dist, "ud", "index.js");
+        if (!fs.existsSync(udEntryPath)) {
+          console.error(
+            c.error(
+              `
+ Universal Deploy server entry not found at ${udEntryPath}.
+ Please run \`yarn cedar build --ud\` before serving.
+`
+            )
+          );
+          process.exit(1);
+        }
+        const webDistIndexHtml = path.join(getPaths().web.dist, "index.html");
+        if (!fs.existsSync(webDistIndexHtml)) {
+          console.error(
+            c.error(
+              "\n Web build artifacts not found.\n Please run `yarn cedar build` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+      } else {
+        const apiExistsButIsNotBuilt = apiSideExists && !fs.existsSync(getPaths().api.dist);
+        if (apiExistsButIsNotBuilt || !webSideIsBuilt(streamingEnabled || rscEnabled)) {
+          console.error(
+            c.error(
+              "\nPlease run `yarn cedar build` before trying to serve your Cedar app.\n"
+            )
+          );
+          process.exit(1);
+        }
       }
     }
     if (!process.env.NODE_ENV) {
@@ -205,6 +372,34 @@ function webSideIsBuilt(isStreamingOrRSC) {
     return fs.existsSync(path.join(getPaths().web.dist, "index.html"));
   }
 }
+function waitForPort(host, port) {
+  const maxAttempts = 50;
+  const intervalMs = 200;
+  return new Promise((resolve, reject) => {
+    let attempts = 0;
+    const tryConnect = () => {
+      attempts++;
+      const socket = net.createConnection({ host, port });
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve();
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        if (attempts >= maxAttempts) {
+          reject(
+            new Error(
+              `API server did not become ready on port ${port} after ${maxAttempts * intervalMs}ms`
+            )
+          );
+        } else {
+          setTimeout(tryConnect, intervalMs);
+        }
+      });
+    };
+    tryConnect();
+  });
+}
 export {
   builder,
   command,

package/dist/commands/setup/neon/neon.js

@@ -0,0 +1,25 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "neon";
+const description = "Provision a Neon Postgres database and configure your project";
+function builder(yargs) {
+  return yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing DATABASE_URL in .env",
+    type: "boolean"
+  });
+}
+async function handler({ force }) {
+  recordTelemetryAttributes({
+    command: "setup neon",
+    force
+  });
+  const { handler: handler2 } = await import("./neonHandler.js");
+  return handler2({ force });
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/neon/neonHandler.js

@@ -0,0 +1,385 @@
+import fs from "node:fs";
+import path from "node:path";
+import execa from "execa";
+import { Listr } from "listr2";
+import { colors, getPaths, installPackages } from "@cedarjs/cli-helpers";
+import { addWorkspacePackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { errorTelemetry } from "@cedarjs/telemetry";
+const cedarPaths = getPaths();
+async function handler({ force }) {
+  const schemaPath = path.join(cedarPaths.api.base, "db", "schema.prisma");
+  const dbTsPath = path.join(cedarPaths.api.src, "lib", "db.ts");
+  const prismaConfigPathCjs = path.join(
+    cedarPaths.api.base,
+    "prisma.config.cjs"
+  );
+  const prismaConfigPathMts = path.join(
+    cedarPaths.api.base,
+    "prisma.config.mts"
+  );
+  const envPath = path.join(cedarPaths.base, ".env");
+  const rootPkgPath = path.join(cedarPaths.base, "package.json");
+  const apiPkgPath = path.join(cedarPaths.api.base, "package.json");
+  const dbTsTemplatePath = path.join(
+    import.meta.dirname,
+    "templates",
+    "db.ts.template"
+  );
+  let hasDirectDatabaseUrl = false;
+  if (fs.existsSync(envPath)) {
+    hasDirectDatabaseUrl = /^DATABASE_URL=/m.test(
+      fs.readFileSync(envPath, "utf-8")
+    );
+  }
+  const notes = [];
+  const tasks = new Listr(
+    [
+      {
+        title: "Checking current database configuration",
+        task: (ctx) => {
+          const schemaContent = fs.readFileSync(schemaPath, "utf-8");
+          ctx.schemaContent = schemaContent;
+          ctx.isSqlite = schemaContent.includes('provider = "sqlite"');
+          ctx.isPostgres = schemaContent.includes('provider = "postgresql"');
+          if (fs.existsSync(dbTsPath)) {
+            ctx.dbTsContent = fs.readFileSync(dbTsPath, "utf-8");
+            ctx.isNeon = ctx.dbTsContent.includes("PrismaPg");
+          } else {
+            ctx.isNeon = false;
+          }
+          if (!ctx.isSqlite && !ctx.isPostgres) {
+            ctx.unsupportedProvider = true;
+            notes.push(
+              colors.note(
+                "setup neon only supports migrating from SQLite to PostgreSQL. Your project uses a different database provider."
+              )
+            );
+            return;
+          }
+          if (!ctx.isPostgres) {
+            ctx.hasSqliteUsageOutsideDb = hasSqliteUsageOutsideDb(
+              cedarPaths.api.src,
+              dbTsPath
+            );
+          }
+          if (hasDirectDatabaseUrl && !force) {
+            ctx.skipWithNote = true;
+            notes.push(
+              colors.note(
+                "DATABASE_URL is already set in .env. Use --force to overwrite."
+              )
+            );
+          }
+        }
+      },
+      {
+        title: "Removing SQLite dependencies from api/package.json",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isPostgres) {
+            return "Already configured for PostgreSQL";
+          }
+          if (ctx.hasSqliteUsageOutsideDb) {
+            return "SQLite is in use outside db.ts \u2014 keeping packages";
+          }
+          return false;
+        },
+        task: () => {
+          const pkg = JSON.parse(fs.readFileSync(apiPkgPath, "utf-8"));
+          if (pkg.dependencies) {
+            delete pkg.dependencies["better-sqlite3"];
+            delete pkg.dependencies["@prisma/adapter-better-sqlite3"];
+          }
+          fs.writeFileSync(apiPkgPath, JSON.stringify(pkg, null, 2) + "\n");
+        }
+      },
+      {
+        title: "Removing better-sqlite3 dependenciesMeta",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isPostgres) {
+            return "Already configured for PostgreSQL";
+          }
+          if (ctx.hasSqliteUsageOutsideDb) {
+            return "SQLite is in use outside db.ts so we're keeping it installed";
+          }
+          return false;
+        },
+        task: () => {
+          if (!fs.existsSync(rootPkgPath)) {
+            return;
+          }
+          const pkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
+          if (pkg.dependenciesMeta?.["better-sqlite3"]) {
+            delete pkg.dependenciesMeta["better-sqlite3"];
+            if (Object.keys(pkg.dependenciesMeta).length === 0) {
+              delete pkg.dependenciesMeta;
+            }
+            fs.writeFileSync(rootPkgPath, JSON.stringify(pkg, null, 2) + "\n");
+          }
+        }
+      },
+      {
+        title: "Switching Prisma schema to PostgreSQL",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isPostgres) {
+            return "Schema is already configured for PostgreSQL";
+          }
+          return false;
+        },
+        task: (ctx) => {
+          const updated = ctx.schemaContent.replace(
+            'provider = "sqlite"',
+            'provider = "postgresql"'
+          );
+          fs.writeFileSync(schemaPath, updated);
+        }
+      },
+      {
+        title: "Updating database adapter",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isNeon) {
+            return "Database adapter is already configured for Neon (PrismaPg)";
+          }
+          if (ctx.skipWithNote) {
+            return "DATABASE_URL already configured \u2014 skipping adapter update";
+          }
+          return false;
+        },
+        task: () => {
+          const neonDbTs = fs.readFileSync(dbTsTemplatePath, "utf-8");
+          fs.writeFileSync(dbTsPath, neonDbTs);
+        }
+      },
+      {
+        title: "Updating Prisma config",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isNeon) {
+            return "Prisma config is already configured for Neon";
+          }
+          if (ctx.skipWithNote) {
+            return "DATABASE_URL already configured \u2014 skipping config update";
+          }
+          return false;
+        },
+        task: () => {
+          if (!fs.existsSync(prismaConfigPathCjs) && !fs.existsSync(prismaConfigPathMts)) {
+            throw new Error(
+              "No Prisma config file found. Expected prisma.config.cjs or prisma.config.mts in the api directory."
+            );
+          }
+          const configPath = fs.existsSync(prismaConfigPathCjs) ? prismaConfigPathCjs : prismaConfigPathMts;
+          const configContent = fs.readFileSync(configPath, "utf-8");
+          const updated = configContent.replace(
+            /env\(["']DATABASE_URL["']\)/,
+            "env('DIRECT_DATABASE_URL')"
+          );
+          fs.writeFileSync(configPath, updated);
+        }
+      },
+      {
+        title: "Adding required api packages...",
+        skip: (ctx) => ctx.unsupportedProvider,
+        task: async () => {
+          await addWorkspacePackages("api", ["@prisma/adapter-pg@7.8.0"], {
+            cwd: cedarPaths.api.base
+          });
+        }
+      },
+      {
+        title: "Provisioning Neon database",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return true;
+          }
+          if (hasDirectDatabaseUrl && !force) {
+            return true;
+          }
+          return false;
+        },
+        task: async (ctx) => {
+          const res = await fetch("https://neon.new/api/v1/database", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ref: "cedarjs" })
+          });
+          if (!res.ok) {
+            throw new Error(`Neon API returned ${res.status} ${res.statusText}`);
+          }
+          const data = await res.json();
+          if (!data.connection_string || !data.expires_at || !data.claim_url) {
+            throw new Error(
+              "Neon API returned an invalid response\n\n" + JSON.stringify(data, null, 2)
+            );
+          }
+          ctx.databaseUrl = data.connection_string;
+          ctx.databaseUrlDirect = data.connection_string.replace(
+            "-pooler.",
+            "."
+          );
+          if (ctx.databaseUrlDirect === ctx.databaseUrl) {
+            throw new Error(
+              'Could not derive a direct (non-pooler) connection string from the Neon response. Expected the connection string to contain "-pooler." in the hostname.'
+            );
+          }
+          ctx.neonClaimUrl = data.claim_url;
+          ctx.neonClaimExpiry = new Date(data.expires_at).toUTCString();
+        }
+      },
+      {
+        title: "Writing database connection to .env",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return true;
+          }
+          if (hasDirectDatabaseUrl && !force) {
+            return true;
+          }
+          if (!ctx.databaseUrl) {
+            return "No database URL to write (Neon provisioning skipped)";
+          }
+          return false;
+        },
+        task: (ctx) => {
+          let envContent = "";
+          if (fs.existsSync(envPath)) {
+            envContent = fs.readFileSync(envPath, "utf-8");
+            if (force) {
+              const lines = envContent.split("\n");
+              const filtered = lines.filter(
+                (line) => !line.startsWith("DATABASE_URL=") && !line.startsWith("DIRECT_DATABASE_URL=")
+              );
+              envContent = filtered.join("\n").trimEnd();
+            }
+            if (envContent && !envContent.endsWith("\n")) {
+              envContent += "\n";
+            }
+          }
+          envContent += `DATABASE_URL=${ctx.databaseUrl}
+`;
+          envContent += `DIRECT_DATABASE_URL=${ctx.databaseUrlDirect}
+`;
+          fs.writeFileSync(envPath, envContent);
+        }
+      },
+      installPackages,
+      {
+        title: "Running Prisma migrations",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return true;
+          }
+          if (ctx.skipWithNote) {
+            return "DATABASE_URL already configured \u2014 skipping migration";
+          }
+          if (!ctx.databaseUrl) {
+            return "No database provisioned \u2014 skipping migration";
+          }
+          return false;
+        },
+        task: (ctx) => {
+          const result = execa.commandSync(
+            "yarn cedar prisma migrate dev --name init-neon",
+            {
+              cwd: cedarPaths.base,
+              stdio: ["inherit", "inherit", "pipe"],
+              reject: false,
+              env: {
+                ...process.env,
+                DIRECT_DATABASE_URL: ctx.databaseUrlDirect
+              }
+            }
+          );
+          if (result.exitCode !== 0) {
+            throw new Error(
+              "Prisma migration failed:\n\n" + result.stderr + "\n\nYou can try running it manually:\n  yarn cedar prisma migrate dev --name init-neon"
+            );
+          }
+        }
+      },
+      {
+        title: "One more thing...",
+        task: (ctx, task) => {
+          if (ctx.unsupportedProvider) {
+            task.output = "Skipped \u2014 unsupported database provider";
+            return;
+          }
+          if (ctx.skipWithNote) {
+            task.output = "Skipped \u2014 DATABASE_URL already configured";
+            return;
+          }
+          const claimMsg = [
+            colors.important(
+              "Your Neon database has been created and is ready to use!"
+            ),
+            "",
+            `Claim URL:  ${colors.underline(ctx.neonClaimUrl || "N/A")}`,
+            `Expires:    ${ctx.neonClaimExpiry || "N/A"}`,
+            "",
+            "Claim your database to keep it beyond the expiration date."
+          ];
+          notes.push(...claimMsg);
+        }
+      }
+    ],
+    {
+      exitOnError: false
+    }
+  );
+  try {
+    await tasks.run();
+    if (notes.length > 0) {
+      console.log();
+      console.log(notes.join("\n"));
+    }
+  } catch (e) {
+    if (isErrorWithMessage(e)) {
+      errorTelemetry(process.argv, e.message);
+      console.error(colors.error(e.message));
+    }
+    if (isErrorWithExitCode(e)) {
+      process.exit(e.exitCode);
+    }
+    process.exit(1);
+  }
+}
+function isErrorWithMessage(e) {
+  return !!e && typeof e === "object" && "message" in e;
+}
+function isErrorWithExitCode(e) {
+  return !!e && typeof e === "object" && "exitCode" in e && typeof e.exitCode === "number";
+}
+function hasSqliteUsageOutsideDb(srcPath, dbTsPath) {
+  const sqlitePattern = /better-sqlite3|@prisma\/adapter-better-sqlite3/;
+  const files = fs.globSync("**/*.{ts,tsx,js,jsx}", { cwd: srcPath });
+  for (const file of files) {
+    const fullPath = path.join(srcPath, file);
+    if (fullPath === dbTsPath) {
+      continue;
+    }
+    try {
+      const content = fs.readFileSync(fullPath, "utf-8");
+      if (sqlitePattern.test(content)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+export {
+  handler
+};

package/dist/commands/setup/neon/templates/db.ts.template

@@ -0,0 +1,32 @@
+import { PrismaPg } from '@prisma/adapter-pg'
+import { PrismaClient } from 'api/db/generated/prisma/client.mts'
+
+import { emitLogLevels, handlePrismaLogging } from '@cedarjs/api/logger'
+
+import { logger } from './logger.js'
+
+export * from 'api/db/generated/prisma/client.mts'
+
+if (!process.env.DATABASE_URL) {
+  throw new Error('DATABASE_URL environment variable is not set')
+}
+
+const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+const prismaClient = new PrismaClient({
+  log: emitLogLevels(['info', 'warn', 'error']),
+  adapter,
+})
+
+handlePrismaLogging({
+  db: prismaClient,
+  logger,
+  logLevels: ['info', 'warn', 'error'],
+})
+
+/**
+ * Global Prisma client extensions should be added here, as $extend
+ * returns a new instance.
+ * export const db = prismaClient.$extend(...)
+ * Add any .$on hooks before using $extend
+ */
+export const db = prismaClient

package/dist/commands/setup.js

@@ -11,6 +11,7 @@ import * as setupJobs from "./setup/jobs/jobs.js";
 import * as setupMailer from "./setup/mailer/mailer.js";
 import * as setupMiddleware from "./setup/middleware/middleware.js";
 import * as setupMonitoring from "./setup/monitoring/monitoring.js";
+import * as setupNeon from "./setup/neon/neon.js";
 import * as setupPackage from "./setup/package/package.js";
 import * as setupRealtime from "./setup/realtime/realtime.js";
 import * as setupServerFile from "./setup/server-file/serverFile.js";
@@ -20,7 +21,7 @@ import * as setupUploads from "./setup/uploads/uploads.js";
 import * as setupVite from "./setup/vite/vite.js";
 const command = "setup <command>";
 const description = "Initialize project config and install packages";
-const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTsconfig).command(setupUi).command(setupUploads).command(setupVite).demandCommand().middleware(detectCedarVersion).epilogue(
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTsconfig).command(setupUi).command(setupUploads).command(setupVite).demandCommand().middleware(detectCedarVersion).epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#setup"

package/dist/commands/upgrade/upgradeHandler.js

@@ -440,7 +440,7 @@ async function downloadYarnPatches(ctx, { dryRun, verbose }) {
 }
 async function refreshPrismaClient(task, { verbose }) {
   try {
-    await generatePrismaClient({ verbose, force: false });
+    await generatePrismaClient({ verbose, force: true });
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
     task.skip("Refreshing the Prisma client caused an Error.");

package/dist/lib/exec.js

@@ -1,8 +1,6 @@
+import { existsSync } from "node:fs";
 import path from "node:path";
-import { createServer, version as viteVersion } from "vite";
-import { ViteNodeRunner } from "vite-node/client";
-import { ViteNodeServer } from "vite-node/server";
-import { installSourcemapsSupport } from "vite-node/source-map";
+import { createServer, isRunnableDevEnvironment } from "vite";
 import { getPaths, importStatementPath } from "@cedarjs/project-config";
 import {
   cedarCellTransform,
@@ -10,8 +8,21 @@ import {
   cedarjsJobPathInjectorPlugin,
   cedarSwapApolloProvider,
   cedarImportDirPlugin,
-  cedarAutoImportsPlugin
+  cedarAutoImportsPlugin,
+  cedarCjsCompatPlugin
 } from "@cedarjs/vite";
+function resolveExtension(id) {
+  if (existsSync(id)) {
+    return id;
+  }
+  const withoutExt = /\.jsx?$/.test(id) ? id.replace(/\.jsx?$/, "") : id;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    if (existsSync(withoutExt + ext)) {
+      return withoutExt + ext;
+    }
+  }
+  return id;
+}
 async function runScriptFunction({
   path: scriptPath,
   functionName,
@@ -22,10 +33,16 @@ async function runScriptFunction({
   const server = await createServer({
     mode: "production",
     optimizeDeps: {
-      // This is recommended in the vite-node readme
       noDiscovery: true,
       include: void 0
     },
+    server: {
+      hmr: false,
+      watch: null
+    },
+    environments: {
+      nodeRunnerEnv: {}
+    },
     resolve: {
       alias: [
         {
@@ -52,18 +69,12 @@ async function runScriptFunction({
             const webImportBase = importStatementPath(getPaths().web.base);
             if (importer.startsWith(apiImportBase)) {
               const apiImportSrc = importStatementPath(getPaths().api.src);
-              let resolvedId = id.replace("src", apiImportSrc);
-              if (importer.endsWith(".ts") || importer.endsWith(".tsx")) {
-                resolvedId = resolvedId.replace(/\.jsx?$/, "");
-              }
-              return { id: resolvedId };
+              const resolvedId = id.replace("src", apiImportSrc);
+              return { id: resolveExtension(resolvedId) };
             } else if (importer.startsWith(webImportBase)) {
               const webImportSrc = importStatementPath(getPaths().web.src);
-              let resolvedId = id.replace("src", webImportSrc);
-              if (importer.endsWith(".ts") || importer.endsWith(".tsx")) {
-                resolvedId = resolvedId.replace(/\.jsx?$/, "");
-              }
-              return { id: resolvedId };
+              const resolvedId = id.replace("src", webImportSrc);
+              return { id: resolveExtension(resolvedId) };
             }
             return null;
           }
@@ -71,6 +82,7 @@ async function runScriptFunction({
       ]
     },
     plugins: [
+      cedarCjsCompatPlugin(),
       cedarjsResolveCedarStyleImportsPlugin(),
       cedarCellTransform(),
       cedarjsJobPathInjectorPlugin(),
@@ -79,41 +91,21 @@ async function runScriptFunction({
       cedarAutoImportsPlugin()
     ]
   });
-  if (Number(viteVersion.split(".")[0]) < 6) {
-    await server.pluginContainer.buildStart({});
+  const env = server.environments.nodeRunnerEnv;
+  if (!env || !isRunnableDevEnvironment(env)) {
+    await server.close();
+    throw new Error("Vite environment is not runnable.");
   }
-  const node = new ViteNodeServer(server, {
-    transformMode: {
-      ssr: [/.*/],
-      web: [/\/web\//]
-    },
-    deps: {
-      fallbackCJS: true
-    }
-  });
-  installSourcemapsSupport({
-    getSourceMap: (source) => node.getSourceMap(source)
-  });
-  const runner = new ViteNodeRunner({
-    root: server.config.root,
-    base: server.config.base,
-    fetchModule(id) {
-      return node.fetchModule(id);
-    },
-    resolveId(id, importer) {
-      return node.resolveId(id, importer);
-    }
-  });
   let returnValue;
   let scriptError = null;
   try {
-    const script = await runner.executeFile(scriptPath);
+    const script = await env.runner.import(scriptPath);
     returnValue = await script[functionName](args);
   } catch (error) {
     scriptError = error;
   }
   try {
-    const { db } = await runner.executeFile(path.join(getPaths().api.lib, "db"));
+    const { db } = await env.runner.import(path.join(getPaths().api.lib, "db"));
     db.$disconnect();
   } catch (e) {
   }

package/dist/lib/generatePrismaClient.js

@@ -1,8 +1,11 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import { createRequire } from "node:module";
-import { resolveGeneratedPrismaClient } from "@cedarjs/project-config";
+import path from "node:path";
+import { getConfig, getPrismaSchemas } from "@cedarjs/project-config";
 import { runCommandTask, getPaths } from "./index.js";
 const generatePrismaCommand = async () => {
+  const config = getConfig();
   const createdRequire = createRequire(import.meta.url);
   const prismaIndexPath = createdRequire.resolve("prisma/build/index.js");
   return {
@@ -10,19 +13,52 @@ const generatePrismaCommand = async () => {
     args: [
       prismaIndexPath,
       "generate",
-      `--config=${getPaths().api.prismaConfig}`
+      `--config=${getPaths().api.prismaConfig}`,
+      ...config.api.prismaGenerateArgs
     ]
   };
 };
-const generatePrismaClient = async ({
+async function computePrismaSchemaHash() {
+  try {
+    const hash = createHash("sha256");
+    const configPath = getPaths().api.prismaConfig;
+    if (fs.existsSync(configPath)) {
+      hash.update(fs.readFileSync(configPath));
+    }
+    const { schemas } = await getPrismaSchemas();
+    for (const schema of schemas) {
+      hash.update(schema[1]);
+    }
+    return hash.digest("hex");
+  } catch {
+    return null;
+  }
+}
+function getHashFilePath() {
+  const generatedBase = getPaths().generated.base;
+  return path.join(generatedBase, "prisma-schema-hash");
+}
+function getStoredSchemaHash() {
+  const hashFile = getHashFilePath();
+  if (fs.existsSync(hashFile)) {
+    return fs.readFileSync(hashFile, "utf-8").trim();
+  }
+  return null;
+}
+function storeSchemaHash(hash) {
+  const hashFile = getHashFilePath();
+  fs.mkdirSync(path.dirname(hashFile), { recursive: true });
+  fs.writeFileSync(hashFile, hash);
+}
+async function generatePrismaClient({
   verbose = true,
-  force = true,
+  force = false,
   silent = false
-} = {}) => {
+} = {}) {
+  const hash = await computePrismaSchemaHash();
   if (!force) {
-    const { clientPath } = await resolveGeneratedPrismaClient();
-    const prismaClientFile = clientPath && fs.existsSync(clientPath) ? fs.readFileSync(clientPath, "utf8") : "";
-    if (!prismaClientFile.includes("@prisma/client did not initialize yet.") && prismaClientFile.includes("exports.Prisma.")) {
+    const storedHash = hash ? getStoredSchemaHash() : null;
+    if (hash !== null && hash === storedHash) {
       return;
     }
   }
@@ -38,7 +74,10 @@ const generatePrismaClient = async ({
       silent
     }
   );
-};
+  if (hash !== null) {
+    storeSchemaHash(hash);
+  }
+}
 export {
   generatePrismaClient,
   generatePrismaCommand

package/dist/lib/locking.js

@@ -32,11 +32,15 @@ function unsetLock(identifier) {
 }
 function isLockSet(identifier) {
   const lockfilePath = path.join(getPaths().generated.base, "locks", identifier);
-  const exists = fs.existsSync(lockfilePath);
-  if (!exists) {
-    return false;
+  let createdAt;
+  try {
+    createdAt = fs.statSync(lockfilePath).birthtimeMs;
+  } catch (error) {
+    if (isErrorWithCode(error, "ENOENT")) {
+      return false;
+    }
+    throw error;
   }
-  const createdAt = fs.statSync(lockfilePath).birthtimeMs;
   if (Date.now() - createdAt > 36e5) {
     unsetLock(identifier);
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/cli",
-  "version": "4.1.1-next.14+69388bd68a",
+  "version": "4.1.1-next.64",
   "description": "The CedarJS Command Line",
   "repository": {
     "type": "git",
@@ -31,18 +31,19 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@babel/parser": "7.29.2",
+    "@babel/parser": "7.29.3",
     "@babel/preset-typescript": "7.28.5",
-    "@cedarjs/api-server": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/cli-helpers": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/fastify-web": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/internal": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/prerender": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/project-config": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/structure": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/telemetry": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/utils": "4.1.1-next.14+69388bd68a",
-    "@cedarjs/web-server": "4.1.1-next.14+69388bd68a",
+    "@cedarjs/api-server": "4.1.0",
+    "@cedarjs/cli-helpers": "4.1.0",
+    "@cedarjs/fastify-web": "4.1.0",
+    "@cedarjs/internal": "4.1.0",
+    "@cedarjs/prerender": "4.1.0",
+    "@cedarjs/project-config": "4.1.0",
+    "@cedarjs/structure": "4.1.0",
+    "@cedarjs/telemetry": "4.1.0",
+    "@cedarjs/utils": "4.1.0",
+    "@cedarjs/vite": "4.1.0",
+    "@cedarjs/web-server": "4.1.0",
     "@listr2/prompt-adapter-enquirer": "4.2.1",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/core": "1.30.1",
@@ -88,7 +89,6 @@
     "title-case": "3.0.3",
     "unionfs": "4.6.0",
     "uuid": "11.1.0",
-    "vite-node": "3.2.4",
     "yargs": "17.7.2"
   },
   "devDependencies": {
@@ -108,5 +108,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "69388bd68ad03ce3b1afd399167899369c2c08c1"
+  "gitHead": "3905ed045508b861b495f8d5630d76c7a157d8f1"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Cedar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.