@cedarjs/cli 0.0.4

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

@@ -0,0 +1,69 @@
+import path from "path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { addEnvVarTask } from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import { addPackagesTask, getPaths, writeFile } from "../../../lib/index.js";
+import { isTypeScriptProject } from "../../../lib/project.js";
+const CLIENT_PACKAGE_MAP = {
+  memcached: "memjs",
+  redis: "redis"
+};
+const CLIENT_HOST_MAP = {
+  memcached: "localhost:11211",
+  redis: "redis://localhost:6379"
+};
+const handler = async ({ client, force }) => {
+  const extension = isTypeScriptProject ? "ts" : "js";
+  const tasks = new Listr([
+    await addPackagesTask({
+      packages: [CLIENT_PACKAGE_MAP[client]],
+      side: "api"
+    }),
+    {
+      title: `Writing api/src/lib/cache.js`,
+      task: () => {
+        const template = fs.readFileSync(
+          path.join(
+            import.meta.dirname,
+            "templates",
+            `${client}.ts.template`
+          )
+        ).toString();
+        return writeFile(
+          path.join(getPaths().api.lib, `cache.${extension}`),
+          template,
+          {
+            overwriteExisting: force
+          }
+        );
+      }
+    },
+    addEnvVarTask(
+      "CACHE_HOST",
+      CLIENT_HOST_MAP[client],
+      `Where your ${client} server lives for service caching`
+    ),
+    {
+      title: "One more thing...",
+      task: (_ctx, task) => {
+        task.title = `One more thing...
+
+          ${c.tip("Check out the Service Cache docs for config and usage:")}
+          ${c.link("https://redwoodjs.com/docs/services#caching")}
+        `;
+      }
+    }
+  ]);
+  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/setup/cache/templates/memcached.ts.template

@@ -0,0 +1,30 @@
+import {
+  createCache,
+  InMemoryClient,
+  MemcachedClient,
+} from '@cedarjs/api/cache'
+
+import { logger } from './logger'
+
+const memJsFormattedLogger = {
+  log: (msg: string) => logger.error(msg),
+}
+
+export let client: InMemoryClient | MemcachedClient
+
+if (process.env.NODE_ENV === 'test') {
+  client = new InMemoryClient()
+} else {
+  try {
+    client = new MemcachedClient(process.env.CACHE_HOST, {
+      logger: memJsFormattedLogger,
+    })
+  } catch (e) {
+    logger.error(`Could not connect to cache: ${e.message}`)
+  }
+}
+
+export const { cache, cacheFindMany, cacheClient, deleteCacheKey } = createCache(client, {
+  logger,
+  timeout: 500,
+})

package/dist/commands/setup/cache/templates/redis.ts.template

@@ -0,0 +1,24 @@
+import {
+  createCache,
+  InMemoryClient,
+  RedisClient,
+} from '@cedarjs/api/cache'
+
+import { logger } from './logger'
+
+export let client: InMemoryClient | RedisClient
+
+if (process.env.NODE_ENV === 'test') {
+  client = new InMemoryClient()
+} else {
+  try {
+    client = new RedisClient({ url: process.env.CACHE_HOST, logger })
+  } catch (e) {
+    logger.error(`Could not connect to cache: ${e.message}`)
+  }
+}
+
+export const { cache, cacheFindMany, cacheClient, deleteCacheKey } = createCache(client, {
+  logger,
+  timeout: 500,
+})

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

@@ -0,0 +1,26 @@
+const command = "deploy <target>";
+const description = "Setup deployment to various targets";
+import terminalLink from "terminal-link";
+import * as setupDeployBaremetal from "./providers/baremetal.js";
+import * as setupDeployCoherence from "./providers/coherence.js";
+import * as setupDeployFlightcontrol from "./providers/flightcontrol.js";
+import * as setupDeployNetlify from "./providers/netlify.js";
+import * as setupDeployRender from "./providers/render.js";
+import * as setupDeployServerless from "./providers/serverless.js";
+import * as setupDeployVercel from "./providers/vercel.js";
+const builder = (yargs) => yargs.command(setupDeployBaremetal).command(setupDeployCoherence).command(setupDeployFlightcontrol).command(setupDeployNetlify).command(setupDeployRender).command(setupDeployServerless).command(setupDeployVercel).demandCommand().option("force", {
+  alias: "f",
+  default: false,
+  description: "Overwrite existing configuration",
+  type: "boolean"
+}).epilogue(
+  `Also see the ${terminalLink(
+    "Redwood CLI Reference",
+    "https://redwoodjs.com/docs/cli-commands#setup-deploy-config"
+  )}`
+);
+export {
+  builder,
+  command,
+  description
+};

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

@@ -0,0 +1,9 @@
+function createHandler(componentName) {
+  return async function handler(argv) {
+    const { handler: importedHandler } = await import(`../providers/${componentName}Handler.js`);
+    return importedHandler(argv);
+  };
+}
+export {
+  createHandler
+};

package/dist/commands/setup/deploy/helpers/index.js

@@ -0,0 +1,110 @@
+import path from "path";
+import execa from "execa";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { getPaths, writeFilesTask } from "../../../../lib/index.js";
+const REDWOOD_TOML_PATH = path.join(getPaths().base, "redwood.toml");
+const updateApiURLTask = (apiUrl) => {
+  return {
+    title: "Updating API URL in redwood.toml...",
+    task: () => {
+      const redwoodToml = fs.readFileSync(REDWOOD_TOML_PATH).toString();
+      let newRedwoodToml = redwoodToml;
+      if (redwoodToml.match(/apiUrl/)) {
+        newRedwoodToml = newRedwoodToml.replace(
+          /apiUrl.*/g,
+          `apiUrl = "${apiUrl}"`
+        );
+      } else if (redwoodToml.match(/\[web\]/)) {
+        newRedwoodToml = newRedwoodToml.replace(
+          /\[web\]/,
+          `[web]
+  apiUrl = "${apiUrl}"`
+        );
+      } else {
+        newRedwoodToml += `[web]
+  apiUrl = "${apiUrl}"`;
+      }
+      fs.writeFileSync(REDWOOD_TOML_PATH, newRedwoodToml);
+    }
+  };
+};
+const preRequisiteCheckTask = (preRequisites) => {
+  return {
+    title: "Checking pre-requisites",
+    task: () => new Listr(
+      preRequisites.map((preReq) => {
+        return {
+          title: preReq.title,
+          task: async () => {
+            try {
+              await execa(...preReq.command);
+            } catch (error) {
+              error.message = error.message + "\n" + preReq.errorMessage;
+              throw error;
+            }
+          }
+        };
+      })
+    )
+  };
+};
+const addFilesTask = ({
+  files,
+  force = false,
+  title = "Adding config"
+}) => {
+  return {
+    title: `${title}...`,
+    task: () => {
+      let fileNameToContentMap = {};
+      files.forEach((fileData) => {
+        fileNameToContentMap[fileData.path] = fileData.content;
+      });
+      return writeFilesTask(fileNameToContentMap, { overwriteExisting: force });
+    }
+  };
+};
+const addToGitIgnoreTask = ({ paths }) => {
+  return {
+    title: "Updating .gitignore...",
+    skip: () => {
+      if (!fs.existsSync(path.resolve(getPaths().base, ".gitignore"))) {
+        return "No gitignore present, skipping.";
+      }
+    },
+    task: async (_ctx, task) => {
+      const gitIgnore = path.resolve(getPaths().base, ".gitignore");
+      const content = fs.readFileSync(gitIgnore).toString();
+      if (paths.every((item) => content.includes(item))) {
+        task.skip(".gitignore already includes the additions.");
+      }
+      fs.appendFileSync(gitIgnore, ["\n", "# Deployment", ...paths].join("\n"));
+    }
+  };
+};
+const addToDotEnvTask = ({ lines }) => {
+  return {
+    title: "Updating .env...",
+    skip: () => {
+      if (!fs.existsSync(path.resolve(getPaths().base, ".env"))) {
+        return "No .env present, skipping.";
+      }
+    },
+    task: async (_ctx, task) => {
+      const env = path.resolve(getPaths().base, ".env");
+      const content = fs.readFileSync(env).toString();
+      if (lines.every((line) => content.includes(line.split("=")[0]))) {
+        task.skip(".env already includes the additions.");
+      }
+      fs.appendFileSync(env, lines.join("\n"));
+    }
+  };
+};
+export {
+  addFilesTask,
+  addToDotEnvTask,
+  addToGitIgnoreTask,
+  preRequisiteCheckTask,
+  updateApiURLTask
+};

package/dist/commands/setup/deploy/providers/baremetal.js

@@ -0,0 +1,9 @@
+import { createHandler } from "../helpers/helpers.js";
+const command = "baremetal";
+const description = "Setup Baremetal deploy";
+const handler = createHandler("baremetal");
+export {
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/deploy/providers/baremetalHandler.js

@@ -0,0 +1,64 @@
+import path from "path";
+import { Listr } from "listr2";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../../lib/colors.js";
+import {
+  addPackagesTask,
+  getPaths,
+  printSetupNotes
+} from "../../../../lib/index.js";
+import { addFilesTask } from "../helpers/index.js";
+import { DEPLOY, ECOSYSTEM, MAINTENANCE } from "../templates/baremetal.js";
+const configFilename = "deploy.toml";
+const files = [
+  {
+    path: path.join(getPaths().base, configFilename),
+    content: DEPLOY
+  },
+  {
+    path: path.join(getPaths().base, "ecosystem.config.js"),
+    content: ECOSYSTEM
+  },
+  {
+    path: path.join(getPaths().web.src, "maintenance.html"),
+    content: MAINTENANCE
+  }
+];
+const notes = [
+  "You are almost ready to go BAREMETAL!",
+  "",
+  "See https://redwoodjs.com/docs/deploy/baremetal for the remaining",
+  "config and setup required before you can perform your first deploy."
+];
+const handler = async ({ force }) => {
+  recordTelemetryAttributes({
+    command: "setup deploy baremetal",
+    force
+  });
+  const tasks = new Listr(
+    [
+      await addPackagesTask({
+        packages: ["node-ssh"],
+        devDependency: true
+      }),
+      addFilesTask({
+        files,
+        force
+      }),
+      printSetupNotes(notes)
+    ],
+    { rendererOptions: { collapseSubtasks: false } }
+  );
+  try {
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  configFilename,
+  handler
+};

package/dist/commands/setup/deploy/providers/coherence.js

@@ -0,0 +1,24 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "coherence";
+const description = "Setup Coherence deploy";
+function builder(yargs) {
+  yargs.option("force", {
+    description: "Overwrite existing configuration",
+    type: "boolean",
+    default: false
+  });
+}
+async function handler(options) {
+  recordTelemetryAttributes({
+    command: "setup deploy coherence",
+    force: options.force
+  });
+  const { handler: handler2 } = await import("./coherenceHandler.js");
+  return handler2(options);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/deploy/providers/coherenceHandler.js

@@ -0,0 +1,203 @@
+import path from "path";
+import prismaInternals from "@prisma/internals";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import * as toml from "smol-toml";
+import {
+  colors as c,
+  getPaths,
+  isTypeScriptProject
+} from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import { printSetupNotes } from "../../../../lib/index.js";
+import { serverFileExists } from "../../../../lib/project.js";
+import { addFilesTask } from "../helpers/index.js";
+const { getSchema, getConfig } = prismaInternals;
+const redwoodProjectPaths = getPaths();
+const EXTENSION = isTypeScriptProject ? "ts" : "js";
+async function handler({ force }) {
+  try {
+    const addCoherenceFilesTask = await getAddCoherenceFilesTask(force);
+    const tasks = new Listr(
+      [
+        addCoherenceFilesTask,
+        updateRedwoodTOMLTask(),
+        printSetupNotes([
+          "You're ready to deploy to Coherence! \u2728\n",
+          "Go to https://app.withcoherence.com to create your account and setup your cloud or GitHub connections.",
+          "Check out the deployment docs at https://docs.withcoherence.com for detailed instructions and more information.\n",
+          "Reach out to redwood@withcoherence.com with any questions! We're here to support you."
+        ])
+      ],
+      { rendererOptions: { collapse: false } }
+    );
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+}
+async function getAddCoherenceFilesTask(force) {
+  const files = [
+    {
+      path: path.join(redwoodProjectPaths.api.functions, `health.${EXTENSION}`),
+      content: coherenceFiles.healthCheck
+    }
+  ];
+  const coherenceConfigFile = {
+    path: path.join(redwoodProjectPaths.base, "coherence.yml")
+  };
+  coherenceConfigFile.content = await getCoherenceConfigFileContent();
+  files.push(coherenceConfigFile);
+  return addFilesTask({
+    title: `Adding coherence.yml and health.${EXTENSION}`,
+    files,
+    force
+  });
+}
+async function getCoherenceConfigFileContent() {
+  const prismaSchema = await getSchema(redwoodProjectPaths.api.dbSchema);
+  const prismaConfig = await getConfig({ datamodel: prismaSchema });
+  let db = prismaConfig.datasources[0].activeProvider;
+  if (!SUPPORTED_DATABASES.includes(db)) {
+    throw new Error(
+      [
+        `Coherence doesn't support the "${db}" provider in your Prisma schema.`,
+        `To proceed, switch to one of the following: ${SUPPORTED_DATABASES.join(
+          ", "
+        )}.`
+      ].join("\n")
+    );
+  }
+  if (db === "postgresql") {
+    db = "postgres";
+  }
+  const apiProdCommand = ["yarn", "rw", "build", "api", "&&"];
+  if (serverFileExists()) {
+    apiProdCommand.push(
+      "yarn",
+      "node",
+      "api/dist/server.js",
+      "--apiRootPath=/api"
+    );
+  } else {
+    apiProdCommand.push("yarn", "rw", "serve", "api", "--apiRootPath=/api");
+  }
+  return coherenceFiles.yamlTemplate({
+    db,
+    apiProdCommand: `[${apiProdCommand.map((cmd) => `"${cmd}"`).join(", ")}]`
+  });
+}
+const SUPPORTED_DATABASES = ["mysql", "postgresql"];
+function updateRedwoodTOMLTask() {
+  return {
+    title: "Updating redwood.toml...",
+    task: () => {
+      const redwoodTOMLPath = path.join(
+        redwoodProjectPaths.base,
+        "redwood.toml"
+      );
+      let redwoodTOMLContent = fs.readFileSync(redwoodTOMLPath, "utf-8");
+      const redwoodTOMLObject = toml.parse(redwoodTOMLContent);
+      if (!redwoodTOMLObject.web.host) {
+        const [beforeWeb, afterWeb] = redwoodTOMLContent.split(/\[web\]\s/);
+        redwoodTOMLContent = [
+          beforeWeb,
+          '[web]\n  host = "0.0.0.0"\n',
+          afterWeb
+        ].join("");
+      }
+      if (!redwoodTOMLObject.api.host) {
+        const [beforeApi, afterApi] = redwoodTOMLContent.split(/\[api\]\s/);
+        redwoodTOMLContent = [
+          beforeApi,
+          '[api]\n  host = "0.0.0.0"\n',
+          afterApi
+        ].join("");
+      }
+      redwoodTOMLContent = redwoodTOMLContent.replaceAll(
+        HOST_REGEXP,
+        (match, spaceBeforeAssign, spaceAfterAssign) => ["host", spaceBeforeAssign, "=", spaceAfterAssign, '"0.0.0.0"'].join(
+          ""
+        )
+      );
+      redwoodTOMLContent = redwoodTOMLContent.replace(
+        API_URL_REGEXP,
+        (match, spaceBeforeAssign, spaceAfterAssign) => ["apiUrl", spaceBeforeAssign, "=", spaceAfterAssign, '"/api"'].join(
+          ""
+        )
+      );
+      redwoodTOMLContent = redwoodTOMLContent.replaceAll(
+        PORT_REGEXP,
+        (_match, spaceBeforeAssign, spaceAfterAssign, port) => [
+          "port",
+          spaceBeforeAssign,
+          "=",
+          spaceAfterAssign,
+          `"\${PORT:${port}}"`
+        ].join("")
+      );
+      fs.writeFileSync(redwoodTOMLPath, redwoodTOMLContent);
+    }
+  };
+}
+const HOST_REGEXP = /host(\s*)=(\s*)\".+\"/g;
+const API_URL_REGEXP = /apiUrl(\s*)=(\s*)\".+\"/;
+const PORT_REGEXP = /port(\s*)=(\s*)(?<port>\d{4})/g;
+const coherenceFiles = {
+  yamlTemplate({ db, apiProdCommand }) {
+    return `api:
+  type: backend
+  url_path: "/api"
+  prod:
+    command: ${apiProdCommand}
+  dev:
+    command: ["yarn", "rw", "build", "api", "&&", "yarn", "rw", "dev", "api", "--apiRootPath=/api"]
+  local_packages: ["node_modules"]
+
+  system:
+    cpu: 2
+    memory: 2G
+    health_check: "/api/health"
+
+  resources:
+    - name: ${path.basename(redwoodProjectPaths.base)}-db
+      engine: ${db}
+      version: 13
+      type: database
+      ${db === "postgres" ? "adapter: postgresql" : ""}
+
+  # If you use data migrations, use the following instead:
+  # migration: ["yarn", "rw", "prisma", "migrate", "deploy", "&&", "yarn", "rw", "data-migrate", "up"]
+  migration: ["yarn", "rw", "prisma", "migrate", "deploy"]
+
+web:
+  type: frontend
+  assets_path: "web/dist"
+  prod:
+    command: ["yarn", "rw", "serve", "web"]
+  dev:
+    command: ["yarn", "rw", "dev", "web", "--fwd=\\"--allowed-hosts all\\""]
+
+  # Heads up: Redwood's prerender doesn't work with Coherence yet.
+  # For current status and updates, see https://github.com/redwoodjs/redwood/issues/8333.
+  build: ["yarn", "rw", "build", "web", "--no-prerender"]
+  local_packages: ["node_modules"]
+
+  system:
+    cpu: 2
+    memory: 2G
+`;
+  },
+  healthCheck: `// Coherence health check
+export const handler = async () => {
+  return {
+    statusCode: 200,
+  }
+}
+`
+};
+export {
+  handler
+};

package/dist/commands/setup/deploy/providers/flightcontrol.js

@@ -0,0 +1,19 @@
+import { createHandler } from "../helpers/helpers.js";
+const command = "flightcontrol";
+const alias = "fc";
+const description = "Setup Flightcontrol deploy";
+const builder = (yargs) => yargs.option("database", {
+  alias: "d",
+  choices: ["none", "postgresql", "mysql"],
+  description: "Database deployment for Flightcontrol only",
+  default: "postgresql",
+  type: "string"
+});
+const handler = createHandler("flightcontrol");
+export {
+  alias,
+  builder,
+  command,
+  description,
+  handler
+};