@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/commands/upgrade/upgradeHandler.js

@@ -5,33 +5,36 @@ import execa from "execa";
 import latestVersion from "latest-version";
 import { Listr } from "listr2";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import {
+  dedupe,
+  dedupeIsSupported,
+  install,
+  installationErrorMessage,
+  prettyPrintCedarCommand
+} from "@cedarjs/cli-helpers/packageManager";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getConfig } from "@cedarjs/project-config";
-import c from "../../lib/colors.js";
+import { getPackageManager } from "@cedarjs/project-config/packageManager";
 import { generatePrismaClient } from "../../lib/generatePrismaClient.js";
 import { getPaths } from "../../lib/index.js";
 import { PLUGIN_CACHE_FILENAME } from "../../lib/plugin.js";
 import { runPreUpgradeScripts } from "./preUpgradeScripts.js";
 import { isValidCedarJSTag } from "./tags.js";
-const handler = async ({
-  dryRun,
-  tag,
-  verbose,
-  dedupe,
-  yes,
-  force
-}) => {
+const handler = async (upgradeOptions) => {
+  const { dryRun, tag, verbose, dedupe: dedupe2, yes, force } = upgradeOptions;
   recordTelemetryAttributes({
     command: "upgrade",
     dryRun: !!dryRun,
     tag: tag ?? "latest",
     verbose: !!verbose,
-    dedupe: !!dedupe,
+    dedupe: !!dedupe2,
     yes: !!yes,
     force: !!force
   });
   let preUpgradeMessage = "";
   let preUpgradeError = "";
+  const notBlockedByPreUpgradeChecks = (ctx) => force || !ctx.preUpgradeError;
   const tasks = new Listr(
     [
       {
@@ -86,51 +89,57 @@ const handler = async ({
       {
         title: "Updating your CedarJS version",
         task: (ctx) => updateCedarJSDepsForAllSides(ctx, { dryRun, verbose }),
-        enabled: (ctx) => !!ctx.versionToUpgradeTo && !ctx.preUpgradeError
+        enabled: (ctx) => !!ctx.versionToUpgradeTo && notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: "Updating other packages in your package.json(s)",
         task: (ctx) => updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }),
-        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && !ctx.preUpgradeError
+        // Canary only. This forces the template's dependency versions onto the
+        // project and adds back any the project is missing, which resurrects
+        // packages people have deliberately removed — a project that moved off
+        // SQLite gets better-sqlite3 back, for example. That's too blunt for
+        // regular upgrades, but people running canary are already signed up
+        // for rougher edges.
+        // https://github.com/redwoodjs/redwood/pull/8855
+        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: "Downloading yarn patches",
         task: (ctx) => downloadYarnPatches(ctx, { dryRun, verbose }),
-        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && !ctx.preUpgradeError
+        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: "Removing CLI cache",
         task: () => removeCliCache({ dryRun, verbose }),
-        enabled: (ctx) => !ctx.preUpgradeError
+        enabled: (ctx) => notBlockedByPreUpgradeChecks(ctx)
       },
       {
-        title: "Running yarn install",
-        task: () => yarnInstall({ verbose }),
-        enabled: (ctx) => !ctx.preUpgradeError,
+        title: `Running ${getPackageManager()} ${install()}`,
+        task: () => packageManagerInstall({ verbose }),
+        enabled: (ctx) => notBlockedByPreUpgradeChecks(ctx),
         skip: () => !!dryRun
       },
       {
         title: "Refreshing the Prisma client",
         task: (_ctx, task) => refreshPrismaClient(task, { verbose }),
-        enabled: (ctx) => !ctx.preUpgradeError,
+        enabled: (ctx) => notBlockedByPreUpgradeChecks(ctx),
         skip: () => !!dryRun
       },
       {
         title: "De-duplicating dependencies",
-        skip: () => !!dryRun || !dedupe,
-        enabled: (ctx) => !ctx.preUpgradeError,
+        skip: () => !!dryRun || !dedupe2,
+        enabled: (ctx) => dedupeIsSupported() && notBlockedByPreUpgradeChecks(ctx),
         task: (_ctx, task) => dedupeDeps(task, { verbose })
       },
       {
         title: "One more thing..",
         task: (ctx, task) => {
           const version = ctx.versionToUpgradeTo;
+          const upgradeMessage = dryRun ? `\u{1F3C3} Dry run complete. Your project would be upgraded to CedarJS ${version}.` : `\u{1F389} Your project has been upgraded to CedarJS ${version}!`;
           const messageSections = [
             `One more thing...
 
-   ${c.warning(
-              `\u{1F389} Your project has been upgraded to CedarJS ${version}!`
-            )} 
+   ${c.warning(upgradeMessage)} 
 
 `
           ];
@@ -188,21 +197,18 @@ const handler = async ({
   }
   if (preUpgradeMessage) {
     console.log("");
-    console.log(`  \u{1F4E3} ${c.info("Pre-upgrade Message:")}`);
+    console.log(`  \u{1F4E3} ${c.info("Pre-upgrade Script Messages:")}`);
     console.log("  " + preUpgradeMessage.replace(/\n/g, "\n  "));
   }
 };
-async function yarnInstall({ verbose }) {
+async function packageManagerInstall({ verbose }) {
   try {
-    await execa("yarn install", {
-      shell: true,
+    await execa(getPackageManager(), [install()], {
       stdio: verbose ? "inherit" : "pipe",
       cwd: getPaths().base
     });
   } catch {
-    throw new Error(
-      "Could not finish installation. Please run `yarn install` and then `yarn dedupe`, before continuing"
-    );
+    throw new Error(installationErrorMessage());
   }
 }
 async function removeCliCache({
@@ -306,6 +312,22 @@ function updateCedarJSDepsForAllSides(ctx, options) {
     })
   );
 }
+function mergeTemplateDependencies(field, templatePackageJson, localPackageJson, messages, { dryRun, verbose } = {}) {
+  const templateDeps = templatePackageJson[field];
+  if (!templateDeps) {
+    return;
+  }
+  for (const [depName, depVersion] of Object.entries(templateDeps)) {
+    if (depName.startsWith("@cedarjs/")) {
+      continue;
+    }
+    const localDeps = localPackageJson[field] ??= {};
+    if (verbose || dryRun) {
+      messages.push(` - ${depName}: ${localDeps[depName]} => ${depVersion}`);
+    }
+    localDeps[depName] = depVersion;
+  }
+}
 async function updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }) {
   if (!ctx.versionToUpgradeTo) {
     throw new Error("Failed to upgrade");
@@ -331,35 +353,25 @@ async function updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }) {
         title: `Updating ${pkgJsonPath}`,
         task: async (_ctx, task) => {
           const res = await fetch(url);
+          if (!res.ok) {
+            throw new Error(
+              `Failed to fetch template package.json from ${url}: ` + res.statusText
+            );
+          }
           const text = await res.text();
           const templatePackageJson = JSON.parse(text);
           const localPackageJsonText = fs.readFileSync(pkgJsonPath, "utf-8");
           const localPackageJson = JSON.parse(localPackageJsonText);
           const messages = [];
-          Object.entries(templatePackageJson.dependencies || {}).forEach(
-            ([depName, depVersion]) => {
-              if (!depName.startsWith("@cedarjs/")) {
-                if (verbose || dryRun) {
-                  messages.push(
-                    ` - ${depName}: ${localPackageJson.dependencies[depName]} => ${depVersion}`
-                  );
-                }
-                localPackageJson.dependencies[depName] = depVersion;
-              }
-            }
-          );
-          Object.entries(templatePackageJson.devDependencies || {}).forEach(
-            ([depName, depVersion]) => {
-              if (!depName.startsWith("@cedarjs/")) {
-                if (verbose || dryRun) {
-                  messages.push(
-                    ` - ${depName}: ${localPackageJson.devDependencies[depName]} => ${depVersion}`
-                  );
-                }
-                localPackageJson.devDependencies[depName] = depVersion;
-              }
-            }
-          );
+          for (const field of ["dependencies", "devDependencies"]) {
+            mergeTemplateDependencies(
+              field,
+              templatePackageJson,
+              localPackageJson,
+              messages,
+              { dryRun, verbose }
+            );
+          }
           if (messages.length > 0) {
             task.title = task.title + "\n" + messages.join("\n");
           }
@@ -380,16 +392,19 @@ async function downloadYarnPatches(ctx, { dryRun, verbose }) {
     throw new Error("Failed to upgrade");
   }
   const githubToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || process.env.REDWOOD_GITHUB_TOKEN;
-  const res = await fetch(
-    "https://api.github.com/repos/cedarjs/cedar/git/trees/main?recursive=1",
-    {
-      headers: {
-        ...githubToken && { Authorization: `Bearer ${githubToken}` },
-        ["X-GitHub-Api-Version"]: "2022-11-28",
-        Accept: "application/vnd.github+json"
-      }
+  const url = "https://api.github.com/repos/cedarjs/cedar/git/trees/main?recursive=1";
+  const res = await fetch(url, {
+    headers: {
+      ...githubToken && { Authorization: `Bearer ${githubToken}` },
+      ["X-GitHub-Api-Version"]: "2022-11-28",
+      Accept: "application/vnd.github+json"
     }
-  );
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch list of yarn patches from ${url}: ` + res.statusText
+    );
+  }
   const json = await res.json();
   const patches = json.tree?.filter(
     (patchInfo) => patchInfo.path.startsWith(
@@ -409,6 +424,11 @@ async function downloadYarnPatches(ctx, { dryRun, verbose }) {
         title: `Downloading ${patch.path}`,
         task: async () => {
           const res2 = await fetch(patch.url);
+          if (!res2.ok) {
+            throw new Error(
+              `Failed to fetch patch metadata from ${patch.url}: ` + res2.statusText
+            );
+          }
           const patchMeta = await res2.json();
           const patchPath = path.join(
             getPaths().base,
@@ -429,20 +449,23 @@ 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.");
     console.log(
-      "You may need to update your prisma client manually: $ yarn cedar prisma generate"
+      "You may need to update your prisma client manually: $ " + prettyPrintCedarCommand(["prisma", "generate"])
     );
     console.log(c.error(message));
   }
 }
-const dedupeDeps = async (_task, { verbose }) => {
+async function dedupeDeps(_task, { verbose }) {
+  const dedupeCmd = dedupe();
+  if (!dedupeCmd) {
+    return;
+  }
   try {
-    await execa("yarn dedupe", {
-      shell: true,
+    await execa(getPackageManager(), [dedupeCmd], {
       stdio: verbose ? "inherit" : "pipe",
       cwd: getPaths().base
     });
@@ -450,11 +473,12 @@ const dedupeDeps = async (_task, { verbose }) => {
     const message = e instanceof Error ? e.message : String(e);
     console.log(c.error(message));
     throw new Error(
-      "Could not finish de-duplication. Please run `yarn dedupe` before continuing"
+      `Could not finish de-duplication. Please run \`${getPackageManager()} ${dedupeCmd}\` before continuing`
     );
   }
-  await yarnInstall({ verbose });
-};
+  await packageManagerInstall({ verbose });
+}
 export {
-  handler
+  handler,
+  mergeTemplateDependencies
 };

package/dist/index.js

@@ -4,8 +4,10 @@ import path from "path";
 import { trace, SpanStatusCode } from "@opentelemetry/api";
 import { hideBin, Parser } from "yargs/helpers";
 import yargs from "yargs/yargs";
-import { loadEnvFiles, recordTelemetryAttributes } from "@cedarjs/cli-helpers";
-import { findUp, projectIsEsm, getConfigPath } from "@cedarjs/project-config";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { loadEnvFiles } from "@cedarjs/cli-helpers/loadEnvFiles";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { findUp, getConfigPath } from "@cedarjs/project-config";
 import { telemetryMiddleware } from "@cedarjs/telemetry";
 import * as buildCommand from "./commands/build.js";
 import * as checkCommand from "./commands/check.js";
@@ -26,29 +28,31 @@ import * as serveCommand from "./commands/serve.js";
 import * as setupCommand from "./commands/setup.js";
 import * as studioCommand from "./commands/studio.js";
 import * as testCommand from "./commands/test.js";
-import * as testCommandEsm from "./commands/testEsm.js";
-import * as tstojsCommand from "./commands/ts-to-js.js";
 import * as typeCheckCommand from "./commands/type-check.js";
 import * as upgradeCommand from "./commands/upgrade/upgrade.js";
-import c from "./lib/colors.js";
 import { exitWithError } from "./lib/exit.js";
 import * as updateCheck from "./lib/updateCheck.js";
 import { loadPlugins } from "./plugin.js";
 import { startTelemetry, shutdownTelemetry } from "./telemetry/index.js";
-let { cwd, telemetry, help, version } = Parser(hideBin(process.argv), {
+const {
+  telemetry,
+  help,
+  version,
+  cwd: parsedCwd
+} = Parser(hideBin(process.argv), {
   // Telemetry is enabled by default, but can be disabled in two ways
   // - by passing a `--telemetry false` option
-  // - by setting a `REDWOOD_DISABLE_TELEMETRY` env var
+  // - by setting a `CEDAR_DISABLE_TELEMETRY` env var
   boolean: ["telemetry"],
   default: {
-    telemetry: process.env.REDWOOD_DISABLE_TELEMETRY === void 0 || process.env.REDWOOD_DISABLE_TELEMETRY === ""
+    telemetry: (process.env.CEDAR_DISABLE_TELEMETRY === void 0 || process.env.CEDAR_DISABLE_TELEMETRY === "") && (process.env.REDWOOD_DISABLE_TELEMETRY === void 0 || process.env.REDWOOD_DISABLE_TELEMETRY === "")
   }
 });
+let cwd = parsedCwd;
 cwd ??= process.env.CEDAR_CWD;
 cwd ??= process.env.RWJS_CWD;
 cwd = getTomlDir(cwd);
 process.env.CEDAR_CWD = cwd;
-process.env.RWJS_CWD = cwd;
 if (process.argv[1]?.endsWith("redwood.js")) {
   const tomlPath = getConfigPath(cwd);
   const toml = fs.readFileSync(tomlPath, "utf8");
@@ -127,7 +131,7 @@ async function runYargs() {
   }).example(
     "yarn cedar g page home /",
     "Create a page component named 'Home' at path '/'"
-  ).demandCommand().strict().exitProcess(false).alias("h", "help").command(buildCommand).command(checkCommand).command(consoleCommand).command(deployCommand).command(destroyCommand).command(devCommand).command(execCommand).command(experimentalCommand).command(generateCommand).command(infoCommand).command(jobsCommand).command(lintCommand).command(prerenderCommand).command(prismaCommand).command(recordCommand).command(serveCommand).command(setupCommand).command(studioCommand).command(projectIsEsm() ? testCommandEsm : testCommand).command(tstojsCommand).command(typeCheckCommand).command(upgradeCommand);
+  ).demandCommand().strict().exitProcess(false).alias("h", "help").command(buildCommand).command(checkCommand).command(consoleCommand).command(deployCommand).command(destroyCommand).command(devCommand).command(execCommand).command(experimentalCommand).command(generateCommand).command(infoCommand).command(jobsCommand).command(lintCommand).command(prerenderCommand).command(prismaCommand).command(recordCommand).command(serveCommand).command(setupCommand).command(studioCommand).command(testCommand).command(typeCheckCommand).command(upgradeCommand);
   await loadPlugins(yarg);
   const pkgJson = await import("../package.json", { with: { type: "json" } });
   yarg.version(pkgJson.default["version"]);
@@ -166,7 +170,7 @@ function getTomlDir(cwd2) {
       tomlDir = path.dirname(configTomlPath);
     }
   } catch (error) {
-    console.error(error.message);
+    console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
   return tomlDir;

package/dist/lib/background.js

@@ -3,6 +3,23 @@ import fs from "node:fs";
 import os from "os";
 import path from "path";
 import { getPaths } from "@cedarjs/project-config";
+function quoteForWindowsShell(arg) {
+  let quoted = '"';
+  let backslashes = 0;
+  for (const char of arg) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      quoted += "\\".repeat(backslashes * 2 + 1) + '"';
+    } else {
+      quoted += "\\".repeat(backslashes) + char;
+    }
+    backslashes = 0;
+  }
+  return quoted + "\\".repeat(backslashes * 2) + '"';
+}
 function spawnBackgroundProcess(name, cmd, args) {
   const logDirectory = path.join(getPaths().generated.base, "logs");
   fs.mkdirSync(logDirectory, { recursive: true });
@@ -37,7 +54,8 @@ function spawnBackgroundProcess(name, cmd, args) {
       shell: true,
       stdio: ["ignore", stdout, stderr]
     };
-    const child = spawn(cmd + " " + args.join(" "), spawnOptions);
+    const command = [cmd, ...args].map(quoteForWindowsShell).join(" ");
+    const child = spawn(command, spawnOptions);
     child.unref();
   } else {
     const spawnOptions = {
@@ -47,7 +65,10 @@ function spawnBackgroundProcess(name, cmd, args) {
     const child = spawn(cmd, args, spawnOptions);
     child.unref();
   }
+  fs.closeSync(stdout);
+  fs.closeSync(stderr);
 }
 export {
+  quoteForWindowsShell,
   spawnBackgroundProcess
 };

package/dist/lib/configureStorybook.js

@@ -10,11 +10,11 @@ import {
 } from "./merge/strategy.js";
 import { isTypeScriptProject } from "./project.js";
 import { getPaths, transformTSToJS, writeFile } from "./index.js";
-async function extendStorybookConfiguration(newConfigPath = void 0) {
+async function extendStorybookConfiguration(newConfigPath) {
   const webPaths = getPaths().web;
   const ts = isTypeScriptProject();
   const sbPreviewConfigPath = webPaths.storybookPreviewConfig ?? `${webPaths.storybook}/preview.${ts ? "tsx" : "js"}`;
-  const read = (path2) => fse.readFileSync(path2, { encoding: "utf-8" });
+  const read = (filePath) => fse.readFileSync(filePath, { encoding: "utf-8" });
   if (!fse.existsSync(sbPreviewConfigPath)) {
     const templateContent = read(
       path.resolve(

package/dist/lib/exec.js

@@ -1,17 +1,38 @@
+import { existsSync, statSync } 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,
-  cedarjsDirectoryNamedImportPlugin,
+  cedarjsResolveCedarStyleImportsPlugin,
   cedarjsJobPathInjectorPlugin,
   cedarSwapApolloProvider,
   cedarImportDirPlugin,
-  cedarAutoImportsPlugin
+  cedarAutoImportsPlugin,
+  cedarCjsCompatPlugin
 } from "@cedarjs/vite";
+function resolveId(id) {
+  if (existsSync(id) && statSync(id).isFile()) {
+    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;
+    }
+  }
+  if (existsSync(id) && statSync(id).isDirectory()) {
+    for (const base of ["index", path.basename(id)]) {
+      for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+        const candidate = path.join(id, base + ext);
+        if (existsSync(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  }
+  return id;
+}
 async function runScriptFunction({
   path: scriptPath,
   functionName,
@@ -22,24 +43,27 @@ 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: {
+      // `$api/` and `api/` imports are handled by
+      // cedarjsResolveCedarStyleImportsPlugin below, which also resolves
+      // Cedar's directory named modules (`$api/src/services/posts` ->
+      // posts/posts.ts) and leaves an actual `api` npm package alone. The web
+      // side equivalents have no plugin support, so they stay aliases
       alias: [
-        {
-          find: /^\$api\//,
-          replacement: getPaths().api.base + "/"
-        },
         {
           find: /^\$web\//,
           replacement: getPaths().web.base + "/"
         },
-        {
-          find: /^api\//,
-          replacement: getPaths().api.base + "/"
-        },
         {
           find: /^web\//,
           replacement: getPaths().web.base + "/"
@@ -50,20 +74,14 @@ async function runScriptFunction({
           customResolver: (id, importer, _options) => {
             const apiImportBase = importStatementPath(getPaths().api.base);
             const webImportBase = importStatementPath(getPaths().web.base);
-            if (importer.startsWith(apiImportBase)) {
+            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 };
-            } else if (importer.startsWith(webImportBase)) {
+              const apiId = id.replace("src", apiImportSrc);
+              return { id: resolveId(apiId) };
+            } 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 webId = id.replace("src", webImportSrc);
+              return { id: resolveId(webId) };
             }
             return null;
           }
@@ -71,7 +89,8 @@ async function runScriptFunction({
       ]
     },
     plugins: [
-      cedarjsDirectoryNamedImportPlugin(),
+      cedarCjsCompatPlugin(),
+      cedarjsResolveCedarStyleImportsPlugin(),
       cedarCellTransform(),
       cedarjsJobPathInjectorPlugin(),
       cedarSwapApolloProvider(),
@@ -79,47 +98,33 @@ 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;
   try {
-    const script = await runner.executeFile(scriptPath);
-    returnValue = script[functionName](args);
-  } catch (error) {
-    console.error(error);
-  }
-  try {
-    const { db } = await runner.executeFile(path.join(getPaths().api.lib, "db"));
-    db.$disconnect();
-  } catch (e) {
+    const module = await env.runner.import(scriptPath);
+    const fn = module[functionName];
+    if (typeof fn !== "function") {
+      throw new Error(`Function '${functionName}' not found in script`);
+    }
+    returnValue = await fn(args);
+  } finally {
+    try {
+      const dbModule = await env.runner.import(
+        path.join(getPaths().api.lib, "db")
+      );
+      dbModule.db?.$disconnect?.();
+    } catch {
+    }
+    await server.close();
+    process.env.NODE_ENV = NODE_ENV;
   }
-  await server.close();
-  process.env.NODE_ENV = NODE_ENV;
   return returnValue;
 }
 export {
+  resolveId,
   runScriptFunction
 };

package/dist/lib/exit.js

@@ -4,7 +4,7 @@ import { v4 as uuidv4 } from "uuid";
 import {
   recordTelemetryAttributes,
   recordTelemetryError
-} from "@cedarjs/cli-helpers";
+} from "@cedarjs/cli-helpers/telemetry";
 const discordLink = terminalLink("Discord", "https://cedarjs.com/discord");
 const githubLink = terminalLink("GitHub", "https://github.com/cedarjs/cedar");
 const DEFAULT_ERROR_EPILOGUE = [
@@ -12,12 +12,27 @@ const DEFAULT_ERROR_EPILOGUE = [
   ` - Not sure about something or need advice? Reach out on our ${discordLink}`,
   ` - Think you've found a bug? Open an issue on our ${githubLink}`
 ].join("\n");
-function exitWithError(error, { exitCode, message, epilogue, includeEpilogue, includeReferenceCode } = {}) {
-  exitCode ??= error?.exitCode ?? 1;
+function exitWithError(error, {
+  exitCode,
+  message,
+  epilogue,
+  includeEpilogue,
+  includeReferenceCode
+} = {}) {
+  if (error && typeof error === "object" && "exitCode" in error) {
+    exitCode ??= typeof error.exitCode === "number" ? error.exitCode : 1;
+  }
+  exitCode ??= 1;
   epilogue ??= DEFAULT_ERROR_EPILOGUE;
   includeEpilogue ??= true;
   includeReferenceCode ??= true;
-  message ??= error.stack ?? (error.toString() || "Unknown error");
+  if (message === void 0) {
+    if (error instanceof Error && error.stack) {
+      message = error.stack;
+    } else {
+      message = String(error) || "Unknown error";
+    }
+  }
   const errorReferenceCode = uuidv4();
   const line = ansis.red("-".repeat(process.stderr.columns - 4));
   const content = !includeEpilogue ? message : [
@@ -31,7 +46,7 @@ ${line}`,
     line
   ].filter(Boolean).join("\n");
   console.error(content);
-  recordTelemetryError(error ?? new Error(message));
+  recordTelemetryError(error ?? new Error(message ?? ""));
   recordTelemetryAttributes({ errorReferenceCode });
   process.exit(exitCode);
 }