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

package/dist/commands/setup/database/postgresHandler.js

@@ -0,0 +1,196 @@
+import fs from "node:fs";
+import path from "node:path";
+import execa from "execa";
+import { Listr } from "listr2";
+import { colors } from "@cedarjs/cli-helpers/colors";
+import { installPackages } from "@cedarjs/cli-helpers/installHelpers";
+import { prettyPrintCedarCommand } from "@cedarjs/cli-helpers/packageManager";
+import { addWorkspacePackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { getPaths } from "@cedarjs/cli-helpers/paths";
+import { resolveFile } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+function checkProjectShape(cedarPaths) {
+  const schemaPath = path.join(cedarPaths.api.base, "db", "schema.prisma");
+  const dbPath = resolveFile(path.join(cedarPaths.api.lib, "db"));
+  if (!fs.existsSync(schemaPath)) {
+    return blocked(`Could not find ${schemaPath}.`);
+  }
+  if (!dbPath) {
+    return blocked(`No ${path.join(cedarPaths.api.lib, "db")} file found`);
+  }
+  const schemaContent = fs.readFileSync(schemaPath, "utf-8");
+  const hasPgAdapter = fs.readFileSync(dbPath, "utf-8").includes("PrismaPg");
+  if (schemaContent.includes('provider = "postgresql"') && hasPgAdapter) {
+    return {
+      ok: false,
+      alreadyConverted: true,
+      message: "This project is already configured for PostgreSQL."
+    };
+  }
+  if (!schemaContent.includes('provider = "sqlite"') || hasPgAdapter) {
+    return blocked(
+      "This command only converts a project that is still on SQLite, with the default adapter in api/src/lib/db.ts (or db.js) untouched. This project doesn't match that shape (a different provider, or a partial previous conversion). Please switch it over to PostgreSQL manually."
+    );
+  }
+  return { ok: true, dbPath };
+}
+function blocked(message) {
+  return { ok: false, alreadyConverted: false, message };
+}
+function getSqliteToPostgresTasks({
+  dbPath
+}) {
+  const cedarPaths = getPaths();
+  const schemaPath = path.join(cedarPaths.api.base, "db", "schema.prisma");
+  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"
+  );
+  return [
+    {
+      title: "Removing SQLite dependencies from api/package.json",
+      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",
+      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",
+      task: () => {
+        const schemaContent = fs.readFileSync(schemaPath, "utf-8");
+        fs.writeFileSync(
+          schemaPath,
+          schemaContent.replace(
+            'provider = "sqlite"',
+            'provider = "postgresql"'
+          )
+        );
+      }
+    },
+    {
+      title: "Updating database adapter",
+      task: () => {
+        const pgDbTs = fs.readFileSync(dbTsTemplatePath, "utf-8");
+        fs.writeFileSync(dbPath, pgDbTs);
+      }
+    },
+    {
+      title: "Adding required api packages...",
+      task: async () => {
+        await addWorkspacePackages("api", ["@prisma/adapter-pg@7.8.0"], {
+          cwd: cedarPaths.api.base
+        });
+      }
+    }
+  ];
+}
+function readEnvVar(envContent, name) {
+  return envContent.match(new RegExp(`^${name}=(.*)$`, "m"))?.[1] || void 0;
+}
+async function handler() {
+  const cedarPaths = getPaths();
+  const shape = checkProjectShape(cedarPaths);
+  if (!shape.ok) {
+    if (shape.alreadyConverted) {
+      console.log(colors.note(shape.message));
+      return;
+    }
+    console.error(colors.error(shape.message));
+    process.exit(1);
+  }
+  const envPath = path.join(cedarPaths.base, ".env");
+  const envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+  const databaseUrl = readEnvVar(envContent, "DATABASE_URL");
+  const tasks = new Listr(
+    [
+      ...getSqliteToPostgresTasks({ dbPath: shape.dbPath }),
+      installPackages,
+      {
+        title: "Running Prisma migrations",
+        skip: () => {
+          if (!databaseUrl) {
+            return `No DATABASE_URL found in \`.env\`. Set it to your PostgreSQL connection string, then run \`${prettyPrintCedarCommand(["prisma", "migrate", "dev"])}\``;
+          }
+          return false;
+        },
+        task: () => {
+          const result = execa.commandSync(
+            "yarn cedar prisma migrate dev --name init-postgres",
+            {
+              cwd: cedarPaths.base,
+              stdio: ["inherit", "inherit", "pipe"],
+              reject: false
+            }
+          );
+          if (result.exitCode !== 0) {
+            throw new Error(
+              "Prisma migration failed:\n\n" + result.stderr + `
+
+You can try running it manually:
+  ${prettyPrintCedarCommand(["prisma", "migrate", "dev", "--name", "init-postgres"])}`
+            );
+          }
+        }
+      }
+    ],
+    {
+      exitOnError: false,
+      collectErrors: "minimal"
+    }
+  );
+  try {
+    await tasks.run();
+    if (tasks.errors.length > 0) {
+      for (const error of tasks.errors) {
+        if (isErrorWithMessage(error)) {
+          errorTelemetry(process.argv, error.message);
+          console.error(colors.error(error.message));
+        }
+      }
+      process.exit(1);
+    }
+  } 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";
+}
+export {
+  checkProjectShape,
+  getSqliteToPostgresTasks,
+  handler
+};

package/dist/commands/setup/database/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/deploy/deploy.js

@@ -1,5 +1,3 @@
-const command = "deploy <target>";
-const description = "Setup deployment to various targets";
 import { terminalLink } from "termi-link";
 import * as setupDeployBaremetal from "./providers/baremetal.js";
 import * as setupDeployCoherence from "./providers/coherence.js";
@@ -7,8 +5,11 @@ import * as setupDeployFlightcontrol from "./providers/flightcontrol.js";
 import * as setupDeployNetlify from "./providers/netlify.js";
 import * as setupDeployRender from "./providers/render.js";
 import * as setupDeployServerless from "./providers/serverless.js";
+import * as setupDeployUniversalDeploy from "./providers/universal-deploy.js";
 import * as setupDeployVercel from "./providers/vercel.js";
-const builder = (yargs) => yargs.command(setupDeployBaremetal).command(setupDeployCoherence).command(setupDeployFlightcontrol).command(setupDeployNetlify).command(setupDeployRender).command(setupDeployServerless).command(setupDeployVercel).demandCommand().option("force", {
+const command = "deploy <target>";
+const description = "Setup deployment to various targets";
+const builder = (yargs) => yargs.command(setupDeployBaremetal).command(setupDeployCoherence).command(setupDeployFlightcontrol).command(setupDeployNetlify).command(setupDeployRender).command(setupDeployServerless).command(setupDeployUniversalDeploy).command(setupDeployVercel).demandCommand().option("force", {
   alias: "f",
   default: false,
   description: "Overwrite existing configuration",

package/dist/commands/setup/deploy/helpers/helpers.js

@@ -1,6 +1,10 @@
 function createHandler(componentName) {
   return async function handler(argv) {
-    const { handler: importedHandler } = await import(`../providers/${componentName}Handler.js`);
+    const { existsSync } = await import("node:fs");
+    const tsPath = `../providers/${componentName}Handler.ts`;
+    const jsPath = `../providers/${componentName}Handler.js`;
+    const resolvedPath = existsSync(new URL(tsPath, import.meta.url)) ? tsPath : jsPath;
+    const { handler: importedHandler } = await import(resolvedPath);
     return importedHandler(argv);
   };
 }

package/dist/commands/setup/deploy/helpers/index.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
+import * as parser from "@babel/parser";
+import * as t from "@babel/types";
 import execa from "execa";
 import { Listr } from "listr2";
-import { getConfigPath } from "@cedarjs/project-config";
+import { getConfigPath, getConfig } from "@cedarjs/project-config";
 import { getPaths, writeFilesTask } from "../../../../lib/index.js";
 const updateApiURLTask = (apiUrl) => {
   const configTomlPath = getConfigPath();
@@ -25,6 +27,9 @@ const updateApiURLTask = (apiUrl) => {
     }
   };
 };
+function getUserApiUrl() {
+  return getConfig().web.apiUrl;
+}
 const preRequisiteCheckTask = (preRequisites) => {
   return {
     title: "Checking pre-requisites",
@@ -35,9 +40,10 @@ const preRequisiteCheckTask = (preRequisites) => {
           task: async () => {
             try {
               await execa(...preReq.command);
-            } catch (error) {
-              error.message = error.message + "\n" + preReq.errorMessage;
-              throw error;
+            } catch (e) {
+              const baseMsg = e instanceof Error ? e.message : String(e);
+              const err = new Error(baseMsg + "\n" + preReq.errorMessage);
+              throw err;
             }
           }
         };
@@ -53,7 +59,7 @@ const addFilesTask = ({
   return {
     title: `${title}...`,
     task: () => {
-      let fileNameToContentMap = {};
+      const fileNameToContentMap = {};
       files.forEach((fileData) => {
         fileNameToContentMap[fileData.path] = fileData.content;
       });
@@ -61,6 +67,121 @@ const addFilesTask = ({
     }
   };
 };
+const verifyUDSetupTask = () => {
+  return {
+    title: "Checking if Universal Deploy is set up...",
+    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)) {
+        throw new Error("Vite config file not found");
+      }
+      const content = fs.readFileSync(viteConfigPath, "utf-8");
+      if (!content.includes("cedarUniversalDeployPlugin")) {
+        throw new Error(
+          "Universal Deploy is not set up. Please run `yarn cedar setup deploy universal-deploy` first."
+        );
+      }
+    }
+  };
+};
+function resolveConfigObject(arg) {
+  if (t.isObjectExpression(arg)) {
+    return arg;
+  }
+  if (t.isArrowFunctionExpression(arg)) {
+    if (t.isObjectExpression(arg.body)) {
+      return arg.body;
+    }
+    if (t.isBlockStatement(arg.body)) {
+      const returnStmt = arg.body.body.find((s) => t.isReturnStatement(s));
+      if (t.isObjectExpression(returnStmt?.argument)) {
+        return returnStmt.argument;
+      }
+    }
+    return null;
+  }
+  if (t.isFunctionExpression(arg)) {
+    if (t.isBlockStatement(arg.body)) {
+      const returnStmt = arg.body.body.find(t.isReturnStatement);
+      if (t.isObjectExpression(returnStmt?.argument)) {
+        return returnStmt.argument;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function insertPluginsBeforeCedar({
+  content,
+  pluginCodes
+}) {
+  const ast = parser.parse(content, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"]
+  });
+  const defaultExport = ast.program.body.find(t.isExportDefaultDeclaration);
+  if (!defaultExport) {
+    return null;
+  }
+  const declaration = defaultExport.declaration;
+  const configArg = resolveConfigObject(declaration.arguments[0]);
+  if (!configArg) {
+    return null;
+  }
+  const pluginsProp = configArg.properties.find(t.isObjectProperty);
+  if (!t.isArrayExpression(pluginsProp?.value)) {
+    return null;
+  }
+  const arrayExpr = pluginsProp.value;
+  const elements = arrayExpr.elements;
+  const cedarIndex = elements.findIndex(
+    (el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === "cedar"
+  );
+  if (cedarIndex === -1) {
+    return null;
+  }
+  const cedarElement = elements[cedarIndex];
+  if (!cedarElement || !t.isCallExpression(cedarElement)) {
+    return null;
+  }
+  const cedarNode = cedarElement;
+  if (!cedarNode.loc || !arrayExpr.loc || !pluginsProp.loc || cedarNode.start == null || arrayExpr.start == null || arrayExpr.end == null) {
+    return null;
+  }
+  const isInline = cedarNode.loc.start.line === arrayExpr.loc.start.line;
+  if (isInline) {
+    const precedingText = content.slice(0, arrayExpr.start);
+    const followingText = content.slice(arrayExpr.end);
+    const existingCodes = elements.flatMap((el) => {
+      if (el?.start == null || el.end == null) {
+        return [];
+      }
+      return [content.slice(el.start, el.end)];
+    });
+    const lines2 = content.split("\n");
+    const pluginsLine = pluginsProp.loc.start.line;
+    const pluginsIndent = (lines2[pluginsLine - 1].match(/^\s*/) ?? [""])[0];
+    const elemIndent = pluginsIndent + "  ";
+    const allCodes = [...existingCodes];
+    allCodes.splice(cedarIndex, 0, ...pluginCodes);
+    const multiline = [
+      "[",
+      ...allCodes.map((code) => `${elemIndent}${code},`),
+      `${pluginsIndent}]`
+    ].join("\n");
+    return precedingText + multiline + followingText;
+  }
+  const cedarLine = cedarNode.loc.start.line;
+  const insertPos = cedarNode.start - cedarNode.loc.start.column;
+  const lines = content.split("\n");
+  const indent = (lines[cedarLine - 1].match(/^\s*/) ?? [""])[0];
+  const insertion = pluginCodes.map((code) => `${indent}${code},
+`).join("");
+  return content.slice(0, insertPos) + insertion + content.slice(insertPos);
+}
 const addToGitIgnoreTask = ({ paths }) => {
   return {
     title: "Updating .gitignore...",
@@ -68,6 +189,7 @@ const addToGitIgnoreTask = ({ paths }) => {
       if (!fs.existsSync(path.resolve(getPaths().base, ".gitignore"))) {
         return "No gitignore present, skipping.";
       }
+      return void 0;
     },
     task: async (_ctx, task) => {
       const gitIgnore = path.resolve(getPaths().base, ".gitignore");
@@ -86,6 +208,7 @@ const addToDotEnvTask = ({ lines }) => {
       if (!fs.existsSync(path.resolve(getPaths().base, ".env"))) {
         return "No .env present, skipping.";
       }
+      return void 0;
     },
     task: async (_ctx, task) => {
       const env = path.resolve(getPaths().base, ".env");
@@ -101,6 +224,9 @@ export {
   addFilesTask,
   addToDotEnvTask,
   addToGitIgnoreTask,
+  getUserApiUrl,
+  insertPluginsBeforeCedar,
   preRequisiteCheckTask,
-  updateApiURLTask
+  updateApiURLTask,
+  verifyUDSetupTask
 };

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

@@ -1,8 +1,10 @@
-import path from "path";
+import fs from "node:fs";
+import path from "node:path";
 import { Listr } from "listr2";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import prompts from "prompts";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import c from "../../../../lib/colors.js";
 import {
   addPackagesTask,
   getPaths,
@@ -36,6 +38,24 @@ const handler = async ({ force }) => {
     command: "setup deploy baremetal",
     force
   });
+  if (fs.existsSync(path.join(getPaths().base, ".pnp.cjs"))) {
+    console.warn(
+      c.warning(
+        "Your project uses Yarn PnP (Plug'n'Play), which is not officially supported for Baremetal deployments. The generated ecosystem.config.js file uses node_modules/.bin/cedar as the PM2 script path, which will most likely not work under PnP.\n\nYou will need to manually configure the server. See also the packageManagerCommand field in deploy.toml."
+      )
+    );
+    console.log();
+    const { confirmed } = await prompts({
+      type: "confirm",
+      name: "confirmed",
+      message: "Generate the default config anyway? (You can edit it later)"
+    });
+    if (!confirmed) {
+      console.log("Aborting baremetal setup.");
+      return;
+    }
+    console.log();
+  }
   const tasks = new Listr(
     [
       await addPackagesTask({
@@ -53,9 +73,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/coherence.js

@@ -1,4 +1,4 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "coherence";
 const description = "Setup Coherence deploy";
 function builder(yargs) {