@cedarjs/cli 0.0.4

package/dist/commands/deploy/flightcontrolHandler.js

@@ -0,0 +1,58 @@
+import path from "path";
+import execa from "execa";
+import fs from "fs-extra";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getPaths } from "@cedarjs/project-config";
+const handler = async ({ side, serve, prisma, dm: dataMigrate }) => {
+  recordTelemetryAttributes({
+    command: "deploy flightcontrol",
+    side,
+    prisma,
+    dataMigrate,
+    serve
+  });
+  const rwjsPaths = getPaths();
+  const execaConfig = {
+    cwd: rwjsPaths.base,
+    shell: true,
+    stdio: "inherit"
+  };
+  async function runApiCommands() {
+    if (!serve) {
+      console.log("Building api...");
+      execa.commandSync("yarn rw build api --verbose", execaConfig);
+      if (prisma) {
+        console.log("Running database migrations...");
+        execa.commandSync(
+          `node_modules/.bin/prisma migrate deploy --schema "${rwjsPaths.api.dbSchema}"`,
+          execaConfig
+        );
+      }
+      if (dataMigrate) {
+        console.log("Running data migrations...");
+        execa.commandSync("yarn rw dataMigrate up", execaConfig);
+      }
+      return;
+    }
+    const serverFilePath = path.join(rwjsPaths.api.dist, "server.js");
+    const hasServerFile = fs.pathExistsSync(serverFilePath);
+    if (hasServerFile) {
+      execa(`yarn node ${serverFilePath}`, execaConfig);
+    } else {
+      const { handler: handler2 } = await import("@cedarjs/api-server/dist/apiCLIConfigHandler.js");
+      handler2();
+    }
+  }
+  async function runWebCommands() {
+    console.log("Building web...");
+    execa.commandSync("yarn rw build web --verbose", execaConfig);
+  }
+  if (side === "api") {
+    runApiCommands();
+  } else if (side === "web") {
+    runWebCommands();
+  }
+};
+export {
+  handler
+};

package/dist/commands/deploy/helpers/deployBuilder.js

@@ -0,0 +1,25 @@
+import terminalLink from "terminal-link";
+const deployBuilder = (yargs) => {
+  yargs.option("build", {
+    description: "Build for production",
+    type: "boolean",
+    default: "true"
+  }).option("prisma", {
+    description: "Apply database migrations",
+    type: "boolean",
+    default: "true"
+  }).option("data-migrate", {
+    description: "Migrate the data in your database",
+    type: "boolean",
+    default: "true",
+    alias: "dm"
+  }).epilogue(
+    `For more commands, options, and examples, see ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#deploy"
+    )}`
+  );
+};
+export {
+  deployBuilder
+};

package/dist/commands/deploy/helpers/deployHandler.js

@@ -0,0 +1,31 @@
+import execa from "execa";
+import { getPaths } from "@cedarjs/project-config";
+import c from "../../../lib/colors.js";
+const deployHandler = async ({ build, prisma, dm: dataMigrate }) => {
+  const paths = getPaths();
+  let commandSet = [];
+  if (build) {
+    commandSet.push("yarn rw build --verbose");
+  }
+  if (prisma) {
+    commandSet.push("yarn rw prisma migrate deploy");
+  }
+  if (dataMigrate) {
+    commandSet.push("yarn rw data-migrate up");
+  }
+  const joinedCommands = commandSet.join(" && ");
+  console.log(c.note(`
+Running:
+`) + `${joinedCommands} 
+`);
+  return execa(joinedCommands, {
+    shell: true,
+    stdio: "inherit",
+    cwd: paths.base,
+    extendEnv: true,
+    cleanup: true
+  });
+};
+export {
+  deployHandler
+};

package/dist/commands/deploy/netlify.js

@@ -0,0 +1,21 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { deployBuilder } from "./helpers/deployBuilder.js";
+const command = "netlify [...commands]";
+const description = "Build command for Netlify deploy";
+const builder = (yargs) => deployBuilder(yargs);
+async function handler(yargs) {
+  recordTelemetryAttributes({
+    command: "deploy netlify",
+    build: yargs.build,
+    prisma: yargs.prisma,
+    dataMigrate: yargs.dataMigrate
+  });
+  const { handler: importedHandler } = await import("./helpers/deployHandler.js");
+  return importedHandler(yargs);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/deploy/packing/nft.js

@@ -0,0 +1,61 @@
+import path from "path";
+import { nodeFileTrace } from "@vercel/nft";
+import archiver from "archiver";
+import fse from "fs-extra";
+import { findApiDistFunctions } from "@cedarjs/internal/dist/files";
+import { ensurePosixPath, getPaths } from "@cedarjs/project-config";
+import * as nftPacker from "../packing/nft.js";
+const ZIPBALL_DIR = "./api/dist/zipball";
+function zipDirectory(source, out) {
+  const archive = archiver("zip", { zlib: { level: 5 } });
+  const stream = fse.createWriteStream(out);
+  return new Promise((resolve, reject) => {
+    archive.directory(source, false).on("error", (err) => reject(err)).pipe(stream);
+    stream.on("close", () => resolve());
+    archive.finalize();
+  });
+}
+function generateEntryFile(functionAbsolutePath, name) {
+  const relativeImport = ensurePosixPath(
+    path.relative(getPaths().base, functionAbsolutePath)
+  );
+  return [
+    `${ZIPBALL_DIR}/${name}/${name}.js`,
+    `module.exports = require('./${relativeImport}')`
+  ];
+}
+async function packageSingleFunction(functionFile) {
+  const { name: functionName } = path.parse(functionFile);
+  const { fileList: functionDependencyFileList } = await nodeFileTrace([
+    functionFile
+  ]);
+  const copyPromises = [];
+  for (const singleDependencyPath of functionDependencyFileList) {
+    copyPromises.push(
+      fse.copy(
+        "./" + singleDependencyPath,
+        `${ZIPBALL_DIR}/${functionName}/${singleDependencyPath}`
+      )
+    );
+  }
+  const [entryFilePath, content] = generateEntryFile(functionFile, functionName);
+  const functionEntryPromise = fse.outputFile(entryFilePath, content);
+  copyPromises.push(functionEntryPromise);
+  await Promise.all(copyPromises);
+  await zipDirectory(
+    `${ZIPBALL_DIR}/${functionName}`,
+    `${ZIPBALL_DIR}/${functionName}.zip`
+  );
+  await fse.remove(`${ZIPBALL_DIR}/${functionName}`);
+  return;
+}
+function nftPack() {
+  const filesToBePacked = findApiDistFunctions();
+  return Promise.all(filesToBePacked.map(nftPacker.packageSingleFunction));
+}
+export {
+  generateEntryFile,
+  nftPack,
+  packageSingleFunction,
+  zipDirectory
+};

package/dist/commands/deploy/render.js

@@ -0,0 +1,37 @@
+import terminalLink from "terminal-link";
+if (process.argv.slice(2).includes("api")) {
+  process.env.REDWOOD_DISABLE_TELEMETRY = 1;
+}
+const command = "render <side>";
+const description = "Build, migrate, and serve command for Render deploy";
+const builder = (yargs) => {
+  yargs.positional("side", {
+    choices: ["api", "web"],
+    description: "Side to deploy",
+    type: "string"
+  }).option("prisma", {
+    description: "Apply database migrations",
+    type: "boolean",
+    default: true
+  }).option("data-migrate", {
+    description: "Apply data migrations",
+    type: "boolean",
+    default: true,
+    alias: "dm"
+  }).epilogue(
+    `For more commands, options, and examples, see ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#deploy"
+    )}`
+  );
+};
+async function handler(yargs) {
+  const { handler: importedHandler } = await import("./renderHandler.js");
+  return importedHandler(yargs);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/deploy/renderHandler.js

@@ -0,0 +1,70 @@
+import path from "path";
+import execa from "execa";
+import fs from "fs-extra";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getPaths } from "@cedarjs/project-config";
+const handler = async ({ side, prisma, dataMigrate }) => {
+  recordTelemetryAttributes({
+    command: "deploy render",
+    side,
+    prisma,
+    dataMigrate
+  });
+  const rwjsPaths = getPaths();
+  const execaConfig = {
+    cwd: rwjsPaths.base,
+    shell: true,
+    stdio: "inherit"
+  };
+  async function runApiCommands() {
+    if (prisma) {
+      console.log("Running database migrations...");
+      execa.commandSync(
+        `node_modules/.bin/prisma migrate deploy --schema "${rwjsPaths.api.dbSchema}"`,
+        execaConfig
+      );
+    }
+    if (dataMigrate) {
+      console.log("Running data migrations...");
+      const packageJson = fs.readJsonSync(
+        path.join(rwjsPaths.base, "package.json")
+      );
+      const hasDataMigratePackage = !!packageJson.devDependencies["@cedarjs/cli-data-migrate"];
+      if (!hasDataMigratePackage) {
+        console.error(
+          [
+            "Skipping data migrations; your project doesn't have the `@cedarjs/cli-data-migrate` package as a dev dependency.",
+            "Without it installed, you're likely to run into memory issues during deploy.",
+            "If you want to run data migrations, add the package to your project's root package.json and deploy again:",
+            "",
+            "```",
+            "yarn add -D @cedarjs/cli-data-migrate",
+            "```"
+          ].join("\n")
+        );
+      } else {
+        execa.commandSync("yarn rw dataMigrate up", execaConfig);
+      }
+    }
+    const serverFilePath = path.join(rwjsPaths.api.dist, "server.js");
+    const hasServerFile = fs.pathExistsSync(serverFilePath);
+    if (hasServerFile) {
+      execa(`yarn node ${serverFilePath}`, execaConfig);
+    } else {
+      const { handler: handler2 } = await import("@cedarjs/api-server/dist/apiCLIConfigHandler.js");
+      handler2();
+    }
+  }
+  async function runWebCommands() {
+    execa.commandSync("yarn install", execaConfig);
+    execa.commandSync("yarn rw build web --verbose", execaConfig);
+  }
+  if (side === "api") {
+    runApiCommands();
+  } else if (side === "web") {
+    runWebCommands();
+  }
+};
+export {
+  handler
+};

package/dist/commands/deploy/serverless.js

@@ -0,0 +1,51 @@
+import terminalLink from "terminal-link";
+const command = "serverless";
+const aliases = ["aws serverless", "sls"];
+const description = "Deploy to AWS via the serverless framework";
+const builder = (yargs) => {
+  yargs.option("stage", {
+    describe: "serverless stage pass through param: https://www.serverless.com/blog/stages-and-environments",
+    default: "production",
+    type: "string"
+  });
+  yargs.option("sides", {
+    describe: "which Side(s) to deploy",
+    choices: ["api", "web"],
+    default: ["api", "web"],
+    alias: "side",
+    type: "array"
+  });
+  yargs.option("verbose", {
+    describe: "verbosity of logs",
+    default: true,
+    type: "boolean"
+  });
+  yargs.option("pack-only", {
+    describe: "Only build and pack, and dont push code up using serverless",
+    default: false,
+    type: "boolean"
+  });
+  yargs.option("first-run", {
+    describe: "Set this flag the first time you deploy, to configure your API URL on the webside",
+    default: false,
+    type: "boolean"
+  });
+  yargs.epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#deploy"
+    )}
+`
+  );
+};
+async function handler(yargs) {
+  const { handler: importedHandler } = await import("./serverlessHandler.js");
+  return importedHandler(yargs);
+}
+export {
+  aliases,
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/deploy/serverlessHandler.js

@@ -0,0 +1,211 @@
+import path from "path";
+import boxen from "boxen";
+import chalk from "chalk";
+import { config } from "dotenv-defaults";
+import execa from "execa";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import prompts from "prompts";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import c from "../../lib/colors.js";
+import { getPaths } from "../../lib/index.js";
+const preRequisites = () => [
+  {
+    title: "Checking if Serverless framework is installed...",
+    command: ["yarn serverless", ["--version"]],
+    errorMessage: [
+      "Looks like Serverless is not installed.",
+      "Please run yarn add -W --dev serverless."
+    ]
+  }
+];
+const buildCommands = ({ sides }) => {
+  return [
+    {
+      title: `Building ${sides.join(" & ")}...`,
+      command: ["yarn", ["rw", "build", ...sides]]
+    },
+    {
+      title: "Packing Functions...",
+      enabled: () => sides.includes("api"),
+      task: async () => {
+        const { nftPack } = await import("./packing/nft.js");
+        await nftPack();
+      }
+    }
+  ];
+};
+const deployCommands = ({ stage, sides, firstRun, packOnly }) => {
+  const slsStage = stage ? ["--stage", stage] : [];
+  return sides.map((side) => {
+    return {
+      title: `Deploying ${side}....`,
+      task: async () => {
+        await execa("yarn", ["serverless", "deploy", ...slsStage], {
+          cwd: path.join(getPaths().base, side),
+          shell: true,
+          stdio: "inherit",
+          cleanup: true
+        });
+      },
+      skip: () => {
+        if (firstRun && side === "web") {
+          return "Skipping web deploy, until environment configured";
+        }
+        if (packOnly) {
+          return "Finishing early due to --pack-only flag. Your Redwood project is packaged and ready to deploy";
+        }
+      }
+    };
+  });
+};
+const loadDotEnvForStage = (dotEnvPath) => {
+  config({
+    path: dotEnvPath,
+    defaults: path.join(getPaths().base, ".env.defaults"),
+    encoding: "utf8"
+  });
+};
+const handler = async (yargs) => {
+  recordTelemetryAttributes({
+    command: "deploy serverless",
+    sides: JSON.stringify(yargs.sides),
+    verbose: yargs.verbose,
+    packOnly: yargs.packOnly,
+    firstRun: yargs.firstRun
+  });
+  const rwjsPaths = getPaths();
+  const dotEnvPath = path.join(rwjsPaths.base, `.env.${yargs.stage}`);
+  loadDotEnvForStage(dotEnvPath);
+  const tasks = new Listr(
+    [
+      ...preRequisites(yargs).map(mapCommandsToListr),
+      ...buildCommands(yargs).map(mapCommandsToListr),
+      ...deployCommands(yargs).map(mapCommandsToListr)
+    ],
+    {
+      exitOnError: true,
+      renderer: yargs.verbose && "verbose"
+    }
+  );
+  try {
+    await tasks.run();
+    if (yargs.firstRun) {
+      const SETUP_MARKER = chalk.bgBlue(chalk.black("First Setup "));
+      console.log();
+      console.log(SETUP_MARKER, c.success("Starting first setup wizard..."));
+      const { stdout: slsInfo } = await execa(
+        `yarn serverless info --verbose --stage=${yargs.stage}`,
+        {
+          shell: true,
+          cwd: getPaths().api.base
+        }
+      );
+      const deployedApiUrl = slsInfo.match(/HttpApiUrl: (https:\/\/.*)/)[1];
+      console.log();
+      console.log(SETUP_MARKER, `Found ${c.success(deployedApiUrl)}`);
+      console.log();
+      const { addDotEnv } = await prompts({
+        type: "confirm",
+        name: "addDotEnv",
+        message: `Add API_URL to your .env.${yargs.stage}? This will be used if you deploy the web side from your machine`
+      });
+      if (addDotEnv) {
+        fs.writeFileSync(dotEnvPath, `API_URL=${deployedApiUrl}`);
+        loadDotEnvForStage(dotEnvPath);
+      }
+      if (yargs.sides.includes("web")) {
+        console.log();
+        console.log(SETUP_MARKER, "Deploying web side with updated API_URL");
+        console.log(
+          SETUP_MARKER,
+          "First deploys can take a good few minutes..."
+        );
+        console.log();
+        const webDeployTasks = new Listr(
+          [
+            // Rebuild web with the new API_URL
+            ...buildCommands({ ...yargs, sides: ["web"], firstRun: false }).map(
+              mapCommandsToListr
+            ),
+            ...deployCommands({
+              ...yargs,
+              sides: ["web"],
+              firstRun: false
+            }).map(mapCommandsToListr)
+          ],
+          {
+            exitOnError: true,
+            renderer: yargs.verbose && "verbose"
+          }
+        );
+        await webDeployTasks.run();
+        const { stdout: slsInfo2 } = await execa(
+          `yarn serverless info --verbose --stage=${yargs.stage}`,
+          {
+            shell: true,
+            cwd: getPaths().web.base
+          }
+        );
+        const deployedWebUrl = slsInfo2.match(/url: (https:\/\/.*)/)[1];
+        const message = [
+          c.bold("Successful first deploy!"),
+          "",
+          `View your deployed site at: ${c.success(deployedWebUrl)}`,
+          "",
+          "You can use serverless.com CI/CD by connecting/creating an app",
+          "To do this run `yarn serverless` on each of the sides, and connect your account",
+          "",
+          "Find more information in our docs:",
+          c.underline("https://redwoodjs.com/docs/deploy#serverless")
+        ];
+        console.log(
+          boxen(message.join("\n"), {
+            padding: { top: 0, bottom: 0, right: 1, left: 1 },
+            margin: 1,
+            borderColor: "gray"
+          })
+        );
+      }
+    }
+  } catch (e) {
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+const mapCommandsToListr = ({
+  title,
+  command,
+  task,
+  cwd,
+  errorMessage,
+  skip,
+  enabled
+}) => {
+  return {
+    title,
+    task: task ? task : async () => {
+      try {
+        const executingCommand = execa(...command, {
+          cwd: cwd || getPaths().base,
+          shell: true
+        });
+        executingCommand.stdout.pipe(process.stdout);
+        await executingCommand;
+      } catch (error) {
+        if (errorMessage) {
+          error.message = error.message + "\n" + errorMessage.join(" ");
+        }
+        throw error;
+      }
+    },
+    skip,
+    enabled
+  };
+};
+export {
+  buildCommands,
+  deployCommands,
+  handler,
+  preRequisites
+};

package/dist/commands/deploy/vercel.js

@@ -0,0 +1,21 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { deployBuilder } from "./helpers/deployBuilder.js";
+const command = "vercel [...commands]";
+const description = "Build command for Vercel deploy";
+const builder = (yargs) => deployBuilder(yargs);
+async function handler(yargs) {
+  recordTelemetryAttributes({
+    command: "deploy vercel",
+    build: yargs.build,
+    prisma: yargs.prisma,
+    dataMigrate: yargs.dataMigrate
+  });
+  const { handler: importedHandler } = await import("./helpers/deployHandler.js");
+  return importedHandler(yargs);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/deploy.js

@@ -0,0 +1,21 @@
+const command = "deploy <target>";
+const description = "Deploy your Redwood project";
+import terminalLink from "terminal-link";
+import * as deployBaremetal from "./deploy/baremetal.js";
+import * as deployFlightcontrol from "./deploy/flightcontrol.js";
+import * as deployNetlify from "./deploy/netlify.js";
+import * as deployRender from "./deploy/render.js";
+import * as deployServerless from "./deploy/serverless.js";
+import * as deployVercel from "./deploy/vercel.js";
+const builder = (yargs) => yargs.command(deployBaremetal).command(deployFlightcontrol).command(deployNetlify).command(deployRender).command(deployServerless).command(deployVercel).demandCommand().epilogue(
+  `Also see the ${terminalLink(
+    "Redwood CLI Reference",
+    "https://redwoodjs.com/docs/cli-commands#deploy"
+  )}
+`
+);
+export {
+  builder,
+  command,
+  description
+};

package/dist/commands/destroy/cell/cell.js

@@ -0,0 +1,12 @@
+import { files as cellFiles } from "../../generate/cell/cellHandler.js";
+import { createYargsForComponentDestroy, createHandler } from "../helpers.js";
+const { command, description, builder } = createYargsForComponentDestroy(
+  { componentName: "cell", filesFn: cellFiles }
+);
+const handler = createHandler("cell");
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/destroy/cell/cellHandler.js

@@ -0,0 +1,10 @@
+import { files as cellFiles } from "../../generate/cell/cell.js";
+import { createHandler } from "../handlerHelpers.js";
+const { handler, tasks } = createHandler({
+  componentName: "cell",
+  filesFn: cellFiles
+});
+export {
+  handler,
+  tasks
+};

package/dist/commands/destroy/component/component.js

@@ -0,0 +1,15 @@
+import { files as componentFiles } from "../../generate/component/componentHandler.js";
+import { createHandler, createYargsForComponentDestroy } from "../helpers.js";
+const description = "Destroy a component";
+const { command, builder, tasks } = createYargsForComponentDestroy({
+  componentName: "component",
+  filesFn: componentFiles
+});
+const handler = createHandler("component");
+export {
+  builder,
+  command,
+  description,
+  handler,
+  tasks
+};

package/dist/commands/destroy/component/componentHandler.js

@@ -0,0 +1,10 @@
+import { files as componentFiles } from "../../generate/component/componentHandler.js";
+import { createHandler } from "../handlerHelpers.js";
+const { handler, tasks } = createHandler({
+  componentName: "component",
+  filesFn: componentFiles
+});
+export {
+  handler,
+  tasks
+};

package/dist/commands/destroy/directive/directive.js

@@ -0,0 +1,14 @@
+import { files as directiveFiles } from "../../generate/directive/directiveHandler.js";
+import { createYargsForComponentDestroy, createHandler } from "../helpers.js";
+const description = "Destroy a directive";
+const { command, builder } = createYargsForComponentDestroy({
+  componentName: "directive",
+  filesFn: (args) => directiveFiles({ ...args, type: "validator" })
+});
+const handler = createHandler("directive");
+export {
+  builder,
+  command,
+  description,
+  handler
+};