@cedarjs/cli 4.2.0 → 4.2.1-next.258

package/dist/commands/setup/deploy/providers/netlifyHandler.js

@@ -1,39 +1,140 @@
+import fs from "node:fs";
 import path from "path";
 import { Listr } from "listr2";
 import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import { getPaths, printSetupNotes } from "../../../../lib/index.js";
-import { addFilesTask, updateApiURLTask } from "../helpers/index.js";
+import {
+  addPackagesTask,
+  getPaths,
+  printSetupNotes
+} from "../../../../lib/index.js";
+import {
+  addFilesTask,
+  insertPluginsBeforeCedar,
+  updateApiURLTask,
+  verifyUDSetupTask
+} from "../helpers/index.js";
 import { NETLIFY_TOML } from "../templates/netlify.js";
+import { NETLIFY_UD_TOML } from "../templates/netlifyUD.js";
 const files = [
   {
     path: path.join(getPaths().base, "netlify.toml"),
     content: NETLIFY_TOML
   }
 ];
+const filesUd = [
+  {
+    path: path.join(getPaths().base, "netlify.toml"),
+    content: NETLIFY_UD_TOML
+  }
+];
 const notes = [
   "You are ready to deploy to Netlify!",
   "See: https://cedarjs.com/docs/deploy/netlify"
 ];
-const handler = async ({ force }) => {
+const udNotes = [
+  "You are ready to deploy to Netlify with Universal Deploy!",
+  `Build with: ${formatCedarCommand(["build", "--ud"])}`,
+  "See: https://cedarjs.com/docs/deploy/netlify"
+];
+function addNetlifyPluginsToViteConfigTask() {
+  return {
+    title: "Adding Netlify plugins to vite config...",
+    task: async (_ctx, task) => {
+      const paths = getPaths();
+      const viteConfigTs = path.join(paths.web.base, "vite.config.ts");
+      const viteConfigJs = path.join(paths.web.base, "vite.config.js");
+      const viteConfigPath = fs.existsSync(viteConfigTs) ? viteConfigTs : viteConfigJs;
+      if (!fs.existsSync(viteConfigPath)) {
+        task.skip(`${viteConfigPath} not found`);
+        return;
+      }
+      let content = fs.readFileSync(viteConfigPath, "utf-8");
+      const hasNetlifyPlugin = content.includes("@netlify/vite-plugin");
+      const hasNetlifyCompat = content.includes(
+        "@universal-deploy/netlify/vite"
+      );
+      if (hasNetlifyPlugin && hasNetlifyCompat && content.includes("netlifyCompat(")) {
+        task.skip("Netlify plugins are already configured.");
+        return;
+      }
+      if (!hasNetlifyPlugin || !hasNetlifyCompat) {
+        const newContent = content.replace(
+          /(import\s+\{[^}]*\}\s+from\s+['"]vite['"];?)/,
+          (match) => {
+            let result = match;
+            if (!hasNetlifyPlugin) {
+              result = `import netlify from '@netlify/vite-plugin'
+${result}`;
+            }
+            if (!hasNetlifyCompat) {
+              result = `import netlifyCompat from '@universal-deploy/netlify/vite'
+${result}`;
+            }
+            return result;
+          }
+        );
+        if (newContent === content) {
+          let prepend = "";
+          if (!hasNetlifyPlugin) {
+            prepend += "import netlify from '@netlify/vite-plugin'\n";
+          }
+          if (!hasNetlifyCompat) {
+            prepend += "import netlifyCompat from '@universal-deploy/netlify/vite'\n";
+          }
+          content = prepend + content;
+        } else {
+          content = newContent;
+        }
+      }
+      if (!content.includes("netlifyCompat(")) {
+        const result = insertPluginsBeforeCedar({
+          content,
+          pluginCodes: [
+            "netlify({ build: { enabled: true } })",
+            "netlifyCompat()"
+          ]
+        });
+        if (result) {
+          content = result;
+        }
+      }
+      fs.writeFileSync(viteConfigPath, content);
+    }
+  };
+}
+function installNetlifyPackagesTask() {
+  return addPackagesTask({
+    packages: ["@netlify/vite-plugin", "@universal-deploy/netlify"],
+    devDependency: true
+  });
+}
+const handler = async ({ force, ud }) => {
   recordTelemetryAttributes({
     command: "setup deploy netlify",
-    force
+    force,
+    ud
   });
   const tasks = new Listr(
     [
-      updateApiURLTask("/.netlify/functions"),
-      addFilesTask({ files, force }),
-      printSetupNotes(notes)
-    ],
+      ud && verifyUDSetupTask(),
+      ud && await installNetlifyPackagesTask(),
+      ud && addNetlifyPluginsToViteConfigTask(),
+      !ud && updateApiURLTask("/.netlify/functions"),
+      addFilesTask({ files: ud ? filesUd : files, force }),
+      printSetupNotes(ud ? udNotes : notes)
+    ].filter((task) => Boolean(task)),
     { rendererOptions: { collapseSubtasks: false } }
   );
   try {
     await tasks.run();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    process.exit(exitCode);
   }
 };
 export {

package/dist/commands/setup/deploy/providers/renderHandler.js

@@ -63,7 +63,10 @@ const additionalFiles = [
     content: RENDER_HEALTH_CHECK
   }
 ];
-const handler = async ({ force, database }) => {
+const handler = async ({
+  force,
+  database
+}) => {
   recordTelemetryAttributes({
     command: "setup deploy render",
     force,
@@ -75,7 +78,7 @@ const handler = async ({ force, database }) => {
         title: "Adding render.yaml",
         task: async () => {
           const fileData = await getRenderYamlContent(database);
-          let files = {};
+          const files = {};
           files[fileData.path] = fileData.content;
           return writeFilesTask(files, { overwriteExisting: force });
         }
@@ -92,9 +95,11 @@ const handler = async ({ force, database }) => {
   try {
     await tasks.run();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    process.exit(exitCode);
   }
 };
 export {

package/dist/commands/setup/deploy/providers/serverlessHandler.js

@@ -132,9 +132,11 @@ const handler = async ({ force }) => {
   try {
     await tasks.run();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    process.exit(exitCode);
   }
 };
 export {

package/dist/commands/setup/deploy/providers/universal-deploy.js

@@ -0,0 +1,11 @@
+const command = "universal-deploy";
+const description = "Setup Universal Deploy";
+async function handler() {
+  const { handler: handler2 } = await import("./universalDeployHandler.js");
+  return handler2();
+}
+export {
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/deploy/providers/universalDeployHandler.js

@@ -0,0 +1,188 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Listr } from "listr2";
+import {
+  colors as c,
+  getPaths,
+  isTypeScriptProject,
+  recordTelemetryAttributes
+} from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import { printSetupNotes } from "../../../../lib/index.js";
+const notes = [
+  "Universal Deploy is set up!",
+  "",
+  "Next steps:",
+  `  ${c.highlight("yarn cedar build --ud")} \u2014 build the Universal Deploy server entry`,
+  `  ${c.highlight("yarn cedar serve --ud")} \u2014 serve it locally`,
+  "",
+  "To deploy, pick a deployment target, for example:",
+  `  ${c.highlight("yarn cedar setup deploy netlify --ud")}`,
+  `  ${c.highlight("yarn cedar setup deploy vercel --ud")}`,
+  "",
+  "See: https://cedarjs.com/docs/deploy/universal-deploy"
+];
+async function handler() {
+  recordTelemetryAttributes({
+    command: "setup deploy universal-deploy"
+  });
+  const tasks = new Listr(
+    [addUniversalDeployPluginToViteConfig(), printSetupNotes(notes)],
+    { rendererOptions: { collapseSubtasks: false } }
+  );
+  try {
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e.exitCode || 1);
+  }
+}
+function addUniversalDeployPluginToViteConfig() {
+  return {
+    title: "Adding cedarUniversalDeployPlugin to vite config...",
+    task: async (_ctx, task) => {
+      const projectIsTS = isTypeScriptProject();
+      const viteConfigPath = path.join(
+        getPaths().web.base,
+        `vite.config.${projectIsTS ? "ts" : "js"}`
+      );
+      if (!fs.existsSync(viteConfigPath)) {
+        task.skip(`${viteConfigPath} not found`);
+        return;
+      }
+      let content = fs.readFileSync(viteConfigPath, "utf-8");
+      if (content.includes("cedarUniversalDeployPlugin")) {
+        task.skip("cedarUniversalDeployPlugin is already configured.");
+        return;
+      }
+      content = mergeImport(content);
+      content = addPluginToConfig(content);
+      fs.writeFileSync(viteConfigPath, content);
+    }
+  };
+}
+function findCedarViteImportLine(lines) {
+  for (let i = 0; i < lines.length; i++) {
+    if (/^import\b/.test(lines[i]) && /from\s+['"]@cedarjs\/vite['"]/.test(lines[i])) {
+      return i;
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (/from\s+['"]@cedarjs\/vite['"]/.test(lines[i])) {
+      for (let j = i; j >= 0; j--) {
+        if (/^import\b/.test(lines[j])) {
+          return j;
+        }
+      }
+      return i;
+    }
+  }
+  return -1;
+}
+function mergeImport(content) {
+  const lines = content.split("\n");
+  const importIndex = findCedarViteImportLine(lines);
+  if (importIndex === -1) {
+    throw new Error("No import from @cedarjs/vite found");
+  }
+  const importLine = lines[importIndex];
+  const singleLineNamed = importLine.match(
+    /^(import\s*\{\s*)([^}]*?)(\s*\}\s*from\s+['"]@cedarjs\/vite['"];?)$/
+  );
+  if (singleLineNamed) {
+    const specifiers = singleLineNamed[2].trim();
+    if (specifiers.includes("cedarUniversalDeployPlugin")) {
+      return content;
+    }
+    lines[importIndex] = specifiers ? `${singleLineNamed[1]}${specifiers}, cedarUniversalDeployPlugin${singleLineNamed[3]}` : `${singleLineNamed[1]}cedarUniversalDeployPlugin${singleLineNamed[3]}`;
+    return lines.join("\n");
+  }
+  let closeIndex = importIndex;
+  for (let i = importIndex + 1; i < lines.length; i++) {
+    if (/}\s*from\s+['"]@cedarjs\/vite['"]/.test(lines[i])) {
+      closeIndex = i;
+      break;
+    }
+  }
+  if (closeIndex > importIndex) {
+    const specifiersLines = lines.slice(importIndex + 1, closeIndex);
+    const allSpecifiers = specifiersLines.join(" ");
+    if (allSpecifiers.includes("cedarUniversalDeployPlugin")) {
+      return content;
+    }
+    const indentMatch = specifiersLines[0]?.match(/^(\s+)/);
+    const indent = indentMatch?.[1] || "  ";
+    lines.splice(closeIndex, 0, `${indent}cedarUniversalDeployPlugin,`);
+    return lines.join("\n");
+  }
+  const defaultMatch = importLine.match(
+    /^import\s+(\w+)\s+from\s+['"]@cedarjs\/vite['"];?\s*$/
+  );
+  if (defaultMatch) {
+    lines[importIndex] = importLine.replace(
+      /(import\s+\w+)(\s+from\s+['"]@cedarjs\/vite['"];?)/,
+      "$1, { cedarUniversalDeployPlugin }$2"
+    );
+    return lines.join("\n");
+  }
+  return content;
+}
+function addPluginToConfig(content) {
+  const lines = content.split("\n");
+  const pluginsLineIndex = lines.findIndex(
+    (line) => /plugins\s*:\s*\[/.test(line)
+  );
+  if (pluginsLineIndex === -1) {
+    return content;
+  }
+  const pluginsLine = lines[pluginsLineIndex];
+  const inlineMatch = pluginsLine.trim().match(/^plugins\s*:\s*\[([\s\S]*?)\]\s*,?\s*$/);
+  if (inlineMatch) {
+    const inner = inlineMatch[1].trimEnd();
+    const indentation = pluginsLine.match(/^\s*/)?.[0] || "  ";
+    lines[pluginsLineIndex] = inner ? `${indentation}plugins: [${inner}, cedarUniversalDeployPlugin()],` : `${indentation}plugins: [cedarUniversalDeployPlugin()],`;
+    return lines.join("\n");
+  }
+  let closeIndex = -1;
+  for (let i = pluginsLineIndex + 1; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "]" || trimmed === "],") {
+      closeIndex = i;
+      break;
+    }
+  }
+  if (closeIndex === -1) {
+    return content;
+  }
+  const pluginsLineIndent = pluginsLine.match(/^\s*/)?.[0] || "";
+  const firstEntryIndent = (() => {
+    for (let i = pluginsLineIndex + 1; i < closeIndex; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed) {
+        return lines[i].match(/^\s*/)?.[0] || "  ";
+      }
+    }
+    return pluginsLineIndent + "  ";
+  })();
+  const prevLine = lines[closeIndex - 1]?.trimEnd();
+  if (prevLine && !prevLine.endsWith(",") && prevLine !== "[" && !prevLine.endsWith("[")) {
+    const commentIdx = prevLine.search(/\s+\/\/|(?<!\\)\/\*/);
+    if (commentIdx !== -1) {
+      lines[closeIndex - 1] = prevLine.slice(0, commentIdx) + "," + prevLine.slice(commentIdx);
+    } else {
+      lines[closeIndex - 1] = prevLine + ",";
+    }
+  }
+  lines.splice(
+    closeIndex,
+    0,
+    `${firstEntryIndent}cedarUniversalDeployPlugin(),`
+  );
+  return lines.join("\n");
+}
+export {
+  addPluginToConfig,
+  handler,
+  mergeImport
+};

package/dist/commands/setup/deploy/providers/vercel.js

@@ -1,8 +1,14 @@
 import { createHandler } from "../helpers/helpers.js";
 const command = "vercel";
 const description = "Setup Vercel deploy";
+const builder = (yargs) => yargs.option("ud", {
+  description: "Setup for use with Universal Deploy",
+  type: "boolean",
+  default: false
+});
 const handler = createHandler("vercel");
 export {
+  builder,
   command,
   description,
   handler

package/dist/commands/setup/deploy/providers/vercelHandler.js

@@ -1,19 +1,35 @@
+import fs from "node:fs";
 import path from "path";
 import { Listr } from "listr2";
 import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import { getPaths, printSetupNotes, writeFile } from "../../../../lib/index.js";
-import { updateApiURLTask } from "../helpers/index.js";
-async function handler(options) {
+import {
+  addPackagesTask,
+  getPaths,
+  printSetupNotes,
+  writeFile
+} from "../../../../lib/index.js";
+import {
+  insertPluginsBeforeCedar,
+  updateApiURLTask,
+  verifyUDSetupTask
+} from "../helpers/index.js";
+async function handler({ force, ud }) {
   recordTelemetryAttributes({
-    command: "setup deploy vercel"
+    command: "setup deploy vercel",
+    force,
+    ud
   });
   const tasks = new Listr(
     [
-      updateApiURLTask("/api"),
-      writeVercelConfigTask({ overwriteExisting: options.force }),
-      printSetupNotes(notes)
-    ],
+      ud && verifyUDSetupTask(),
+      ud && await installVercelPackagesTask(),
+      ud && addVercelPluginToViteConfigTask(),
+      !ud && updateApiURLTask("/api"),
+      ud ? writeVercelUDConfigTask({ overwriteExisting: force }) : writeVercelConfigTask({ overwriteExisting: force }),
+      printSetupNotes(ud ? udNotes : notes)
+    ].filter((task) => Boolean(task)),
     {
       rendererOptions: { collapseSubtasks: false }
     }
@@ -21,12 +37,64 @@ async function handler(options) {
   try {
     await tasks.run();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    process.exit(exitCode);
   }
 }
-function writeVercelConfigTask({ overwriteExisting = false } = {}) {
+function addVercelPluginToViteConfigTask() {
+  return {
+    title: "Adding Vercel plugin to vite config...",
+    task: async (_ctx, task) => {
+      const paths = getPaths();
+      const viteConfigTs = path.join(paths.web.base, "vite.config.ts");
+      const viteConfigJs = path.join(paths.web.base, "vite.config.js");
+      const viteConfigPath = fs.existsSync(viteConfigTs) ? viteConfigTs : viteConfigJs;
+      if (!fs.existsSync(viteConfigPath)) {
+        task.skip(`${viteConfigPath} not found`);
+        return;
+      }
+      let content = fs.readFileSync(viteConfigPath, "utf-8");
+      const hasVercelPlugin = content.includes("vite-plugin-vercel");
+      if (hasVercelPlugin && content.includes("vercel(")) {
+        task.skip("Vercel plugin is already configured.");
+        return;
+      }
+      if (!hasVercelPlugin) {
+        const newContent = content.replace(
+          /(import\s+\{[^}]*\}\s+from\s+['"]vite['"];?)/,
+          "import { vercel } from 'vite-plugin-vercel/vite'\n$1"
+        );
+        if (newContent === content) {
+          content = "import { vercel } from 'vite-plugin-vercel/vite'\n" + content;
+        } else {
+          content = newContent;
+        }
+      }
+      if (!content.includes("vercel(")) {
+        const result = insertPluginsBeforeCedar({
+          content,
+          pluginCodes: ["vercel({ outDir: '../.vercel/output' })"]
+        });
+        if (result) {
+          content = result;
+        }
+      }
+      fs.writeFileSync(viteConfigPath, content);
+    }
+  };
+}
+function installVercelPackagesTask() {
+  return addPackagesTask({
+    packages: ["vite-plugin-vercel"],
+    devDependency: true
+  });
+}
+function writeVercelConfigTask({
+  overwriteExisting = false
+} = {}) {
   return {
     title: "Writing vercel.json...",
     task: (_ctx, task) => {
@@ -50,6 +118,39 @@ const notes = [
   "You are ready to deploy to Vercel!",
   "See: https://cedarjs.com/docs/deploy#vercel-deploy"
 ];
+const udNotes = [
+  "You are ready to deploy to Vercel with Universal Deploy!",
+  `Build with: ${formatCedarCommand(["build", "--ud"])}`,
+  "See: https://cedarjs.com/docs/deploy#vercel-deploy"
+];
+function writeVercelUDConfigTask({
+  overwriteExisting = false
+} = {}) {
+  const config = {
+    build: {
+      command: formatCedarCommand([
+        "build",
+        "--ud",
+        "--verbose",
+        "--apiRootPath=/.api/functions"
+      ]),
+      env: {
+        ENABLE_EXPERIMENTAL_COREPACK: "1"
+      }
+    }
+  };
+  return {
+    title: "Writing vercel.json for Universal Deploy...",
+    task: (_ctx, task) => {
+      writeFile(
+        path.join(getPaths().base, "vercel.json"),
+        JSON.stringify(config, null, 2),
+        { overwriteExisting },
+        task
+      );
+    }
+  };
+}
 export {
   handler
 };

package/dist/commands/setup/deploy/templates/baremetal.js

@@ -1,9 +1,10 @@
+import { getPackageManager } from "@cedarjs/project-config/packageManager";
 const ECOSYSTEM = `module.exports = {
   apps: [
     {
       name: 'serve',
       cwd: 'current',
-      script: 'node_modules/.bin/rw',
+      script: 'node_modules/.bin/cedar',
       args: 'serve',
       instances: 'max',
       exec_mode: 'cluster',
@@ -32,7 +33,7 @@ host = "server.com"
 username = "user"
 agentForward = true
 sides = ["api","web"]
-packageManagerCommand = "yarn"
+packageManagerCommand = "${getPackageManager()}"
 monitorCommand = "pm2"
 path = "/var/www/app"
 processNames = ["serve"]