@cedarjs/cli 0.0.4

package/dist/commands/exec.js

@@ -0,0 +1,38 @@
+import terminalLink from "terminal-link";
+const command = "exec [name]";
+const description = "Run scripts generated with yarn generate script";
+const builder = (yargs) => {
+  yargs.positional("name", {
+    description: "The file name (extension is optional) of the script to run",
+    type: "string"
+  }).option("prisma", {
+    type: "boolean",
+    default: true,
+    description: "Generate the Prisma client"
+  }).option("list", {
+    alias: "l",
+    type: "boolean",
+    default: false,
+    description: "List available scripts"
+  }).option("silent", {
+    alias: "s",
+    type: "boolean",
+    default: false,
+    description: "Silence Redwood's output, leaving only the script output"
+  }).strict(false).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#up"
+    )}`
+  );
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./execHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/execHandler.js

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import path from "node:path";
+import { context } from "@opentelemetry/api";
+import { suppressTracing } from "@opentelemetry/core";
+import { Listr } from "listr2";
+import {
+  getWebSideDefaultBabelConfig,
+  registerApiSideBabelHook
+} from "@cedarjs/babel-config";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { findScripts } from "@cedarjs/internal/dist/files";
+import c from "../lib/colors.js";
+import { runScriptFunction } from "../lib/exec.js";
+import { generatePrismaClient } from "../lib/generatePrismaClient.js";
+import { getPaths } from "../lib/index.js";
+const printAvailableScriptsToConsole = () => {
+  const scripts = findScripts(getPaths().scripts).reduce((acc, scriptPath) => {
+    const relativePath = path.relative(getPaths().scripts, scriptPath);
+    const ext = path.parse(relativePath).ext;
+    const pathNoExt = relativePath.slice(0, -ext.length);
+    acc[pathNoExt] ||= [];
+    acc[pathNoExt].push(relativePath);
+    return acc;
+  }, {});
+  console.log("Available scripts:");
+  Object.entries(scripts).forEach(([name, paths]) => {
+    if (paths.length > 1) {
+      paths.forEach((scriptPath) => {
+        console.log(c.info(`- ${scriptPath}`));
+      });
+    } else {
+      console.log(c.info(`- ${name}`));
+    }
+  });
+  console.log();
+};
+const handler = async (args) => {
+  recordTelemetryAttributes({
+    command: "exec",
+    prisma: args.prisma,
+    list: args.list
+  });
+  const { name, prisma, list, ...scriptArgs } = args;
+  if (list || !name) {
+    printAvailableScriptsToConsole();
+    return;
+  }
+  const {
+    overrides: _overrides,
+    plugins: webPlugins,
+    ...otherWebConfig
+  } = getWebSideDefaultBabelConfig();
+  registerApiSideBabelHook({
+    plugins: [
+      [
+        "babel-plugin-module-resolver",
+        {
+          alias: {
+            $api: getPaths().api.base,
+            $web: getPaths().web.base,
+            api: getPaths().api.base,
+            web: getPaths().web.base
+          },
+          loglevel: "silent"
+          // to silence the unnecessary warnings
+        },
+        "exec-$side-module-resolver"
+      ]
+    ],
+    overrides: [
+      {
+        test: ["./api/"],
+        plugins: [
+          [
+            "babel-plugin-module-resolver",
+            {
+              alias: {
+                src: getPaths().api.src
+              },
+              loglevel: "silent"
+            },
+            "exec-api-src-module-resolver"
+          ]
+        ]
+      },
+      {
+        test: ["./web/"],
+        plugins: [
+          ...webPlugins,
+          [
+            "babel-plugin-module-resolver",
+            {
+              alias: {
+                src: getPaths().web.src
+              },
+              loglevel: "silent"
+            },
+            "exec-web-src-module-resolver"
+          ]
+        ],
+        ...otherWebConfig
+      }
+    ]
+  });
+  const scriptPath = resolveScriptPath(name);
+  if (!scriptPath) {
+    console.error(
+      c.error(`
+No script called \`${name}\` in the ./scripts folder.
+`)
+    );
+    printAvailableScriptsToConsole();
+    process.exit(1);
+  }
+  const scriptTasks = [
+    {
+      title: "Generating Prisma client",
+      enabled: () => prisma,
+      task: () => generatePrismaClient({
+        force: false,
+        verbose: !args.silent,
+        silent: args.silent
+      })
+    },
+    {
+      title: "Running script",
+      task: async () => {
+        try {
+          await runScriptFunction({
+            path: scriptPath,
+            functionName: "default",
+            args: { args: scriptArgs }
+          });
+        } catch (e) {
+          console.error(c.error(`Error in script: ${e.message}`));
+          throw e;
+        }
+      }
+    }
+  ];
+  const tasks = new Listr(scriptTasks, {
+    rendererOptions: { collapseSubtasks: false },
+    renderer: args.silent ? "silent" : "verbose"
+  });
+  await context.with(suppressTracing(context.active()), async () => {
+    await tasks.run();
+  });
+};
+function resolveScriptPath(name) {
+  const scriptPath = path.join(getPaths().scripts, name);
+  if (fs.existsSync(scriptPath)) {
+    return scriptPath;
+  }
+  const extensions = [".js", ".jsx", ".ts", ".tsx"];
+  const matches = [];
+  for (const extension of extensions) {
+    const p = scriptPath + extension;
+    if (fs.existsSync(p)) {
+      matches.push(p);
+    }
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  } else if (matches.length > 1) {
+    console.error(
+      c.error(
+        `
+Multiple scripts found for \`${name}\`. Please specify the extension.`
+      )
+    );
+    matches.forEach((match) => {
+      console.log(c.info(`- ${path.relative(getPaths().scripts, match)}`));
+    });
+    process.exit(1);
+  }
+  return null;
+}
+export {
+  handler
+};

package/dist/commands/experimental/setupInngest.js

@@ -0,0 +1,28 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getEpilogue } from "./util.js";
+const command = "setup-inngest";
+const description = "Setup Inngest for background, scheduled, delayed, multi-step, and fan-out jobs";
+const EXPERIMENTAL_TOPIC_ID = 4866;
+const builder = (yargs) => {
+  yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  }).epilogue(getEpilogue(command, description, EXPERIMENTAL_TOPIC_ID, true));
+};
+const handler = async (options) => {
+  recordTelemetryAttributes({
+    command: "experimental setup-inngest",
+    force: options.force
+  });
+  const { handler: handler2 } = await import("./setupInngestHandler.js");
+  return handler2(options);
+};
+export {
+  EXPERIMENTAL_TOPIC_ID,
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/experimental/setupInngestHandler.js

@@ -0,0 +1,46 @@
+import execa from "execa";
+import { Listr } from "listr2";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../lib/colors.js";
+import { getPaths } from "../../lib/index.js";
+import { command, description, EXPERIMENTAL_TOPIC_ID } from "./setupInngest.js";
+import { printTaskEpilogue } from "./util.js";
+const handler = async ({ force }) => {
+  const tasks = new Listr([
+    {
+      title: `Adding Inngest setup packages for RedwoodJS ...`,
+      task: async () => {
+        await execa("yarn", ["add", "-D", "inngest-setup-redwoodjs"], {
+          cwd: getPaths().base
+        });
+      }
+    },
+    {
+      task: async () => {
+        const pluginCommands = ["inngest-setup-redwoodjs", "plugin"];
+        if (force) {
+          pluginCommands.push("--force");
+        }
+        await execa("yarn", [...pluginCommands], {
+          stdout: "inherit",
+          cwd: getPaths().base
+        });
+      }
+    },
+    {
+      task: () => {
+        printTaskEpilogue(command, description, EXPERIMENTAL_TOPIC_ID);
+      }
+    }
+  ]);
+  try {
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  handler
+};

package/dist/commands/experimental/setupOpentelemetry.js

@@ -0,0 +1,34 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getEpilogue } from "./util.js";
+const command = "setup-opentelemetry";
+const description = "Setup OpenTelemetry within the API side";
+const EXPERIMENTAL_TOPIC_ID = 4772;
+const builder = (yargs) => {
+  yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more logs",
+    type: "boolean"
+  }).epilogue(getEpilogue(command, description, EXPERIMENTAL_TOPIC_ID, true));
+};
+const handler = async (options) => {
+  recordTelemetryAttributes({
+    command: "experimental setup-opentelemetry",
+    force: options.force,
+    verbose: options.verbose
+  });
+  const { handler: handler2 } = await import("./setupOpentelemetryHandler.js");
+  return handler2(options);
+};
+export {
+  EXPERIMENTAL_TOPIC_ID,
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/experimental/setupOpentelemetryHandler.js

@@ -0,0 +1,215 @@
+import path from "path";
+import { ListrEnquirerPromptAdapter } from "@listr2/prompt-adapter-enquirer";
+import execa from "execa";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { addApiPackages } from "@cedarjs/cli-helpers";
+import { getConfigPath, resolveFile } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../lib/colors.js";
+import { getPaths, transformTSToJS, writeFile } from "../../lib/index.js";
+import { isTypeScriptProject } from "../../lib/project.js";
+import {
+  command,
+  description,
+  EXPERIMENTAL_TOPIC_ID
+} from "./setupOpentelemetry.js";
+import { printTaskEpilogue } from "./util.js";
+const handler = async ({ force, verbose }) => {
+  const ts = isTypeScriptProject();
+  const opentelemetryScriptPath = `${getPaths().api.src}/opentelemetry.${ts ? "ts" : "js"}`;
+  const opentelemetryPackages = [
+    "@opentelemetry/api",
+    "@opentelemetry/instrumentation",
+    "@opentelemetry/exporter-trace-otlp-http",
+    "@opentelemetry/resources",
+    "@opentelemetry/sdk-node",
+    "@opentelemetry/semantic-conventions",
+    "@opentelemetry/instrumentation-http",
+    "@opentelemetry/instrumentation-fastify",
+    "@prisma/instrumentation"
+  ];
+  const opentelemetryTasks = [
+    {
+      title: `Adding OpenTelemetry setup files...`,
+      task: async () => {
+        const setupTemplateContent = fs.readFileSync(
+          path.resolve(
+            import.meta.dirname,
+            "templates",
+            "opentelemetry.ts.template"
+          ),
+          "utf-8"
+        );
+        const setupScriptContent = ts ? setupTemplateContent : await transformTSToJS(opentelemetryScriptPath, setupTemplateContent);
+        return [
+          writeFile(opentelemetryScriptPath, setupScriptContent, {
+            overwriteExisting: force
+          })
+        ];
+      }
+    },
+    {
+      title: "Adding config to redwood.toml...",
+      task: (_ctx, task) => {
+        const redwoodTomlPath = getConfigPath();
+        const configContent = fs.readFileSync(redwoodTomlPath, "utf-8");
+        if (!configContent.includes("[experimental.opentelemetry]")) {
+          writeFile(
+            redwoodTomlPath,
+            configContent.concat(
+              `
+[experimental.opentelemetry]
+	enabled = true
+	wrapApi = true`
+            ),
+            {
+              overwriteExisting: true
+              // redwood.toml always exists
+            }
+          );
+        } else {
+          task.skip(
+            `The [experimental.opentelemetry] config block already exists in your 'redwood.toml' file.`
+          );
+        }
+      }
+    },
+    {
+      title: "Notice: GraphQL function update...",
+      enabled: () => {
+        return fs.existsSync(
+          resolveFile(path.join(getPaths().api.functions, "graphql"))
+        );
+      },
+      task: (_ctx, task) => {
+        task.output = [
+          "Please add the following to your 'createGraphQLHandler' function options to enable OTel for your graphql",
+          "openTelemetryOptions: {",
+          "  resolvers: true,",
+          "  result: true,",
+          "  variables: true,",
+          "}",
+          "",
+          `Which can found at ${c.info(
+            path.join(getPaths().api.functions, "graphql")
+          )}`
+        ].join("\n");
+      },
+      rendererOptions: { persistentOutput: true }
+    },
+    {
+      title: "Notice: GraphQL function update (server file)...",
+      enabled: () => {
+        return fs.existsSync(
+          resolveFile(path.join(getPaths().api.src, "server"))
+        );
+      },
+      task: (_ctx, task) => {
+        task.output = [
+          "Please add the following to your 'redwoodFastifyGraphQLServer' plugin options to enable OTel for your graphql",
+          "openTelemetryOptions: {",
+          "  resolvers: true,",
+          "  result: true,",
+          "  variables: true,",
+          "}",
+          "",
+          `Which can found at ${c.info(
+            path.join(getPaths().api.src, "server")
+          )}`
+        ].join("\n");
+      },
+      rendererOptions: { persistentOutput: true }
+    },
+    addApiPackages(opentelemetryPackages)
+  ];
+  const prismaTasks = [
+    {
+      title: "Setup Prisma OpenTelemetry...",
+      task: (_ctx, task) => {
+        const schemaPath = path.join(getPaths().api.db, "schema.prisma");
+        const schemaContent = fs.readFileSync(schemaPath, {
+          encoding: "utf-8",
+          flag: "r"
+        });
+        const clientConfig = schemaContent.slice(
+          schemaContent.indexOf("generator client") + "generator client".length,
+          schemaContent.indexOf(
+            "}",
+            schemaContent.indexOf("generator client")
+          ) + 1
+        ).trim();
+        const previewLineExists = clientConfig.includes("previewFeatures");
+        let newSchemaContents = schemaContent;
+        if (previewLineExists) {
+          task.skip(
+            'Please add "tracing" to your previewFeatures in prisma.schema'
+          );
+        } else {
+          const newClientConfig = clientConfig.trim().split("\n");
+          newClientConfig.splice(
+            newClientConfig.length - 1,
+            0,
+            'previewFeatures = ["tracing"]'
+          );
+          newSchemaContents = newSchemaContents.replace(
+            clientConfig,
+            newClientConfig.join("\n")
+          );
+        }
+        return writeFile(schemaPath, newSchemaContents, {
+          overwriteExisting: true
+          // We'll likely always already have this file in the project
+        });
+      }
+    },
+    {
+      title: "Regenerate the Prisma client...",
+      task: (_ctx, _task) => {
+        return execa(`yarn rw prisma generate`, {
+          stdio: "inherit",
+          shell: true,
+          cwd: getPaths().web.base
+        });
+      }
+    }
+  ];
+  const tasks = new Listr(
+    [
+      {
+        title: "Confirmation",
+        task: async (_ctx, task) => {
+          const prompt = task.prompt(ListrEnquirerPromptAdapter);
+          const confirmation = await prompt.run({
+            type: "Confirm",
+            message: "OpenTelemetry support is experimental. Continue?"
+          });
+          if (!confirmation) {
+            throw new Error("User aborted");
+          }
+        }
+      },
+      ...opentelemetryTasks,
+      ...prismaTasks,
+      {
+        task: () => {
+          printTaskEpilogue(command, description, EXPERIMENTAL_TOPIC_ID);
+        }
+      }
+    ],
+    {
+      rendererOptions: { collapseSubtasks: false, persistentOutput: true },
+      renderer: verbose ? "verbose" : "default"
+    }
+  );
+  try {
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  handler
+};

package/dist/commands/experimental/setupReactCompiler.js

@@ -0,0 +1,28 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getEpilogue } from "./util.js";
+const command = "setup-react-compiler";
+const description = "Enable the experimental React Compiler";
+const EXPERIMENTAL_TOPIC_ID = 7128;
+const builder = (yargs) => {
+  yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  }).epilogue(getEpilogue(command, description, EXPERIMENTAL_TOPIC_ID, true));
+};
+const handler = async (options) => {
+  recordTelemetryAttributes({
+    command: ["experimental", command].join(" "),
+    force: options.force
+  });
+  const { handler: handler2 } = await import("./setupReactCompilerHandler.js");
+  return handler2(options);
+};
+export {
+  EXPERIMENTAL_TOPIC_ID,
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/experimental/setupReactCompilerHandler.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import execa from "execa";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import semver from "semver";
+import { getConfigPath } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../lib/colors.js";
+import { getPaths, writeFile } from "../../lib/index.js";
+import {
+  command,
+  description,
+  EXPERIMENTAL_TOPIC_ID
+} from "./setupReactCompiler.js";
+import { printTaskEpilogue } from "./util.js";
+const handler = async ({ force, verbose }) => {
+  const rwPaths = getPaths();
+  const redwoodTomlPath = getConfigPath();
+  const configContent = fs.readFileSync(redwoodTomlPath, "utf-8");
+  const tasks = new Listr(
+    [
+      {
+        title: "Check prerequisites",
+        skip: force,
+        task: () => {
+          if (!rwPaths.web.entryClient || !rwPaths.web.viteConfig) {
+            throw new Error(
+              "Vite needs to be setup before you can enable React Compiler"
+            );
+          }
+          const webPkgJson = fs.readJSONSync(
+            path.join(rwPaths.web.base, "package.json")
+          );
+          const reactVersion = webPkgJson["dependencies"]["react"];
+          const coercedReactVersion = semver.coerce(reactVersion);
+          if (!semver.gte(coercedReactVersion, "19.0.0")) {
+            throw new Error(
+              "You need to be using at least React version 19 to enable the React Compiler"
+            );
+          }
+        }
+      },
+      {
+        title: "Adding config to redwood.toml...",
+        task: (_ctx, task) => {
+          if (!configContent.includes("[experimental.reactCompiler]")) {
+            writeFile(
+              redwoodTomlPath,
+              configContent.concat(
+                "\n[experimental.reactCompiler]\n  enabled = true\n  lintOnly = false\n"
+              ),
+              {
+                overwriteExisting: true
+                // redwood.toml always exists
+              }
+            );
+          } else {
+            if (force) {
+              task.output = "Overwriting config in redwood.toml";
+              writeFile(
+                redwoodTomlPath,
+                configContent.replace(
+                  // Enable if it's currently disabled
+                  "\n[experimental.reactCompiler]\n  enabled = false\n",
+                  "\n[experimental.reactCompiler]\n  enabled = true\n"
+                ),
+                {
+                  overwriteExisting: true
+                  // redwood.toml always exists
+                }
+              );
+            } else {
+              task.skip(
+                "The [experimental.reactCompiler] config block already exists in your `redwood.toml` file."
+              );
+            }
+          }
+        },
+        rendererOptions: { persistentOutput: true }
+      },
+      // We are using two different yarn commands here which is fine because they're operating on different
+      // workspaces - web and the root
+      {
+        title: "Installing eslint-plugin-react-compiler",
+        task: async () => {
+          await execa("yarn", ["add", "-D", "eslint-plugin-react-compiler"], {
+            cwd: getPaths().base
+          });
+        }
+      },
+      {
+        title: "Installing babel-plugin-react-compiler",
+        task: async () => {
+          await execa(
+            "yarn",
+            ["web/", "add", "-D", "babel-plugin-react-compiler"],
+            {
+              cwd: getPaths().base
+            }
+          );
+        }
+      },
+      {
+        task: () => {
+          printTaskEpilogue(command, description, EXPERIMENTAL_TOPIC_ID);
+        }
+      }
+    ],
+    {
+      rendererOptions: { collapseSubtasks: false, persistentOutput: true },
+      renderer: verbose ? "verbose" : "default"
+    }
+  );
+  try {
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  handler
+};