@cedarjs/cli 0.0.4

package/dist/commands/build.js

@@ -0,0 +1,54 @@
+import terminalLink from "terminal-link";
+import c from "../lib/colors.js";
+import { exitWithError } from "../lib/exit.js";
+import { sides } from "../lib/project.js";
+import { checkNodeVersion } from "../middleware/checkNodeVersion.js";
+const command = "build [side..]";
+const description = "Build for production";
+const builder = (yargs) => {
+  const choices = sides();
+  yargs.positional("side", {
+    choices,
+    default: choices,
+    description: "Which side(s) to build",
+    type: "array"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more",
+    type: "boolean"
+  }).option("prerender", {
+    default: true,
+    description: "Prerender after building web",
+    type: "boolean"
+  }).option("prisma", {
+    type: "boolean",
+    alias: "db",
+    default: true,
+    description: "Generate the Prisma client"
+  }).middleware(() => {
+    const check = checkNodeVersion();
+    if (check.ok) {
+      return;
+    }
+    exitWithError(void 0, {
+      message: `${c.error("Error")}: ${check.message}`,
+      includeEpilogue: false
+    });
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#build"
+    )}`
+  );
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./buildHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/buildHandler.js

@@ -0,0 +1,134 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import execa from "execa";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { buildApi, cleanApiBuild } from "@cedarjs/internal/dist/build/api";
+import { generate } from "@cedarjs/internal/dist/generate/generate";
+import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
+import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
+import { timedTelemetry } from "@cedarjs/telemetry";
+import { generatePrismaCommand } from "../lib/generatePrismaClient.js";
+import { getPaths, getConfig } from "../lib/index.js";
+const handler = async ({
+  side = ["api", "web"],
+  verbose = false,
+  prisma = true,
+  prerender
+}) => {
+  recordTelemetryAttributes({
+    command: "build",
+    side: JSON.stringify(side),
+    verbose,
+    prisma,
+    prerender
+  });
+  const rwjsPaths = getPaths();
+  const rwjsConfig = getConfig();
+  const useFragments = rwjsConfig.graphql?.fragments;
+  const useTrustedDocuments = rwjsConfig.graphql?.trustedDocuments;
+  const prismaSchemaExists = fs.existsSync(rwjsPaths.api.dbSchema);
+  const prerenderRoutes = prerender && side.includes("web") ? detectPrerenderRoutes() : [];
+  const shouldGeneratePrismaClient = prisma && prismaSchemaExists && (side.includes("api") || prerenderRoutes.length > 0);
+  const tasks = [
+    shouldGeneratePrismaClient && {
+      title: "Generating Prisma Client...",
+      task: () => {
+        const { cmd, args } = generatePrismaCommand(rwjsPaths.api.dbSchema);
+        return execa(cmd, args, {
+          stdio: verbose ? "inherit" : "pipe",
+          shell: true,
+          cwd: rwjsPaths.api.base
+        });
+      }
+    },
+    // 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
+    (useFragments || useTrustedDocuments) && {
+      title: `Generating types needed for ${[
+        useFragments && "GraphQL Fragments",
+        useTrustedDocuments && "Trusted Documents"
+      ].filter(Boolean).join(" and ")} support...`,
+      task: async () => {
+        await generate();
+      }
+    },
+    side.includes("api") && {
+      title: "Verifying graphql schema...",
+      task: loadAndValidateSdls
+    },
+    side.includes("api") && {
+      title: "Building API...",
+      task: async () => {
+        await cleanApiBuild();
+        const { errors, warnings } = await buildApi();
+        if (errors.length) {
+          console.error(errors);
+        }
+        if (warnings.length) {
+          console.warn(warnings);
+        }
+      }
+    },
+    side.includes("web") && {
+      title: "Building Web...",
+      task: async () => {
+        process.env.VITE_CJS_IGNORE_WARNING = "true";
+        const createdRequire = createRequire(import.meta.url);
+        await execa(
+          `node ${createdRequire.resolve(
+            "@cedarjs/vite/bins/rw-vite-build.mjs"
+          )} --webDir="${rwjsPaths.web.base}" --verbose=${verbose}`,
+          {
+            stdio: verbose ? "inherit" : "pipe",
+            shell: true,
+            // `cwd` is needed for yarn to find the rw-vite-build binary
+            // It won't change process.cwd for anything else here, in this
+            // process
+            cwd: rwjsPaths.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")
+          );
+        }
+      }
+    }
+  ].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://" + rwjsPaths.web.routes
+        )}.`
+      );
+      return;
+    }
+    await execa("yarn rw prerender", {
+      stdio: "inherit",
+      shell: true,
+      cwd: rwjsPaths.web.base
+    });
+  };
+  const jobs = new Listr(tasks, {
+    renderer: verbose && "verbose"
+  });
+  await timedTelemetry(process.argv, { type: "build" }, async () => {
+    await jobs.run();
+    if (side.includes("web") && prerender && prismaSchemaExists) {
+      await triggerPrerender();
+    }
+  });
+};
+export {
+  handler
+};

package/dist/commands/check.js

@@ -0,0 +1,28 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import c from "../lib/colors.js";
+import { getPaths } from "../lib/index.js";
+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, {
+    getSeverityLabel: (severity) => {
+      if (severity === DiagnosticSeverity.Error) {
+        return c.error("error");
+      }
+      if (severity === DiagnosticSeverity.Warning) {
+        return c.warning("warning");
+      }
+      return c.info("info");
+    }
+  });
+};
+export {
+  aliases,
+  command,
+  description,
+  handler
+};

package/dist/commands/console.js

@@ -0,0 +1,13 @@
+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);
+};
+export {
+  aliases,
+  command,
+  description,
+  handler
+};

package/dist/commands/consoleHandler.js

@@ -0,0 +1,68 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import repl from "node:repl";
+import fs from "fs-extra";
+import { registerApiSideBabelHook } from "@cedarjs/babel-config";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getPaths } from "../lib/index.js";
+const paths = getPaths();
+const loadPrismaClient = (replContext) => {
+  const createdRequire = createRequire(import.meta.url);
+  const { db } = createdRequire(path.join(paths.api.lib, "db"));
+  db[Symbol.for("nodejs.util.inspect.custom")] = "PrismaClient";
+  replContext.db = db;
+};
+const consoleHistoryFile = path.join(paths.generated.base, "console_history");
+const persistConsoleHistory = (r) => {
+  fs.appendFileSync(
+    consoleHistoryFile,
+    r.lines.filter((line) => line.trim()).join("\n") + "\n",
+    "utf8"
+  );
+};
+const loadConsoleHistory = async (r) => {
+  try {
+    const history = await fs.promises.readFile(consoleHistoryFile, "utf8");
+    history.split("\n").reverse().map((line) => r.history.push(line));
+  } catch (e) {
+  }
+};
+const handler = () => {
+  recordTelemetryAttributes({
+    command: "console"
+  });
+  registerApiSideBabelHook({
+    plugins: [
+      [
+        "babel-plugin-module-resolver",
+        {
+          alias: {
+            src: paths.api.src
+          }
+        },
+        "rwjs-console-module-resolver"
+      ]
+    ]
+  });
+  const r = repl.start();
+  const defaultEval = r.eval;
+  r.eval = (cmd, context, filename, callback) => {
+    defaultEval(cmd, context, filename, async (err, result) => {
+      if (err) {
+        callback(err);
+      } else {
+        try {
+          callback(null, await Promise.resolve(result));
+        } catch (err2) {
+          callback(err2);
+        }
+      }
+    });
+  };
+  loadConsoleHistory(r);
+  r.addListener("close", () => persistConsoleHistory(r));
+  loadPrismaClient(r.context);
+};
+export {
+  handler
+};

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

@@ -0,0 +1,41 @@
+import { NodeSSH } from "node-ssh";
+class SshExecutor {
+  constructor(verbose) {
+    this.ssh = new NodeSSH();
+    this.verbose = verbose;
+  }
+  /**
+   * Executes a single command via SSH connection. Throws an error and sets
+   * the exit code with the same code returned from the SSH command.
+   */
+  async exec(path, command, args) {
+    const argsString = args?.join(" ") || "";
+    const sshCommand = command + (argsString ? ` ${argsString}` : "");
+    if (this.verbose) {
+      console.log(
+        `SshExecutor::exec running command \`${sshCommand}\` in ${path}`
+      );
+    }
+    const result = await this.ssh.execCommand(sshCommand, {
+      cwd: path
+    });
+    if (result.code !== 0) {
+      const error = new Error(
+        `Error while running command \`${sshCommand}\` in ${path}
+` + result.stderr
+      );
+      error.exitCode = result.code;
+      throw error;
+    }
+    return result;
+  }
+  connect(options) {
+    return this.ssh.connect(options);
+  }
+  dispose() {
+    return this.ssh.dispose();
+  }
+}
+export {
+  SshExecutor
+};