@cedarjs/cli 0.0.4

package/dist/commands/prismaHandler.js

@@ -0,0 +1,90 @@
+import path from "path";
+import boxen from "boxen";
+import execa from "execa";
+import fs from "fs-extra";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../lib/colors.js";
+import { getPaths } from "../lib/index.js";
+const handler = async ({ _, $0, commands = [], ...options }) => {
+  recordTelemetryAttributes({
+    command: "prisma"
+  });
+  const rwjsPaths = getPaths();
+  const helpIndex = commands.indexOf("help");
+  if (helpIndex !== -1) {
+    options.help = true;
+    commands.splice(helpIndex, 1);
+  }
+  const hasHelpOption = options.help || options.h;
+  if (!hasHelpOption) {
+    if (["generate", "introspect", "db", "migrate", "studio", "format"].includes(
+      commands[0]
+    )) {
+      const schemaDir = path.dirname(rwjsPaths.api.dbSchema);
+      if (!fs.existsSync(rwjsPaths.api.dbSchema) && !fs.existsSync(schemaDir)) {
+        console.error();
+        console.error(c.error("No Prisma Schema found."));
+        console.error(`Redwood searched here '${rwjsPaths.api.dbSchema}'`);
+        console.error();
+        process.exit(1);
+      }
+      options.schema = `${rwjsPaths.api.dbSchema}`;
+      if (["seed", "diff"].includes(commands[1])) {
+        delete options.schema;
+      }
+    }
+  }
+  const args = commands;
+  for (const [name, value] of Object.entries(options)) {
+    args.push(name.length > 1 ? `--${name}` : `-${name}`);
+    if (typeof value === "string") {
+      value.split(" ").length > 1 ? args.push(`"${value}"`) : args.push(value);
+    } else if (typeof value === "number") {
+      args.push(value);
+    }
+  }
+  console.log();
+  console.log(c.note("Running Prisma CLI..."));
+  console.log(c.underline("$ yarn prisma " + args.join(" ")));
+  console.log();
+  try {
+    execa.sync(
+      `"${path.join(rwjsPaths.base, "node_modules/.bin/prisma")}"`,
+      args,
+      {
+        shell: true,
+        cwd: rwjsPaths.base,
+        stdio: "inherit",
+        cleanup: true
+      }
+    );
+    if (hasHelpOption || commands.length === 0) {
+      printWrapInfo();
+    }
+  } catch (e) {
+    errorTelemetry(process.argv, `Error generating prisma client: ${e.message}`);
+    process.exit(e?.exitCode || 1);
+  }
+};
+const printWrapInfo = () => {
+  const message = [
+    c.bold("Redwood CLI wraps Prisma CLI"),
+    "",
+    "Use `yarn rw prisma` to automatically pass `--schema` and `--preview-feature` options.",
+    "Use `yarn prisma` to skip Redwood CLI automatic options.",
+    "",
+    "Find more information in our docs:",
+    c.underline("https://redwoodjs.com/docs/cli-commands#prisma")
+  ];
+  console.log(
+    boxen(message.join("\n"), {
+      padding: { top: 0, bottom: 0, right: 1, left: 1 },
+      margin: 1,
+      borderColor: "gray"
+    })
+  );
+};
+export {
+  handler
+};

package/dist/commands/record/init.js

@@ -0,0 +1,11 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const handler = async () => {
+  recordTelemetryAttributes({
+    command: "record"
+  });
+  const { parseDatamodel } = await import("@cedarjs/record");
+  parseDatamodel();
+};
+export {
+  handler
+};

package/dist/commands/record.js

@@ -0,0 +1,19 @@
+const command = "record <command>";
+const description = "Setup RedwoodRecord for your project. Caches a JSON version of your data model and adds api/src/models/index.js with some config.";
+import terminalLink from "terminal-link";
+const builder = (yargs) => yargs.command({ command, description, handler }).demandCommand().epilogue(
+  `Also see the ${terminalLink(
+    "RedwoodRecord Docs",
+    "https://redwoodjs.com/docs/redwoodrecord"
+  )}
+`
+);
+async function handler(argv) {
+  const recordInit = await import("./record/init.js");
+  recordInit(argv);
+}
+export {
+  builder,
+  command,
+  description
+};

package/dist/commands/serve.js

@@ -0,0 +1,139 @@
+import path from "path";
+import fs from "fs-extra";
+import terminalLink from "terminal-link";
+import * as apiServerCLIConfig from "@cedarjs/api-server/dist/apiCLIConfig.js";
+import * as bothServerCLIConfig from "@cedarjs/api-server/dist/bothCLIConfig.js";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import * as webServerCLIConfig from "@cedarjs/web-server";
+import c from "../lib/colors.js";
+import { getPaths, getConfig } from "../lib/index.js";
+import { serverFileExists } from "../lib/project.js";
+import { webSsrServerHandler } from "./serveWebHandler.js";
+const command = "serve [side]";
+const description = "Start a server for serving both the api and web sides";
+const builder = async (yargs) => {
+  const rscEnabled = getConfig().experimental?.rsc?.enabled;
+  const streamingEnabled = getConfig().experimental?.streamingSsr?.enabled;
+  yargs.command({
+    command: "$0",
+    description: bothServerCLIConfig.description,
+    builder: bothServerCLIConfig.builder,
+    handler: async (argv) => {
+      recordTelemetryAttributes({
+        command: "serve",
+        port: argv.port,
+        host: argv.host,
+        socket: argv.socket
+      });
+      if (serverFileExists()) {
+        const { bothServerFileHandler } = await import("./serveBothHandler.js");
+        await bothServerFileHandler(argv);
+      } else if (rscEnabled || streamingEnabled) {
+        const { bothSsrRscServerHandler } = await import("./serveBothHandler.js");
+        await bothSsrRscServerHandler(argv, rscEnabled);
+      } else {
+        await bothServerCLIConfig.handler(argv);
+      }
+    }
+  }).command({
+    command: "api",
+    description: apiServerCLIConfig.description,
+    builder: apiServerCLIConfig.builder,
+    handler: async (argv) => {
+      recordTelemetryAttributes({
+        command: "serve",
+        port: argv.port,
+        host: argv.host,
+        socket: argv.socket,
+        apiRootPath: argv.apiRootPath
+      });
+      if (serverFileExists()) {
+        const { apiServerFileHandler } = await import("./serveApiHandler.js");
+        await apiServerFileHandler(argv);
+      } else {
+        await apiServerCLIConfig.handler(argv);
+      }
+    }
+  }).command({
+    command: "web",
+    description: webServerCLIConfig.description,
+    builder: webServerCLIConfig.builder,
+    handler: async (argv) => {
+      recordTelemetryAttributes({
+        command: "serve",
+        port: argv.port,
+        host: argv.host,
+        socket: argv.socket,
+        apiHost: argv.apiHost
+      });
+      if (streamingEnabled) {
+        await webSsrServerHandler(rscEnabled);
+      } else {
+        await webServerCLIConfig.handler(argv);
+      }
+    }
+  }).middleware((argv) => {
+    recordTelemetryAttributes({
+      command: "serve"
+    });
+    const positionalArgs = argv._;
+    if (positionalArgs.includes("web") && !fs.existsSync(path.join(getPaths().web.dist), "index.html")) {
+      console.error(
+        c.error(
+          "\n Please run `yarn rw build web` before trying to serve web. \n"
+        )
+      );
+      process.exit(1);
+    }
+    const apiSideExists = fs.existsSync(getPaths().api.base);
+    if (positionalArgs.includes("api")) {
+      if (!apiSideExists) {
+        console.error(
+          c.error(
+            "\n Unable to serve the api side as no `api` folder exists. \n"
+          )
+        );
+        process.exit(1);
+      }
+      if (!fs.existsSync(path.join(getPaths().api.dist))) {
+        console.error(
+          c.error(
+            "\n Please run `yarn rw build api` before trying to serve api. \n"
+          )
+        );
+        process.exit(1);
+      }
+    }
+    if (positionalArgs.length === 1) {
+      if (!apiSideExists && !rscEnabled) {
+        console.error(
+          c.error(
+            "\n Unable to serve the both sides as no `api` folder exists. Please use `yarn rw serve web` instead. \n"
+          )
+        );
+        process.exit(1);
+      }
+      if (fs.existsSync(path.join(getPaths().api.base)) && !fs.existsSync(path.join(getPaths().api.dist)) || !fs.existsSync(path.join(getPaths().web.dist), "index.html")) {
+        console.error(
+          c.error(
+            "\n Please run `yarn rw build` before trying to serve your redwood app. \n"
+          )
+        );
+        process.exit(1);
+      }
+    }
+    if (!process.env.NODE_ENV) {
+      process.env.NODE_ENV = "production";
+    }
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#serve"
+    )}`
+  );
+};
+export {
+  builder,
+  command,
+  description
+};

package/dist/commands/serveApiHandler.js

@@ -0,0 +1,15 @@
+import execa from "execa";
+import { getPaths } from "@cedarjs/project-config";
+const apiServerFileHandler = async (argv) => {
+  const args = ["node", "server.js", "--apiRootPath", argv.apiRootPath];
+  if (argv.port) {
+    args.push("--apiPort", argv.port);
+  }
+  await execa("yarn", args, {
+    cwd: getPaths().api.dist,
+    stdio: "inherit"
+  });
+};
+export {
+  apiServerFileHandler
+};

package/dist/commands/serveBothHandler.js

@@ -0,0 +1,95 @@
+import path from "path";
+import concurrently from "concurrently";
+import execa from "execa";
+import { handler as apiServerHandler } from "@cedarjs/api-server/dist/apiCLIConfigHandler.js";
+import {
+  getAPIHost,
+  getAPIPort,
+  getWebHost,
+  getWebPort
+} from "@cedarjs/api-server/dist/cliHelpers.js";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import { exitWithError } from "../lib/exit.js";
+const bothServerFileHandler = async (argv) => {
+  if (getConfig().experimental?.rsc?.enabled || getConfig().experimental?.streamingSsr?.enabled) {
+    logSkippingFastifyWebServer();
+    await execa("yarn", ["rw-serve-fe"], {
+      cwd: getPaths().web.base,
+      stdio: "inherit",
+      shell: true
+    });
+  } else {
+    argv.apiPort ??= getAPIPort();
+    argv.apiHost ??= getAPIHost();
+    argv.webPort ??= getWebPort();
+    argv.webHost ??= getWebHost();
+    const apiProxyTarget = [
+      "http://",
+      argv.apiHost.includes(":") ? `[${argv.apiHost}]` : argv.apiHost,
+      ":",
+      argv.apiPort,
+      argv.apiRootPath
+    ].join("");
+    const { result } = concurrently(
+      [
+        {
+          name: "api",
+          command: `yarn node ${path.join("dist", "server.js")} --apiPort ${argv.apiPort} --apiHost ${argv.apiHost} --apiRootPath ${argv.apiRootPath}`,
+          cwd: getPaths().api.base,
+          prefixColor: "cyan"
+        },
+        {
+          name: "web",
+          command: `yarn rw-web-server --port ${argv.webPort} --host ${argv.webHost} --api-proxy-target ${apiProxyTarget}`,
+          cwd: getPaths().base,
+          prefixColor: "blue"
+        }
+      ],
+      {
+        prefix: "{name} |",
+        timestampFormat: "HH:mm:ss",
+        handleInput: true
+      }
+    );
+    try {
+      await result;
+    } catch (error) {
+      if (typeof error?.message !== "undefined") {
+        errorTelemetry(
+          process.argv,
+          `Error concurrently starting sides: ${error.message}`
+        );
+        exitWithError(error);
+      }
+    }
+  }
+};
+const bothSsrRscServerHandler = async (argv, rscEnabled) => {
+  const apiPromise = apiServerHandler({
+    apiRootPath: argv.apiRootPath,
+    host: argv.apiHost,
+    port: argv.apiPort
+  });
+  const fePromise = execa("yarn", ["rw-serve-fe"], {
+    cwd: getPaths().web.base,
+    stdio: "inherit",
+    shell: true,
+    env: rscEnabled ? {
+      // TODO (RSC): Is this how we want to do it? If so, we need to find a way
+      // to merge this with users' NODE_OPTIONS
+      NODE_OPTIONS: "--conditions react-server"
+    } : void 0
+  });
+  await Promise.all([apiPromise, fePromise]);
+};
+function logSkippingFastifyWebServer() {
+  console.warn("");
+  console.warn("\u26A0\uFE0F Skipping Fastify web server \u26A0\uFE0F");
+  console.warn("\u26A0\uFE0F Using new RSC server instead \u26A0\uFE0F");
+  console.warn("");
+}
+export {
+  bothServerFileHandler,
+  bothSsrRscServerHandler
+};

package/dist/commands/serveWebHandler.js

@@ -0,0 +1,17 @@
+import execa from "execa";
+import { getPaths } from "@cedarjs/project-config";
+const webSsrServerHandler = async (rscEnabled) => {
+  await execa("yarn", ["rw-serve-fe"], {
+    cwd: getPaths().web.base,
+    stdio: "inherit",
+    shell: true,
+    env: rscEnabled ? {
+      // TODO (RSC): Is this how we want to do it? If so, we need to find a way
+      // to merge this with users' NODE_OPTIONS
+      NODE_OPTIONS: "--conditions react-server"
+    } : void 0
+  });
+};
+export {
+  webSsrServerHandler
+};

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

@@ -0,0 +1,265 @@
+import path from "node:path";
+import execa from "execa";
+import fs from "fs-extra";
+import terminalLink from "terminal-link";
+import {
+  recordTelemetryAttributes,
+  standardAuthBuilder
+} from "@cedarjs/cli-helpers";
+import { getPaths } from "../../../lib/index.js";
+const command = "auth <provider>";
+const description = "Set up an auth configuration";
+async function builder(yargs) {
+  yargs.demandCommand().epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#setup-auth"
+    )}`
+  ).command(...directToCustomAuthCommand("ethereum")).command(...directToCustomAuthCommand("goTrue")).command(...directToCustomAuthCommand("magicLink")).command(...directToCustomAuthCommand("nhost")).command(...directToCustomAuthCommand("okta")).command(
+    "auth0",
+    "Set up auth for Auth0",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth auth0",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler("@cedarjs/auth-auth0-setup");
+      console.log();
+      handler(args);
+    }
+  ).command(
+    ["azure-active-directory", "azureActiveDirectory"],
+    "Set up auth for Azure Active Directory",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth azure-active-directory",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler(
+        "@cedarjs/auth-azure-active-directory-setup"
+      );
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "clerk",
+    "Set up auth for Clerk",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth clerk",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler("@cedarjs/auth-clerk-setup");
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "custom",
+    "Set up a custom auth provider",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth custom",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler("@cedarjs/auth-custom-setup");
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "dbAuth",
+    "Set up auth for dbAuth",
+    (yargs2) => {
+      return standardAuthBuilder(yargs2).option("webauthn", {
+        alias: "w",
+        default: null,
+        description: "Include WebAuthn support (TouchID/FaceID)",
+        type: "boolean"
+      }).option("createUserModel", {
+        alias: "u",
+        default: null,
+        description: "Create a User database model",
+        type: "boolean"
+      }).option("generateAuthPages", {
+        alias: "g",
+        default: null,
+        description: "Generate auth pages (login, signup, etc.)",
+        type: "boolean"
+      });
+    },
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth dbAuth",
+        force: args.force,
+        verbose: args.verbose,
+        webauthn: args.webauthn
+      });
+      const handler = await getAuthSetupHandler("@cedarjs/auth-dbauth-setup");
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "firebase",
+    "Set up auth for Firebase",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth firebase",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler(
+        "@cedarjs/auth-firebase-setup"
+      );
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "netlify",
+    "Set up auth for Netlify",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth netlify",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler("@cedarjs/auth-netlify-setup");
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "supabase",
+    "Set up auth for Supabase",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth supabase",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler(
+        "@cedarjs/auth-supabase-setup"
+      );
+      console.log();
+      handler(args);
+    }
+  ).command(
+    "supertokens",
+    "Set up auth for SuperTokens",
+    (yargs2) => standardAuthBuilder(yargs2),
+    async (args) => {
+      recordTelemetryAttributes({
+        command: "setup auth supertokens",
+        force: args.force,
+        verbose: args.verbose
+      });
+      const handler = await getAuthSetupHandler(
+        "@cedarjs/auth-supertokens-setup"
+      );
+      console.log();
+      handler(args);
+    }
+  );
+}
+function directToCustomAuthCommand(provider) {
+  return [
+    provider,
+    false,
+    () => {
+    },
+    () => {
+      recordTelemetryAttributes({
+        command: `setup auth ${provider}`
+      });
+      const customAuthLink = terminalLink(
+        "Custom Auth",
+        "https://redwoodjs.com/docs/auth/custom"
+      );
+      console.log(
+        `${provider} is no longer supported out of the box. But you can still integrate it yourself with ${customAuthLink}`
+      );
+    }
+  ];
+}
+async function getAuthSetupHandler(module) {
+  let customRequire;
+  try {
+    if (typeof require === "undefined") {
+      const { createRequire } = await import("node:module");
+      customRequire = createRequire(import.meta.url);
+    } else {
+      customRequire = require;
+    }
+  } catch (error) {
+    customRequire = require;
+  }
+  const packageJsonPath = customRequire.resolve("@cedarjs/cli/package.json");
+  let { version } = fs.readJSONSync(packageJsonPath);
+  if (!isInstalled(module)) {
+    if (version.includes("+")) {
+      version = version.split("+")[0];
+    }
+    let packument;
+    try {
+      const packumentResponse = await fetch(
+        `https://registry.npmjs.org/${module}`
+      );
+      packument = await packumentResponse.json();
+      if (packument.error) {
+        throw new Error(packument.error);
+      }
+    } catch (error) {
+      throw new Error(
+        `Couldn't fetch packument for ${module}: ${error.message}`
+      );
+    }
+    const versionIsPublished = Object.keys(packument.versions).includes(version);
+    if (!versionIsPublished) {
+      version = "canary";
+    }
+    await execa.command(`yarn add -D ${module}@${version}`, {
+      stdio: "inherit",
+      cwd: getPaths().base
+    });
+  }
+  const setupModule = await import(module);
+  return setupModule.default.handler;
+}
+function isInstalled(module) {
+  const { dependencies, devDependencies } = fs.readJSONSync(
+    path.join(getPaths().base, "package.json")
+  );
+  const deps = {
+    ...dependencies,
+    ...devDependencies
+  };
+  if (deps[module]) {
+    return true;
+  }
+  try {
+    const possiblePaths = [
+      path.join(getPaths().base, "node_modules", module),
+      path.join(getPaths().base, "..", "node_modules", module),
+      path.join(getPaths().api.base, "node_modules", module),
+      path.join(getPaths().web.base, "node_modules", module)
+    ];
+    return possiblePaths.some((modulePath) => {
+      return fs.existsSync(path.join(modulePath, "package.json"));
+    });
+  } catch (error) {
+    return false;
+  }
+}
+export {
+  builder,
+  command,
+  description
+};

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

@@ -0,0 +1,37 @@
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "cache <client>";
+const description = "Sets up an init file for service caching";
+const builder = (yargs) => {
+  yargs.positional("client", {
+    choices: ["memcached", "redis"],
+    description: "Cache client",
+    type: "string",
+    required: true
+  }).option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing cache.js file",
+    type: "boolean"
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#setup-cache"
+    )}`
+  );
+};
+const handler = async (options) => {
+  recordTelemetryAttributes({
+    command: "setup cache",
+    client: options.client,
+    force: options.force
+  });
+  const { handler: handler2 } = await import("./cacheHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};