@cedarjs/cli 0.0.4

package/dist/commands/generate/yargsHandlerHelpers.js

@@ -0,0 +1,155 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Listr } from "listr2";
+import pascalcase from "pascalcase";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { ensurePosixPath, getConfig } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../lib/colors.js";
+import { generateTemplate, getPaths, writeFilesTask } from "../../lib/index.js";
+import { prepareForRollback } from "../../lib/rollback.js";
+import {
+  createCommand,
+  createDescription,
+  createBuilder
+} from "./yargsCommandHelpers.js";
+const customOrDefaultTemplatePath = ({
+  side,
+  generator,
+  templatePath
+}) => {
+  const defaultPath = path.join(
+    import.meta.dirname,
+    generator,
+    "templates",
+    templatePath
+  );
+  const customPath = path.join(
+    getPaths()[side].generators,
+    generator,
+    templatePath
+  );
+  if (fs.existsSync(customPath)) {
+    return customPath;
+  } else {
+    return defaultPath;
+  }
+};
+const templateForComponentFile = async ({
+  name,
+  suffix = "",
+  extension = ".js",
+  webPathSection,
+  apiPathSection,
+  generator,
+  templatePath,
+  templateVars,
+  componentName,
+  outputPath
+}) => {
+  const basePath = webPathSection ? getPaths().web[webPathSection] : getPaths().api[apiPathSection];
+  const outputComponentName = componentName || pascalcase(name) + suffix;
+  const componentOutputPath = outputPath || path.join(basePath, outputComponentName, outputComponentName + extension);
+  const fullTemplatePath = customOrDefaultTemplatePath({
+    generator,
+    templatePath,
+    side: webPathSection ? "web" : "api"
+  });
+  const content = await generateTemplate(fullTemplatePath, {
+    name,
+    outputPath: ensurePosixPath(
+      `./${path.relative(getPaths().base, componentOutputPath)}`
+    ),
+    ...templateVars
+  });
+  return [componentOutputPath, content];
+};
+const validateName = (name) => {
+  if (name.match(/^\W/)) {
+    throw new Error(
+      "The <name> argument must start with a letter, number or underscore."
+    );
+  }
+};
+function createHandler({
+  componentName,
+  preTasksFn = (argv) => argv,
+  filesFn,
+  includeAdditionalTasks = () => []
+}) {
+  return async (argv) => {
+    recordTelemetryAttributes({
+      command: `generate ${componentName}`,
+      tests: argv.tests,
+      stories: argv.stories,
+      verbose: argv.verbose,
+      rollback: argv.rollback,
+      force: argv.force
+      // TODO: This does not cover the specific options that each generator might pass in
+    });
+    if (argv.tests === void 0) {
+      argv.tests = getConfig().generate.tests;
+    }
+    if (argv.stories === void 0) {
+      argv.stories = getConfig().generate.stories;
+    }
+    validateName(argv.name);
+    try {
+      argv = await preTasksFn(argv);
+      const tasks = new Listr(
+        [
+          {
+            title: `Generating ${componentName} files...`,
+            task: async () => {
+              const f = await filesFn(argv);
+              return writeFilesTask(f, { overwriteExisting: argv.force });
+            }
+          },
+          ...includeAdditionalTasks(argv)
+        ],
+        {
+          rendererOptions: { collapseSubtasks: false },
+          exitOnError: true,
+          renderer: argv.verbose && "verbose"
+        }
+      );
+      if (argv.rollback && !argv.force) {
+        prepareForRollback(tasks);
+      }
+      await tasks.run();
+    } catch (e) {
+      errorTelemetry(process.argv, e.message);
+      console.error(c.error(e.message));
+      process.exit(e?.exitCode || 1);
+    }
+  };
+}
+const createYargsForComponentGeneration = ({
+  componentName,
+  preTasksFn = (options) => options,
+  /** filesFn is not used if generator implements its own `handler` */
+  filesFn = () => ({}),
+  optionsObj,
+  positionalsObj = {},
+  /** function that takes the options object and returns an array of listr tasks */
+  includeAdditionalTasks = () => []
+}) => {
+  return {
+    command: createCommand(componentName, positionalsObj),
+    description: createDescription(componentName),
+    builder: createBuilder({ componentName, optionsObj, positionalsObj }),
+    handler: createHandler({
+      componentName,
+      preTasksFn,
+      filesFn,
+      includeAdditionalTasks
+    })
+  };
+};
+export {
+  createHandler,
+  createYargsForComponentGeneration,
+  customOrDefaultTemplatePath,
+  templateForComponentFile,
+  validateName
+};

package/dist/commands/generate.js

@@ -0,0 +1,44 @@
+import execa from "execa";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import * as generateCell from "./generate/cell/cell.js";
+import * as generateComponent from "./generate/component/component.js";
+import * as generateDataMigration from "./generate/dataMigration/dataMigration.js";
+import * as generateDbAuth from "./generate/dbAuth/dbAuth.js";
+import * as generateDirective from "./generate/directive/directive.js";
+import * as generateFunction from "./generate/function/function.js";
+import * as generateJob from "./generate/job/job.js";
+import * as generateLayout from "./generate/layout/layout.js";
+import * as generateModel from "./generate/model/model.js";
+import * as generateOgImage from "./generate/ogImage/ogImage.js";
+import * as generatePage from "./generate/page/page.js";
+import * as generateRealtime from "./generate/realtime/realtime.js";
+import * as generateScaffold from "./generate/scaffold/scaffold.js";
+import * as generateScript from "./generate/script/script.js";
+import * as generateSdl from "./generate/sdl/sdl.js";
+import * as generateSecret from "./generate/secret/secret.js";
+import * as generateService from "./generate/service/service.js";
+const command = "generate <type>";
+const aliases = ["g"];
+const description = "Generate boilerplate code and type definitions";
+const builder = (yargs) => yargs.command("types", "Generate supplementary code", {}, () => {
+  recordTelemetryAttributes({
+    command: "generate types"
+  });
+  try {
+    execa.sync("yarn rw-gen", { shell: true, stdio: "inherit" });
+  } catch (error) {
+    process.exitCode = error.exitCode ?? 1;
+  }
+}).command(generateCell).command(generateComponent).command(generateDataMigration).command(generateDbAuth).command(generateDirective).command(generateFunction).command(generateJob).command(generateLayout).command(generateModel).command(generateOgImage).command(generatePage).command(generateRealtime).command(generateScaffold).command(generateScript).command(generateSdl).command(generateSecret).command(generateService).demandCommand().epilogue(
+  `Also see the ${terminalLink(
+    "Redwood CLI Reference",
+    "https://redwoodjs.com/docs/cli-commands#generate-alias-g"
+  )}`
+);
+export {
+  aliases,
+  builder,
+  command,
+  description
+};

package/dist/commands/info.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import envinfo from "envinfo";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getPaths } from "@cedarjs/project-config";
+const command = "info";
+const description = "Print your system environment information";
+const builder = (yargs) => {
+  yargs.epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#info"
+    )}`
+  );
+};
+const handler = async () => {
+  recordTelemetryAttributes({ command: "info" });
+  const output = await envinfo.run({
+    System: ["OS", "Shell"],
+    Binaries: ["Node", "Yarn"],
+    Browsers: ["Chrome", "Edge", "Firefox", "Safari"],
+    // yarn workspaces not supported :-/
+    npmPackages: "@cedarjs/*",
+    Databases: ["SQLite"]
+  });
+  const redwoodToml = fs.readFileSync(getPaths().base + "/redwood.toml", "utf8");
+  console.log(
+    output + "  redwood.toml:\n" + redwoodToml.split("\n").filter((line) => line.trim().length > 0).filter((line) => !/^#/.test(line)).map((line) => `    ${line}`).join("\n")
+  );
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/jobs.js

@@ -0,0 +1,17 @@
+const command = "jobs";
+const description = "Starts the RedwoodJob runner to process background jobs";
+const builder = (yargs) => {
+  yargs.strictOptions(false).strictCommands(false).strict(false).parserConfiguration({
+    "camel-case-expansion": false
+  }).help(false).version(false);
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./jobsHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/jobsHandler.js

@@ -0,0 +1,30 @@
+import execa from "execa";
+import { getPaths } from "../lib/index.js";
+const handler = async ({
+  _,
+  $0: _rw,
+  commands: _commands,
+  ...options
+}) => {
+  const args = [_.pop()];
+  for (const [name, value] of Object.entries(options)) {
+    args.push(name.length > 1 ? `--${name}` : `-${name}`);
+    args.push(value);
+  }
+  let command = `yarn rw-jobs ${args.join(" ")}`;
+  const originalLogLevel = process.env.LOG_LEVEL;
+  process.env.LOG_LEVEL = originalLogLevel || "warn";
+  if (process.env.NODE_ENV !== "production") {
+    command += " | yarn rw-log-formatter";
+    process.env.LOG_LEVEL = originalLogLevel || "debug";
+  }
+  execa.commandSync(command, {
+    shell: true,
+    cwd: getPaths().base,
+    stdio: "inherit",
+    cleanup: true
+  });
+};
+export {
+  handler
+};

package/dist/commands/lint.js

@@ -0,0 +1,57 @@
+import execa from "execa";
+import fs from "fs-extra";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getPaths } from "../lib/index.js";
+const command = "lint [path..]";
+const description = "Lint your files";
+const builder = (yargs) => {
+  yargs.positional("path", {
+    description: "Specify file(s) or directory(ies) to lint relative to project root",
+    type: "array"
+  }).option("fix", {
+    default: false,
+    description: "Try to fix errors",
+    type: "boolean"
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#lint"
+    )}`
+  );
+};
+const handler = async ({ path, fix }) => {
+  recordTelemetryAttributes({
+    command: "lint",
+    fix
+  });
+  try {
+    const pathString = path?.join(" ");
+    const result = await execa(
+      "yarn eslint",
+      [
+        fix && "--fix",
+        !pathString && fs.existsSync(getPaths().web.src) && "web/src",
+        !pathString && fs.existsSync(getPaths().web.config) && "web/config",
+        !pathString && fs.existsSync(getPaths().web.storybook) && "web/.storybook",
+        !pathString && fs.existsSync(getPaths().scripts) && "scripts",
+        !pathString && fs.existsSync(getPaths().api.src) && "api/src",
+        pathString
+      ].filter(Boolean),
+      {
+        cwd: getPaths().base,
+        shell: true,
+        stdio: "inherit"
+      }
+    );
+    process.exitCode = result.exitCode;
+  } catch (error) {
+    process.exitCode = error.exitCode ?? 1;
+  }
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/prerender.js

@@ -0,0 +1,34 @@
+const command = "prerender";
+const aliases = ["render"];
+const description = "Prerender pages of your Redwood app at build time";
+const builder = (yargs) => {
+  yargs.showHelpOnFail(false);
+  yargs.option("path", {
+    alias: ["p", "route"],
+    description: "Router path to prerender. Especially useful for debugging",
+    type: "string"
+  });
+  yargs.option("dry-run", {
+    alias: ["d", "dryrun"],
+    default: false,
+    description: "Run prerender and output to console",
+    type: "boolean"
+  });
+  yargs.option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more",
+    type: "boolean"
+  });
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./prerenderHandler.js");
+  return handler2(options);
+};
+export {
+  aliases,
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/prerenderHandler.js

@@ -0,0 +1,282 @@
+import path from "path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { runPrerender, writePrerenderedHtmlFile } from "@cedarjs/prerender";
+import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../lib/colors.js";
+import { configureBabel, runScriptFunction } from "../lib/exec.js";
+class PathParamError extends Error {
+}
+const mapRouterPathToHtml = (routerPath) => {
+  if (routerPath === "/") {
+    return "web/dist/index.html";
+  } else {
+    return `web/dist${routerPath}.html`;
+  }
+};
+function getRouteHooksFilePath(routeFilePath) {
+  const routeHooksFilePathTs = routeFilePath.replace(
+    /\.[jt]sx?$/,
+    ".routeHooks.ts"
+  );
+  if (fs.existsSync(routeHooksFilePathTs)) {
+    return routeHooksFilePathTs;
+  }
+  const routeHooksFilePathJs = routeFilePath.replace(
+    /\.[jt]sx?$/,
+    ".routeHooks.js"
+  );
+  if (fs.existsSync(routeHooksFilePathJs)) {
+    return routeHooksFilePathJs;
+  }
+  return void 0;
+}
+async function expandRouteParameters(route) {
+  const routeHooksFilePath = getRouteHooksFilePath(route.filePath);
+  if (!routeHooksFilePath) {
+    return [route];
+  }
+  try {
+    const routeParameters = await runScriptFunction({
+      path: routeHooksFilePath,
+      functionName: "routeParameters",
+      args: {
+        name: route.name,
+        path: route.path,
+        routePath: route.routePath,
+        filePath: route.filePath
+      }
+    });
+    if (routeParameters) {
+      return routeParameters.map((pathParamValues) => {
+        let newPath = route.path;
+        Object.entries(pathParamValues).forEach(([paramName, paramValue]) => {
+          newPath = newPath.replace(
+            new RegExp(`{${paramName}:?[^}]*}`),
+            paramValue
+          );
+        });
+        return { ...route, path: newPath };
+      });
+    }
+  } catch (e) {
+    console.error(c.error(e.stack));
+    return [route];
+  }
+  return [route];
+}
+const getTasks = async (dryrun, routerPathFilter = null) => {
+  const prerenderRoutes = detectPrerenderRoutes().filter((route) => route.path);
+  const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
+  if (prerenderRoutes.length === 0) {
+    console.log("\nSkipping prerender...");
+    console.log(
+      c.warning(
+        "You have not marked any routes with a path as `prerender` in `Routes.{jsx,tsx}` \n"
+      )
+    );
+    return [];
+  }
+  if (!fs.existsSync(indexHtmlPath)) {
+    console.error(
+      "You must run `yarn rw build web` before trying to prerender."
+    );
+    process.exit(1);
+  }
+  configureBabel();
+  const expandedRouteParameters = await Promise.all(
+    prerenderRoutes.map((route) => expandRouteParameters(route))
+  );
+  const listrTasks = expandedRouteParameters.flatMap((routesToPrerender) => {
+    const queryCache = {};
+    const shouldFold = routesToPrerender.length > 16;
+    if (shouldFold) {
+      const displayIncrement = Math.max(
+        1,
+        Math.floor(routesToPrerender.length / 100)
+      );
+      const title = (i) => `Prerendering ${routesToPrerender[0].name} (${i.toLocaleString()} of ${routesToPrerender.length.toLocaleString()})`;
+      return [
+        {
+          title: title(0),
+          task: async (_, task) => {
+            for (let i = 0; i < routesToPrerender.length; i++) {
+              const routeToPrerender = routesToPrerender[i];
+              if (routerPathFilter && routeToPrerender.path !== routerPathFilter) {
+                continue;
+              }
+              await prerenderRoute(
+                queryCache,
+                routeToPrerender,
+                dryrun,
+                mapRouterPathToHtml(routeToPrerender.path)
+              );
+              if (i % displayIncrement === 0) {
+                task.title = title(i);
+              }
+            }
+            task.title = title(routesToPrerender.length);
+          }
+        }
+      ];
+    }
+    return routesToPrerender.map((routeToPrerender) => {
+      if (routerPathFilter && routeToPrerender.path !== routerPathFilter) {
+        return [];
+      }
+      const outputHtmlPath = mapRouterPathToHtml(routeToPrerender.path);
+      return {
+        title: `Prerendering ${routeToPrerender.path} -> ${outputHtmlPath}`,
+        task: async () => {
+          await prerenderRoute(
+            queryCache,
+            routeToPrerender,
+            dryrun,
+            outputHtmlPath
+          );
+        }
+      };
+    });
+  });
+  return listrTasks;
+};
+const diagnosticCheck = () => {
+  const checks = [
+    {
+      message: "Duplicate React version found in web/node_modules",
+      failure: fs.existsSync(
+        path.join(getPaths().web.base, "node_modules/react")
+      )
+    },
+    {
+      message: "Duplicate react-dom version found in web/node_modules",
+      failure: fs.existsSync(
+        path.join(getPaths().web.base, "node_modules/react-dom")
+      )
+    },
+    {
+      message: "Duplicate core-js version found in web/node_modules",
+      failure: fs.existsSync(
+        path.join(getPaths().web.base, "node_modules/core-js")
+      )
+    },
+    {
+      message: "Duplicate @cedarjs/web version found in web/node_modules",
+      failure: fs.existsSync(
+        path.join(getPaths().web.base, "node_modules/@cedarjs/web")
+      )
+    }
+  ];
+  console.log("Running diagnostic checks");
+  if (checks.some((checks2) => checks2.failure)) {
+    console.error(c.error("node_modules are being duplicated in `./web` \n"));
+    console.log("\u26A0\uFE0F  Issues found: ");
+    console.log("-".repeat(50));
+    checks.filter((check) => check.failure).forEach((check, i) => {
+      console.log(`${i + 1}. ${check.message}`);
+    });
+    console.log("-".repeat(50));
+    console.log(
+      "Diagnostic check found issues. See the Redwood Forum link below for help:"
+    );
+    console.log(
+      c.underline(
+        "https://community.redwoodjs.com/search?q=duplicate%20package%20found"
+      )
+    );
+    console.log();
+    process.exit(1);
+  } else {
+    console.log("\u2714 Diagnostics checks passed \n");
+  }
+};
+const prerenderRoute = async (queryCache, routeToPrerender, dryrun, outputHtmlPath) => {
+  if (/\{.*}/.test(routeToPrerender.path)) {
+    throw new PathParamError(
+      `Could not retrieve route parameters for ${routeToPrerender.path}`
+    );
+  }
+  try {
+    const prerenderedHtml = await runPrerender({
+      queryCache,
+      renderPath: routeToPrerender.path
+    });
+    if (!dryrun) {
+      writePrerenderedHtmlFile(outputHtmlPath, prerenderedHtml);
+    }
+  } catch (e) {
+    console.log();
+    console.log(c.warning("You can use `yarn rw prerender --dry-run` to debug"));
+    console.log();
+    console.log(
+      `${c.info("-".repeat(10))} Error rendering path "${routeToPrerender.path}" ${c.info("-".repeat(10))}`
+    );
+    errorTelemetry(process.argv, `Error prerendering: ${e.message}`);
+    console.error(c.error(e.stack));
+    console.log();
+    throw new Error(`Failed to render "${routeToPrerender.filePath}"`);
+  }
+};
+const handler = async ({ path: routerPath, dryRun, verbose }) => {
+  if (getConfig().experimental?.streamingSsr?.enabled) {
+    console.log(
+      c.warning(
+        "Prerendering is not yet supported with Streaming SSR. Skipping prerender..."
+      )
+    );
+    return;
+  }
+  recordTelemetryAttributes({
+    command: "prerender",
+    dryRun,
+    verbose
+  });
+  const listrTasks = await getTasks(dryRun, routerPath);
+  const tasks = new Listr(listrTasks, {
+    renderer: verbose ? "verbose" : "default",
+    rendererOptions: { collapseSubtasks: false },
+    concurrent: false
+  });
+  try {
+    if (dryRun) {
+      console.log(c.info("::: Dry run, not writing changes :::"));
+    }
+    await tasks.run();
+  } catch (e) {
+    console.log();
+    await diagnosticCheck();
+    console.log(c.warning("Tips:"));
+    if (e instanceof PathParamError) {
+      console.log(
+        c.info(
+          "- You most likely need to add or update a *.routeHooks.{js,ts} file next to the Page you're trying to prerender"
+        )
+      );
+    } else {
+      console.log(
+        c.info(
+          `- This could mean that a library you're using does not support SSR.`
+        )
+      );
+      console.log(
+        c.info(
+          "- Avoid using `window` in the initial render path through your React components without checks. \n  See https://redwoodjs.com/docs/prerender#prerender-utils"
+        )
+      );
+      console.log(
+        c.info(
+          "- Avoid prerendering Cells with authenticated queries, by conditionally rendering them.\n  See https://redwoodjs.com/docs/prerender#common-warnings--errors"
+        )
+      );
+    }
+    console.log();
+    process.exit(1);
+  }
+};
+export {
+  getTasks,
+  handler
+};

package/dist/commands/prisma.js

@@ -0,0 +1,17 @@
+const command = "prisma [commands..]";
+const description = "Run Prisma CLI with experimental features";
+const builder = (yargs) => {
+  yargs.strictOptions(false).strictCommands(false).strict(false).parserConfiguration({
+    "camel-case-expansion": false
+  }).help(false).version(false);
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./prismaHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};