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

package/README.md

@@ -238,12 +238,9 @@ export const builder = (yargs) => {
 
     ...
 
-    .option('stats', {
-      default: false,
-      description: `Use ${terminalLink(
-        'Webpack Bundle Analyzer',
-        'https://github.com/webpack-contrib/webpack-bundle-analyzer'
-      )}`,
+    .option('prerender', {
+      default: true,
+      description: 'Prerender after building web',
       type: 'boolean',
     })
     .option('verbose', {
@@ -258,11 +255,11 @@ export const builder = (yargs) => {
 }
 ```
 
-These two calls to `options` configure this command to have options `--stats` and `--verbose`:
+These two calls to `options` configure this command to have options `--prerender` and `--verbose`:
 
 ```terminal
-yarn rw build --stats
-yarn rw build --verbose
+yarn cedar build --no-prerender
+yarn cedar build --verbose
 ```
 
 For the full list of what properties you can use to compose the options object, see [options(key, [opt])](https://yargs.js.org/docs/#api-optionskey-opt).
@@ -280,8 +277,8 @@ While `build`'s `handler` is too long to reproduce here in full, to get the poin
 
 export const handler = async ({
   side = ['api', 'web'],
+  prerender = true,
   verbose = false,
-  stats = false,
 }) => {
 
   ...

package/dist/cfw.js

@@ -2,11 +2,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import Configstore from "configstore";
-import execa from "execa";
 import { terminalLink } from "termi-link";
+import { runScriptSync } from "@cedarjs/cli-helpers/packageManager/exec";
 import { getConfigPath } from "@cedarjs/project-config";
 const config = new Configstore("@cedarjs/cli");
-const CFW_PATH = process.env.CFW_PATH || process.env.RWFW_PATH || process.env.RW_PATH || config.get("CFW_PATH") || config.get("RWFW_PATH");
+const CFW_PATH = process.env.CFW_PATH || config.get("CFW_PATH");
 if (!CFW_PATH) {
   console.error("Error: You must specify the path to Cedar Framework");
   console.error("Usage: `CFW_PATH=~/gh/cedarjs/cedar yarn cfw <command>");
@@ -30,14 +30,18 @@ const helpCommands = ["help", "--help"];
 if (!command.length || command.some((cmd) => helpCommands.includes(cmd))) {
   command = ["run"];
 }
+const script = command[0];
+const args = command.slice(1);
 try {
-  execa.sync("yarn", [...command], {
+  runScriptSync(script, args, {
     stdio: "inherit",
     cwd: absCfwPath,
-    env: {
-      CEDAR_CWD: projectPath
-    }
+    // @ts-expect-error - testUtils.d.ts augments ProcessEnv with
+    // CEDAR_DISABLE_TELEMETRY
+    env: { CEDAR_CWD: projectPath }
   });
 } catch (e) {
   console.log();
+  const exitCode = e && typeof e === "object" && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+  process.exit(exitCode);
 }

package/dist/commands/build/buildHandler.js

@@ -4,39 +4,103 @@ import path from "node:path";
 import execa from "execa";
 import { Listr } from "listr2";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
-import { buildApi, cleanApiBuild } from "@cedarjs/internal/dist/build/api";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import {
+  formatCedarCommand,
+  formatRunWorkspaceScriptCommand
+} from "@cedarjs/cli-helpers/packageManager/display";
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import {
+  buildApi,
+  buildApiWithVite,
+  cleanApiBuild
+} from "@cedarjs/internal/dist/build/api";
 import { generate } from "@cedarjs/internal/dist/generate/generate";
+import { generateGqlormArtifacts } from "@cedarjs/internal/dist/generate/gqlormSchema";
 import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
 import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
 import { timedTelemetry } from "@cedarjs/telemetry";
+import { buildCedarApp } from "@cedarjs/vite/build";
 import { generatePrismaCommand } from "../../lib/generatePrismaClient.js";
 import { getPaths, getConfig } from "../../lib/index.js";
 import { buildPackagesTask } from "./buildPackagesTask.js";
+function checkWorkspacePackageEntryPoints(cedarPaths) {
+  const packagesDir = cedarPaths.packages;
+  if (!packagesDir || !fs.existsSync(packagesDir)) {
+    return [];
+  }
+  const problems = [];
+  const packageDirs = fs.readdirSync(packagesDir, { withFileTypes: true });
+  for (const entry of packageDirs) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const pkgJsonPath = path.join(packagesDir, entry.name, "package.json");
+    if (!fs.existsSync(pkgJsonPath)) {
+      continue;
+    }
+    const pkgJson = JSON.parse(
+      fs.readFileSync(pkgJsonPath, "utf8")
+    );
+    const pkgName = pkgJson.name || entry.name;
+    const pkgDir = path.join(packagesDir, entry.name);
+    const entryFiles = /* @__PURE__ */ new Set();
+    if (pkgJson.main) {
+      entryFiles.add(path.normalize(pkgJson.main));
+    }
+    if (pkgJson.exports) {
+      const collectPaths = (obj) => {
+        if (typeof obj === "string") {
+          if (!obj.endsWith(".d.ts")) {
+            entryFiles.add(path.normalize(obj));
+          }
+        } else if (obj && typeof obj === "object") {
+          for (const [key, value] of Object.entries(obj)) {
+            if (key !== "types") {
+              collectPaths(value);
+            }
+          }
+        }
+      };
+      collectPaths(pkgJson.exports);
+    }
+    for (const entryFile of entryFiles) {
+      const resolvedPath = path.resolve(pkgDir, entryFile);
+      if (!fs.existsSync(resolvedPath)) {
+        problems.push({ pkgName, entryFile, pkgDir });
+      }
+    }
+  }
+  return problems;
+}
 const handler = async ({
   workspace = ["api", "web", "packages/*"],
   verbose = false,
   prisma = true,
-  prerender = true
+  prerender = true,
+  ud = false,
+  apiRootPath
 }) => {
   recordTelemetryAttributes({
     command: "build",
     workspace: JSON.stringify(workspace),
     verbose,
     prisma,
-    prerender
+    prerender,
+    apiRootPath
   });
   const cedarPaths = getPaths();
   const cedarConfig = getConfig();
   const useFragments = cedarConfig.graphql?.fragments;
   const useTrustedDocuments = cedarConfig.graphql?.trustedDocuments;
+  const usePackagesWorkspace = cedarConfig.experimental?.packagesWorkspace?.enabled;
   const prismaSchemaExists = fs.existsSync(cedarPaths.api.prismaConfig);
   const prerenderRoutes = prerender && workspace.includes("web") ? detectPrerenderRoutes() : [];
   const shouldGeneratePrismaClient = prisma && prismaSchemaExists && (workspace.includes("api") || prerenderRoutes.length > 0);
-  const packageJsonPath = path.join(cedarPaths.base, "package.json");
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-  const packageJsonWorkspaces = packageJson.workspaces;
-  const nonApiWebWorkspaces = Array.isArray(packageJsonWorkspaces) && packageJsonWorkspaces.length > 2 ? workspace.filter((w) => w !== "api" && w !== "web") : [];
+  const nonApiWebWorkspaces = workspace.filter(
+    (w) => w !== "api" && w !== "web"
+  );
   const gqlFeaturesTaskTitle = `Generating types needed for ${[
     useFragments && "GraphQL Fragments",
     useTrustedDocuments && "Trusted Documents"
@@ -52,10 +116,31 @@ const handler = async ({
         });
       }
     },
-    nonApiWebWorkspaces.length > 0 && {
+    nonApiWebWorkspaces.length > 0 && usePackagesWorkspace && {
       title: "Building Packages...",
       task: (_ctx, task) => buildPackagesTask(task, nonApiWebWorkspaces)
     },
+    (workspace.includes("web") || workspace.includes("api")) && usePackagesWorkspace && {
+      title: "Checking workspace packages...",
+      task: () => {
+        const problems = checkWorkspacePackageEntryPoints(cedarPaths);
+        if (problems.length === 0) {
+          return;
+        }
+        const details = problems.map(
+          ({ pkgName, entryFile, pkgDir }) => `  \u2022 ${c.error(pkgName)}: missing "${entryFile}" (in ${pkgDir})`
+        ).join("\n");
+        throw new Error(
+          `The following workspace package entry points are missing:
+${details}
+
+This usually means the package has not been built yet.
+Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspace) to build everything,\nor build the package manually first, e.g. " + c.info(
+            formatRunWorkspaceScriptCommand(problems[0].pkgName, "build")
+          )
+        );
+      }
+    },
     // If using GraphQL Fragments or Trusted Documents, then we need to use
     // codegen to generate the types needed for possible types and the trusted
     // document store hashes
@@ -63,43 +148,125 @@ const handler = async ({
       title: gqlFeaturesTaskTitle,
       task: generate
     },
+    workspace.includes("web") && cedarConfig.experimental?.gqlorm?.enabled && {
+      title: "Generating gqlorm schema...",
+      task: async () => {
+        const { errors } = await generateGqlormArtifacts();
+        if (errors.length > 0) {
+          for (const { message } of errors) {
+            console.warn(`Warning: ${message}`);
+          }
+        }
+      }
+    },
     workspace.includes("api") && {
       title: "Verifying graphql schema...",
       task: loadAndValidateSdls
     },
-    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();
-        const { errors, warnings } = await buildApi();
-        if (errors.length) {
-          console.error(errors);
+        await buildApiWithVite();
+      }
+    },
+    workspace.includes("web") && getConfig().experimental?.streamingSsr?.enabled && {
+      title: "Building Web...",
+      task: async () => {
+        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",
+            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";
         const createdRequire = createRequire(import.meta.url);
         const buildBinPath = createdRequire.resolve(
-          "@cedarjs/vite/bins/rw-vite-build.mjs"
+          "@cedarjs/vite/bins/cedar-vite-build.mjs"
         );
         await execa(
-          `node ${buildBinPath} --webDir="${cedarPaths.web.base}" --verbose=${verbose}`,
+          "node",
+          [
+            buildBinPath,
+            `--webDir=${cedarPaths.web.base}`,
+            `--verbose=${verbose}`
+          ],
           {
             stdio: verbose ? "inherit" : "pipe",
-            shell: true,
-            // `cwd` is needed for yarn to find the rw-vite-build binary
+            // `cwd` makes postcss/tailwind config resolution work (see the
+            // @NOTE above)
             // It won't change process.cwd for anything else here, in this
             // process
             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, ud: true });
+        } finally {
+          process.chdir(originalCwd);
+        }
+        if (workspace.includes("web")) {
           console.log("Creating 200.html...");
           const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
           fs.copyFileSync(
@@ -109,34 +276,42 @@ const handler = async ({
         }
       }
     }
-  ].filter(Boolean);
-  const triggerPrerender = async () => {
-    console.log("Starting prerendering...");
-    if (prerenderRoutes.length === 0) {
-      console.log(
-        `You have not marked any routes to "prerender" in your ${terminalLink(
-          "Routes",
-          "file://" + cedarPaths.web.routes
-        )}.`
-      );
-      return;
-    }
-    await execa("yarn cedar prerender", {
-      stdio: "inherit",
-      shell: true,
-      cwd: cedarPaths.web.base
+  ];
+  if (apiRootPath !== void 0) {
+    process.env.CEDAR_API_ROOT_PATH = apiRootPath;
+  }
+  try {
+    await timedTelemetry(process.argv, { type: "build" }, async () => {
+      const listrTasks = tasks.filter((t) => Boolean(t));
+      const jobs = new Listr(listrTasks, {
+        renderer: verbose ? "verbose" : void 0
+      });
+      await jobs.run();
+      if (workspace.includes("web") && prerender && prismaSchemaExists) {
+        await triggerPrerender(prerenderRoutes);
+      }
     });
-  };
-  const jobs = new Listr(tasks, {
-    renderer: verbose ? "verbose" : void 0
-  });
-  await timedTelemetry(process.argv, { type: "build" }, async () => {
-    await jobs.run();
-    if (workspace.includes("web") && prerender && prismaSchemaExists) {
-      await triggerPrerender();
-    }
-  });
+  } finally {
+    delete process.env.CEDAR_API_ROOT_PATH;
+  }
 };
+async function triggerPrerender(prerenderRoutes) {
+  const cedarPaths = getPaths();
+  console.log("Starting prerendering...");
+  if (prerenderRoutes.length === 0) {
+    console.log(
+      `You have not marked any routes to "prerender" in your ${terminalLink(
+        "Routes",
+        "file://" + cedarPaths.web.routes
+      )}.`
+    );
+    return;
+  }
+  await runBin("cedar", ["prerender"], {
+    stdio: "inherit",
+    cwd: cedarPaths.web.base
+  });
+}
 export {
   handler
 };

package/dist/commands/build/buildPackagesTask.js

@@ -1,9 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import concurrently from "concurrently";
+import { runScript } from "@cedarjs/cli-helpers/packageManager/exec";
 import { importStatementPath } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import { exitWithError } from "../../lib/exit.js";
 import { getPaths } from "../../lib/index.js";
 async function buildPackagesTask(task, nonApiWebWorkspaces) {
   const cedarPaths = getPaths();
@@ -11,7 +10,7 @@ async function buildPackagesTask(task, nonApiWebWorkspaces) {
   const workspacePaths = nonApiWebWorkspaces.some((w) => w === "packages/*") ? await Array.fromAsync(fs.promises.glob(globPattern)) : nonApiWebWorkspaces.map((w) => {
     const workspacePath = path.join(
       cedarPaths.packages,
-      w.split("/").at(-1)
+      w.split("/").at(-1) ?? ""
     );
     if (!fs.existsSync(workspacePath)) {
       return "";
@@ -22,28 +21,30 @@ async function buildPackagesTask(task, nonApiWebWorkspaces) {
     task.skip("No packages to build at " + nonApiWebWorkspaces.join(", "));
     return;
   }
-  const { result } = concurrently(
+  return task.newListr(
     workspacePaths.map((workspacePath) => {
+      const name = workspacePath.split("/").at(-1);
       return {
-        command: `yarn build`,
-        name: workspacePath.split("/").at(-1),
-        cwd: workspacePath
+        title: name,
+        task: async () => {
+          try {
+            await runScript("build", [], { cwd: workspacePath });
+          } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            const stderr = e instanceof Error && "stderr" in e && typeof e.stderr === "string" ? e.stderr : void 0;
+            errorTelemetry(
+              process.argv,
+              `Error building package "${name}": ${message}`
+            );
+            throw new Error(`Building "${name}" failed
+
+${stderr || message}`);
+          }
+        }
       };
     }),
-    {
-      prefix: "{name} |",
-      timestampFormat: "HH:mm:ss"
-    }
+    { concurrent: true, rendererOptions: { collapseSubtasks: false } }
   );
-  await result.catch((e) => {
-    if (e?.message) {
-      errorTelemetry(
-        process.argv,
-        `Error concurrently building sides: ${e.message}`
-      );
-      exitWithError(e);
-    }
-  });
 }
 export {
   buildPackagesTask

package/dist/commands/build.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import c from "../lib/colors.js";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 import { exitWithError } from "../lib/exit.js";
 import { workspaces } from "../lib/project.js";
 import { checkNodeVersion } from "../middleware/checkNodeVersion.js";
@@ -9,7 +9,8 @@ const builder = (yargs) => {
   yargs.positional("workspace", {
     default: ["api", "web", "packages/*"],
     description: "What workspace(s) to build. Valid values are: web, api, packages/*, <package-name>",
-    type: "array"
+    type: "string",
+    array: true
   }).option("verbose", {
     alias: "v",
     default: false,
@@ -24,6 +25,13 @@ const builder = (yargs) => {
     alias: "db",
     default: true,
     description: "Generate the Prisma client"
+  }).option("ud", {
+    type: "boolean",
+    default: false,
+    description: "Build the Universal Deploy server entry (api/dist/ud/)."
+  }).option("apiRootPath", {
+    type: "string",
+    description: 'Root path where API functions are served. Overrides the apiRootPath option on cedarUniversalDeployPlugin() in your vite config. Defaults to "/".'
   }).middleware(() => {
     const check = checkNodeVersion();
     if (check.ok) {
@@ -38,6 +46,9 @@ const builder = (yargs) => {
     if (!Array.isArray(workspacesArg)) {
       return "Workspace must be an array";
     }
+    if (argv.apiRootPath && !argv.ud) {
+      return c.error("Error:") + " --apiRootPath requires --ud.\n  Use --ud to build the Universal Deploy server entry.";
+    }
     const filtered = workspacesArg.filter(
       (item) => item !== "api" && item !== "web" && item !== "packages/*"
     );

package/dist/commands/check.js

@@ -1,14 +1,12 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
-import c from "../lib/colors.js";
-import { getPaths } from "../lib/index.js";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "check";
 const aliases = ["diagnostics"];
 const description = "Get structural diagnostics for a Redwood project (experimental)";
 const handler = async () => {
   recordTelemetryAttributes({ command: "check" });
-  const { printDiagnostics, DiagnosticSeverity } = (await import("@cedarjs/structure")).default;
-  console.log("DiagnosticServerity", DiagnosticSeverity);
-  printDiagnostics(getPaths().base, {
+  const { printDiagnostics, DiagnosticSeverity } = await import("@cedarjs/structure");
+  printDiagnostics({
     getSeverityLabel: (severity) => {
       if (severity === DiagnosticSeverity.Error) {
         return c.error("error");

package/dist/commands/console.js

@@ -1,9 +1,11 @@
 const command = "console";
 const aliases = ["c"];
-const description = "Launch an interactive Redwood shell (experimental)";
-const handler = async (options) => {
-  const { handler: handler2 } = await import("./consoleHandler.js");
-  return handler2(options);
+const description = "Launch an interactive Cedar shell";
+const handler = async () => {
+  console.log(
+    "`cedar console` has been removed from the Cedar CLI.\nRun it as a standalone tool instead:\n\n  yarn dlx @cedarjs/console\n  npx @cedarjs/console\n  pnpm dlx @cedarjs/console\n"
+  );
+  process.exit(1);
 };
 export {
   aliases,

package/dist/commands/deploy/baremetal/SshExecutor.js

@@ -1,5 +1,15 @@
 import { NodeSSH } from "node-ssh";
+class ExecError extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "ExecError";
+    this.exitCode = exitCode;
+  }
+}
 class SshExecutor {
+  ssh;
+  verbose;
   constructor(verbose) {
     this.ssh = new NodeSSH();
     this.verbose = verbose;
@@ -20,12 +30,11 @@ class SshExecutor {
       cwd: path
     });
     if (result.code !== 0) {
-      const error = new Error(
+      throw new ExecError(
         `Error while running command \`${sshCommand}\` in ${path}
-` + result.stderr
+` + result.stderr,
+        result.code
       );
-      error.exitCode = result.code;
-      throw error;
     }
     return result;
   }