@cedarjs/cli 0.0.4

package/dist/commands/setup/middleware/ogImage/codemodVitePlugin.js

@@ -0,0 +1,65 @@
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  const needsImport = ast.find(j.ImportDeclaration, {
+    specifiers: [
+      {
+        type: "ImportDefaultSpecifier",
+        local: {
+          name: "vitePluginOgImageGen"
+        }
+      }
+    ],
+    source: {
+      value: "@cedarjs/ogimage-gen/plugin",
+      type: "StringLiteral"
+    }
+  }).length === 0;
+  if (needsImport) {
+    ast.find(j.ImportDeclaration).at(0).insertBefore(
+      j.importDeclaration(
+        [j.importDefaultSpecifier(j.identifier("vitePluginOgImageGen"))],
+        j.stringLiteral("@cedarjs/ogimage-gen/plugin")
+      )
+    );
+  }
+  const viteConfigVariable = ast.find(j.VariableDeclaration, {
+    declarations(value) {
+      if (value.length !== 1) {
+        return false;
+      }
+      const declaration = value[0];
+      if (declaration.type !== "VariableDeclarator") {
+        return false;
+      }
+      return declaration.id.type === "Identifier" && declaration.id.name === "viteConfig";
+    }
+  });
+  if (viteConfigVariable.length === 0) {
+    throw new Error("Could not find the `viteConfig` variable");
+  }
+  const pluginsArray = viteConfigVariable.find(j.ObjectExpression, {
+    properties(value) {
+      if (!value) {
+        return false;
+      }
+      return value.some(
+        (property) => property.type === "ObjectProperty" && property.key.type === "Identifier" && property.key.name === "plugins"
+      );
+    }
+  });
+  if (pluginsArray.length === 0) {
+    throw new Error(
+      "Could not find the `plugins` array in the `viteConfig` variable"
+    );
+  }
+  pluginsArray.find(j.ArrayExpression).at(0).replaceWith((nodePath) => {
+    const elements = nodePath.value.elements;
+    elements.push(j.callExpression(j.identifier("vitePluginOgImageGen"), []));
+    return nodePath.value;
+  });
+  return ast.toSource();
+}
+export {
+  transform as default
+};

package/dist/commands/setup/middleware/ogImage/ogImage.js

@@ -0,0 +1,27 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "og-image";
+const aliases = ["ogImage", "ogimage"];
+const description = "Set up OG Image generation middleware";
+function builder(yargs) {
+  return yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  });
+}
+async function handler({ force }) {
+  recordTelemetryAttributes({
+    command: "setup middleware og-image",
+    force
+  });
+  const { handler: handler2 } = await import("./ogImageHandler.js");
+  return handler2({ force });
+}
+export {
+  aliases,
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/middleware/ogImage/ogImageHandler.js

@@ -0,0 +1,121 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { format } from "prettier";
+import { addWebPackages, getPrettierOptions } from "@cedarjs/cli-helpers";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { runTransform } from "../../../../lib/runTransform.js";
+async function handler({ force }) {
+  const rwPaths = getPaths();
+  const rootPkgJson = fs.readJSONSync(path.join(rwPaths.base, "package.json"));
+  const currentProjectVersion = rootPkgJson.devDependencies["@cedarjs/core"];
+  const notes = [""];
+  const tasks = new Listr(
+    [
+      {
+        title: "Check prerequisites",
+        skip: force,
+        task: () => {
+          if (!getConfig().experimental?.streamingSsr?.enabled) {
+            throw new Error(
+              "The Streaming SSR experimental feature must be enabled before you can setup middleware.\n\nRun this command to setup streaming ssr: \n  yarn rw exp setup-streaming-ssr\n"
+            );
+          }
+        }
+      },
+      addWebPackages([`@cedarjs/ogimage-gen@${currentProjectVersion}`]),
+      {
+        title: "Add OG Image middleware ...",
+        task: async () => {
+          const serverEntryPath = rwPaths.web.entryServer;
+          if (serverEntryPath === null) {
+            throw new Error(
+              "Could not find the server entry file. Is your project using the default structure?"
+            );
+          }
+          const transformResult = await runTransform({
+            transformPath: path.join(
+              import.meta.dirname,
+              "codemodMiddleware.js"
+            ),
+            targetPaths: [serverEntryPath]
+          });
+          if (transformResult.error) {
+            throw new Error(transformResult.error);
+          }
+        }
+      },
+      {
+        title: "Add OG Image vite plugin ...",
+        task: async () => {
+          const viteConfigPath = rwPaths.web.viteConfig;
+          if (viteConfigPath === null) {
+            throw new Error("Could not find the Vite config file");
+          }
+          const transformResult = await runTransform({
+            transformPath: path.join(
+              import.meta.dirname,
+              "codemodVitePlugin.js"
+            ),
+            targetPaths: [viteConfigPath]
+          });
+          if (transformResult.error) {
+            throw new Error(transformResult.error);
+          }
+        }
+      },
+      {
+        title: "Prettifying changed files",
+        task: async (_ctx, task) => {
+          const prettifyPaths = [
+            rwPaths.web.entryServer,
+            rwPaths.web.viteConfig
+          ];
+          for (const prettifyPath of prettifyPaths) {
+            if (prettifyPath === null) {
+              throw new Error("Could not find the file to be prettified");
+            }
+            try {
+              const source = fs.readFileSync(prettifyPath, "utf-8");
+              const prettierOptions = await getPrettierOptions();
+              const prettifiedApp = await format(source, {
+                ...prettierOptions,
+                parser: "babel-ts"
+              });
+              fs.writeFileSync(prettifyPath, prettifiedApp, "utf-8");
+            } catch {
+              task.output = "Couldn't prettify the changes. Please reformat the files manually if needed.";
+            }
+          }
+        }
+      },
+      {
+        title: "One more thing...",
+        task: () => {
+          notes.push(
+            "og:image generation is almost ready to go! You'll need to add playwright as a dependency to the web side and then install the headless browser packages:"
+          );
+          notes.push("");
+          notes.push("  yarn workspace web add playwright");
+          notes.push("  yarn workspace web playwright install");
+          notes.push("");
+          notes.push(
+            "Depending on how your host is configured you may need to install additional dependencies first. If so, the `playwright install` step will error out and give you the command to run to install those deps."
+          );
+          notes.push("");
+        }
+      }
+    ],
+    { rendererOptions: { collapseSubtasks: false } }
+  );
+  try {
+    await tasks.run();
+    console.log(notes.join("\n"));
+  } catch (e) {
+    console.error(e.message);
+    process.exit(e?.exitCode || 1);
+  }
+}
+export {
+  handler
+};

package/dist/commands/setup/monitoring/monitoring.js

@@ -0,0 +1,17 @@
+import terminalLink from "terminal-link";
+import * as sentryCommand from "./sentry/sentry.js";
+const command = "monitoring <provider>";
+const description = "Set up monitoring in your Redwood app";
+function builder(yargs) {
+  return yargs.command(sentryCommand).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#setup-graphql"
+    )}`
+  );
+}
+export {
+  builder,
+  command,
+  description
+};

package/dist/commands/setup/monitoring/sentry/sentry.js

@@ -0,0 +1,25 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "sentry";
+const description = "Setup Sentry error and performance tracking";
+const builder = (yargs) => {
+  return yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing Sentry config files",
+    type: "boolean"
+  });
+};
+async function handler({ force }) {
+  recordTelemetryAttributes({
+    command: "setup monitoring sentry",
+    force
+  });
+  const { handler: handler2 } = await import("./sentryHandler.js");
+  return handler2({ force });
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/monitoring/sentry/sentryHandler.js

@@ -0,0 +1,163 @@
+import path from "path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import {
+  addApiPackages,
+  addEnvVarTask,
+  addWebPackages,
+  colors,
+  getPaths,
+  isTypeScriptProject,
+  prettify,
+  writeFilesTask
+} from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+const rwPaths = getPaths();
+const handler = async ({ force }) => {
+  const extension = isTypeScriptProject() ? "ts" : "js";
+  const notes = [];
+  const tasks = new Listr([
+    addApiPackages(["@envelop/sentry@5", "@sentry/node@7"]),
+    addWebPackages(["@sentry/react@7", "@sentry/browser@7"]),
+    addEnvVarTask(
+      "SENTRY_DSN",
+      "",
+      "https://docs.sentry.io/product/sentry-basics/dsn-explainer/"
+    ),
+    {
+      title: "Setting up Sentry on the API and web sides",
+      task: () => {
+        return writeFilesTask(
+          {
+            [path.join(rwPaths.api.lib, `sentry.${extension}`)]: fs.readFileSync(
+              path.join(
+                import.meta.dirname,
+                "templates/sentryApi.ts.template"
+              )
+            ).toString(),
+            [path.join(rwPaths.web.src, "lib", `sentry.${extension}`)]: fs.readFileSync(
+              path.join(
+                import.meta.dirname,
+                "templates/sentryWeb.ts.template"
+              )
+            ).toString()
+          },
+          { existingFiles: force ? "OVERWRITE" : "SKIP" }
+        );
+      }
+    },
+    {
+      title: "Implementing the Envelop plugin",
+      task: async (ctx) => {
+        const graphqlHandlerPath = path.join(
+          rwPaths.api.functions,
+          `graphql.${extension}`
+        );
+        const contentLines = fs.readFileSync(graphqlHandlerPath).toString().split("\n");
+        const handlerIndex = contentLines.findLastIndex(
+          (line) => line.startsWith("export const handler = createGraphQLHandler({")
+        );
+        const pluginsIndex = contentLines.findLastIndex(
+          (line) => line.includes("extraPlugins:")
+        );
+        if (handlerIndex === -1 || pluginsIndex !== -1) {
+          ctx.addEnvelopPluginSkipped = true;
+          return;
+        }
+        contentLines.splice(
+          handlerIndex,
+          1,
+          "import 'src/lib/sentry'",
+          "",
+          "export const handler = createGraphQLHandler({",
+          "extraPlugins: [useSentry({",
+          "  includeRawResult: true,",
+          "  includeResolverArgs: true,",
+          "  includeExecuteVariables: true,",
+          "})],"
+        );
+        contentLines.splice(0, 0, "import { useSentry } from '@envelop/sentry'");
+        fs.writeFileSync(
+          graphqlHandlerPath,
+          await prettify("graphql.ts", contentLines.join("\n"))
+        );
+      }
+    },
+    {
+      title: "Replacing Redwood's Error boundary",
+      task: async () => {
+        const contentLines = fs.readFileSync(rwPaths.web.app).toString().split("\n");
+        const webImportIndex = contentLines.findLastIndex(
+          (line) => /^import { FatalErrorBoundary, RedwoodProvider } from '@cedarjs\/web'$/.test(
+            line
+          )
+        );
+        contentLines.splice(
+          webImportIndex,
+          1,
+          "import { RedwoodProvider } from '@cedarjs/web'"
+        );
+        const boundaryOpenIndex = contentLines.findLastIndex(
+          (line) => line.includes("<FatalErrorBoundary page={FatalErrorPage}>")
+        );
+        contentLines.splice(
+          boundaryOpenIndex,
+          1,
+          "<Sentry.ErrorBoundary fallback={FatalErrorPage}>"
+        );
+        const boundaryCloseIndex = contentLines.findLastIndex(
+          (line) => line.includes("</FatalErrorBoundary>")
+        );
+        contentLines.splice(boundaryCloseIndex, 1, "</Sentry.ErrorBoundary>");
+        contentLines.splice(0, 0, "import Sentry from 'src/lib/sentry'");
+        fs.writeFileSync(
+          rwPaths.web.app,
+          await prettify("App.tsx", contentLines.join("\n"))
+        );
+      }
+    },
+    {
+      title: "One more thing...",
+      task: (ctx) => {
+        notes.push(
+          colors.important(
+            "You will need to add `SENTRY_DSN` to `includeEnvironmentVariables` in redwood.toml."
+          )
+        );
+        if (ctx.addEnvelopPluginSkipped) {
+          notes.push(
+            `${colors.underline(
+              "Make sure you implement the Sentry Envelop plugin:"
+            )} https://redwoodjs.com/docs/cli-commands#sentry-envelop-plugin`
+          );
+        } else {
+          notes.push(
+            "Check out the RedwoodJS forums for more: https://community.redwoodjs.com/t/sentry-error-and-performance-monitoring-experimental/4880"
+          );
+        }
+      }
+    }
+  ]);
+  try {
+    await tasks.run();
+    console.log(notes.join("\n"));
+  } 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 {
+  handler
+};

package/dist/commands/setup/monitoring/sentry/templates/sentryApi.ts.template

@@ -0,0 +1,15 @@
+import * as Sentry from '@sentry/node'
+
+import { db as client } from 'src/lib/db'
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  environment: process.env.NODE_ENV,
+  integrations: [
+    new Sentry.Integrations.Prisma({ client }),
+    new Sentry.Integrations.Http({ tracing: true }),
+  ],
+  tracesSampleRate: 1.0,
+})
+
+export default Sentry

package/dist/commands/setup/monitoring/sentry/templates/sentryWeb.ts.template

@@ -0,0 +1,31 @@
+import * as Sentry from '@sentry/react'
+
+let dsn = ''
+let environment = 'development'
+
+if (typeof process === 'undefined' || !process.env?.SENTRY_DSN) {
+  console.error(
+    'Missing SENTRY_DSN environment variable. Did you forget to add it to ' +
+      'your redwood.toml file in `includeEnvironmentVariables`?'
+  )
+  console.info(`Copy this into your redwood.toml file:`)
+  console.info(`
+  includeEnvironmentVariables = [
+    "SENTRY_DSN"
+  ]
+
+  `)
+  console.error('Sentry is disabled for now')
+} else {
+  dsn = process.env.SENTRY_DSN
+  environment = process.env.NODE_ENV
+}
+
+Sentry.init({
+  dsn,
+  environment,
+  integrations: [new Sentry.BrowserTracing()],
+  tracesSampleRate: 1.0,
+})
+
+export default Sentry

package/dist/commands/setup/package/package.js

@@ -0,0 +1,33 @@
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "package <npm-package>";
+const description = "Run a bin from an NPM package with version compatibility checks";
+const builder = (yargs) => {
+  yargs.positional("npm-package", {
+    description: "The NPM package to run. This can be a package name or a package name with a version or tag.",
+    type: "string"
+  }).option("force", {
+    default: false,
+    description: "Proceed with a potentially incompatible version of the package",
+    type: "boolean",
+    alias: "f"
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#lint"
+    )}`
+  );
+};
+const handler = async (options) => {
+  recordTelemetryAttributes({
+    command: "setup package"
+  });
+  const { handler: handler2 } = await import("./packageHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/package/packageHandler.js

@@ -0,0 +1,134 @@
+import enq from "enquirer";
+import execa from "execa";
+import semver from "semver";
+import { getCompatibilityData } from "@cedarjs/cli-helpers";
+import { getPaths } from "@cedarjs/project-config";
+async function handler({ npmPackage, force, _: _args }) {
+  const isScoped = npmPackage.startsWith("@");
+  const packageName = (isScoped ? "@" : "") + npmPackage.split("@")[isScoped ? 1 : 0];
+  const packageVersion = npmPackage.split("@")[isScoped ? 2 : 1] ?? "latest";
+  const additionalOptionsToForward = _args.slice(2) ?? [];
+  if (force) {
+    console.log(
+      "No compatibility check will be performed because you used the --force flag."
+    );
+    if (semver.parse(packageVersion) !== null && semver.lt(packageVersion, "1.0.0")) {
+      console.log(
+        "Be aware that this package is under version 1.0.0 and so should be considered experimental."
+      );
+    }
+    await runPackage(packageName, packageVersion, additionalOptionsToForward);
+    return;
+  }
+  console.log("Checking compatibility...");
+  let compatibilityData;
+  try {
+    compatibilityData = await getCompatibilityData(packageName, packageVersion);
+  } catch (error) {
+    console.log("The following error occurred while checking compatibility:");
+    const errorMessage = error.message ?? error;
+    console.log(errorMessage);
+    if (errorMessage.includes("does not have a tag") || errorMessage.includes("does not have a version")) {
+      process.exit(1);
+    }
+    const decision2 = await promptWithChoices("What would you like to do?", [
+      {
+        name: "cancel",
+        message: "Cancel"
+      },
+      {
+        name: "continue",
+        message: "Continue regardless of potential incompatibility"
+      }
+    ]);
+    if (decision2 === "continue") {
+      await runPackage(packageName, packageVersion, additionalOptionsToForward);
+    }
+    return;
+  }
+  const { preferred, compatible } = compatibilityData;
+  const preferredVersionIsCompatible = preferred.version === compatible.version;
+  if (preferredVersionIsCompatible) {
+    await showExperimentalWarning(preferred.version);
+    await runPackage(packageName, preferred.version, additionalOptionsToForward);
+    return;
+  }
+  const preferredVersionText = `${preferred.version}${preferred.tag ? ` (${preferred.tag})` : ""}`;
+  const latestCompatibleVersionText = `${compatible.version}${compatible.tag ? ` (${compatible.tag})` : ""}`;
+  console.log(
+    `The version ${preferredVersionText} of '${packageName}' is not compatible with your RedwoodJS project version.
+The latest version compatible with your project is ${latestCompatibleVersionText}.`
+  );
+  const decision = await promptWithChoices("What would you like to do?", [
+    {
+      name: "useLatestCompatibleVersion",
+      message: `Use the latest compatible version: ${latestCompatibleVersionText}`
+    },
+    {
+      name: "usePreferredVersion",
+      message: `Continue anyway with version: ${preferredVersionText}`
+    },
+    {
+      name: "cancel",
+      message: "Cancel"
+    }
+  ]);
+  if (decision === "cancel") {
+    process.exitCode = 1;
+    return;
+  }
+  const versionToUse = decision === "useLatestCompatibleVersion" ? compatible.version : preferred.version;
+  await showExperimentalWarning(versionToUse);
+  await runPackage(packageName, versionToUse, additionalOptionsToForward);
+}
+async function showExperimentalWarning(version) {
+  if (version === void 0 || semver.parse(version) === null || semver.gte(version, "1.0.0")) {
+    return;
+  }
+  const decision = await promptWithChoices(
+    "This package is under version 1.0.0 and so should be considered experimental. Would you like to continue?",
+    [
+      {
+        name: "yes",
+        message: "Yes"
+      },
+      {
+        name: "no",
+        message: "No"
+      }
+    ]
+  );
+  if (decision === "no") {
+    process.exit();
+  }
+}
+async function runPackage(packageName, version, options = []) {
+  const versionString = version === void 0 ? "" : `@${version}`;
+  console.log(`Running ${packageName}${versionString}...`);
+  try {
+    await execa("yarn", ["dlx", `${packageName}${versionString}`, ...options], {
+      stdio: "inherit",
+      cwd: getPaths().base
+    });
+  } catch (error) {
+    process.exitCode = error.exitCode ?? 1;
+  }
+}
+async function promptWithChoices(message, choices) {
+  try {
+    const prompt = new enq.Select({
+      name: message.substring(0, 8).toLowerCase(),
+      message,
+      choices
+    });
+    return await prompt.run();
+  } catch (error) {
+    if (error) {
+      throw error;
+    }
+  }
+  return null;
+}
+export {
+  handler
+};

package/dist/commands/setup/realtime/realtime.js

@@ -0,0 +1,37 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "realtime";
+const description = "Setup RedwoodJS Realtime";
+function builder(yargs) {
+  yargs.option("includeExamples", {
+    alias: ["e", "examples"],
+    default: true,
+    description: "Include examples of how to implement liveQueries and subscriptions",
+    type: "boolean"
+  }).option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more logs",
+    type: "boolean"
+  });
+}
+async function handler(options) {
+  recordTelemetryAttributes({
+    command: "setup realtime",
+    includeExamples: options.includeExamples,
+    force: options.force,
+    verbose: options.verbose
+  });
+  const { handler: handler2 } = await import("./realtimeHandler.js");
+  return handler2(options);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};