@cedarjs/cli 0.0.4

package/dist/commands/setup/uploads/uploadsHandler.js

@@ -0,0 +1,147 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { format } from "prettier";
+import { addApiPackages, getPrettierOptions } from "@cedarjs/cli-helpers";
+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 { runTransform } from "../../../lib/runTransform.js";
+const handler = async ({ force }) => {
+  const projectIsTypescript = isTypeScriptProject();
+  const redwoodVersion = await import(path.join(getPaths().base, "package.json"), {
+    with: { type: "json " }
+  }).default.devDependencies["@cedarjs/core"] ?? "latest";
+  const tasks = new Listr(
+    [
+      {
+        title: `Adding api/src/lib/uploads.${projectIsTypescript ? "ts" : "js"}...`,
+        task: async () => {
+          const templatePath = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "srcLibUploads.ts.template"
+          );
+          const templateContent = fs.readFileSync(templatePath, {
+            encoding: "utf8",
+            flag: "r"
+          });
+          const uploadsPath = path.join(
+            getPaths().api.lib,
+            `uploads.${projectIsTypescript ? "ts" : "js"}`
+          );
+          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
+          return writeFile(uploadsPath, uploadsContent, {
+            overwriteExisting: force
+          });
+        }
+      },
+      {
+        title: `Adding signedUrl function...`,
+        task: async () => {
+          const templatePath = path.resolve(
+            import.meta.dirname,
+            "templates",
+            "signedUrl.ts.template"
+          );
+          const templateContent = fs.readFileSync(templatePath, {
+            encoding: "utf8",
+            flag: "r"
+          });
+          const uploadsPath = path.join(
+            getPaths().api.functions,
+            `signedUrl.${projectIsTypescript ? "ts" : "js"}`
+          );
+          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
+          return writeFile(uploadsPath, uploadsContent, {
+            overwriteExisting: force
+          });
+        }
+      },
+      {
+        ...addApiPackages([`@cedarjs/storage@${redwoodVersion}`]),
+        title: "Adding dependencies to your api side..."
+      },
+      {
+        title: "Modifying api/src/lib/db to add uploads prisma extension..",
+        task: async () => {
+          const dbPath = path.join(
+            getPaths().api.lib,
+            `db.${projectIsTypescript ? "ts" : "js"}`
+          );
+          const transformResult = await runTransform({
+            transformPath: path.join(import.meta.dirname, "dbCodemod.js"),
+            targetPaths: [dbPath]
+          });
+          if (transformResult.error) {
+            if (transformResult.error === "RW_CODEMOD_ERR_OLD_FORMAT") {
+              throw new Error(
+                "It looks like your src/lib/db file is using the old format. Please update it as per the v8 upgrade guide: https://redwoodjs.com/upgrade/v8#database-file-structure-change. And run again. \n\nYou can also manually modify your api/src/lib/db to include the prisma extension: https://docs.redwoodjs.com/docs/uploads/#attaching-the-prisma-extension"
+              );
+            }
+            throw new Error(
+              "Could not add the prisma extension. \n Please modify your api/src/lib/db to include the prisma extension: https://docs.redwoodjs.com/docs/uploads/#attaching-the-prisma-extension"
+            );
+          }
+        }
+      },
+      {
+        title: "Prettifying changed files",
+        task: async (_ctx, task) => {
+          const prettifyPaths = [
+            path.join(getPaths().api.lib, "db.js"),
+            path.join(getPaths().api.lib, "db.ts"),
+            path.join(getPaths().api.lib, "uploads.js"),
+            path.join(getPaths().api.lib, "uploads.ts")
+          ];
+          for (const prettifyPath of prettifyPaths) {
+            try {
+              if (!fs.existsSync(prettifyPath)) {
+                continue;
+              }
+              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: (_ctx, task) => {
+          task.title = `One more thing...
+
+          ${c.success("\nUploads and storage configured!\n")}
+
+          Remember to add UPLOADS_SECRET to your .env file. You can generate one with ${c.highlight("yarn rw generate secret")}
+
+
+          Check out the docs for more info:
+          ${c.link("https://docs.redwoodjs.com/docs/uploads")}
+
+        `;
+        }
+      }
+    ],
+    {
+      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 {
+  handler
+};

package/dist/commands/setup/vite/templates/vite.config.ts.template

@@ -0,0 +1,19 @@
+import dns from 'dns'
+
+import { defineConfig, UserConfig } from 'vite'
+
+import redwood from '@cedarjs/vite'
+
+// See: https://vitejs.dev/config/server-options.html#server-host
+// So that Vite will load on local instead of 127.0.0.1
+dns.setDefaultResultOrder('verbatim')
+
+/**
+ * https://vitejs.dev/config/
+ * @type {import('vite').UserConfig}
+ */
+const viteConfig: UserConfig = {
+  plugins: [redwood()],
+}
+
+export default defineConfig(viteConfig)

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

@@ -0,0 +1,38 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "vite";
+const description = "Configure the web side to use Vite";
+const builder = (yargs) => {
+  yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  });
+  yargs.option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more logs",
+    type: "boolean"
+  });
+  yargs.option("add-package", {
+    default: true,
+    description: "Allows you to skip adding the @cedarjs/vite package. Useful for testing",
+    type: "boolean"
+  });
+};
+const handler = async (options) => {
+  recordTelemetryAttributes({
+    command: "setup vite",
+    force: options.force,
+    verbose: options.verbose,
+    addPackage: options.addPackage
+  });
+  const { handler: handler2 } = await import("./viteHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/setup/vite/viteHandler.js

@@ -0,0 +1,83 @@
+import path from "path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { addWebPackages } from "@cedarjs/cli-helpers";
+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";
+const { version } = JSON.parse(
+  fs.readFileSync(
+    path.resolve(import.meta.dirname, "../../../../package.json"),
+    "utf-8"
+  )
+);
+const handler = async ({ force, verbose, addPackage }) => {
+  const ts = isTypeScriptProject();
+  const tasks = new Listr(
+    [
+      {
+        title: "Adding vite.config.js...",
+        task: async () => {
+          const viteConfigPath = `${getPaths().web.base}/vite.config.${ts ? "ts" : "js"}`;
+          const templateContent = fs.readFileSync(
+            path.resolve(
+              import.meta.dirname,
+              "templates",
+              "vite.config.ts.template"
+            ),
+            "utf-8"
+          );
+          const viteConfigContent = ts ? templateContent : await transformTSToJS(viteConfigPath, templateContent);
+          return writeFile(viteConfigPath, viteConfigContent, {
+            overwriteExisting: force
+          });
+        }
+      },
+      {
+        title: "Creating new entry point in `web/src/entry.client.{jsx,tsx}`...",
+        task: () => {
+          const entryPointFile = path.join(
+            getPaths().web.src,
+            `entry.client.${ts ? "tsx" : "jsx"}`
+          );
+          const content = fs.readFileSync(
+            path.join(
+              getPaths().base,
+              // NOTE we're copying over the index.js before babel transform
+              "node_modules/@cedarjs/web/src/entry/index.js"
+            ),
+            "utf-8"
+          ).replace("~redwood-app-root", "./App");
+          return writeFile(entryPointFile, content, {
+            overwriteExisting: force
+          });
+        }
+      },
+      {
+        // @NOTE: make sure its added as a dev package.
+        ...addWebPackages(["-D", `@cedarjs/vite@${version}`]),
+        title: "Adding @cedarjs/vite dev dependency to web side...",
+        skip: () => {
+          if (!addPackage) {
+            return "Skipping package install, you will need to add @cedarjs/vite manaually as a dev-dependency on the web workspace";
+          }
+        }
+      }
+    ],
+    {
+      rendererOptions: { collapseSubtasks: false },
+      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/setup.js

@@ -0,0 +1,33 @@
+import terminalLink from "terminal-link";
+import detectRxVersion from "../middleware/detectProjectRxVersion.js";
+import * as setupAuth from "./setup/auth/auth.js";
+import * as setupCache from "./setup/cache/cache.js";
+import * as setupDeploy from "./setup/deploy/deploy.js";
+import * as setupDocker from "./setup/docker/docker.js";
+import * as setupGenerator from "./setup/generator/generator.js";
+import * as setupGraphql from "./setup/graphql/graphql.js";
+import * as setupI18n from "./setup/i18n/i18n.js";
+import * as setupJobs from "./setup/jobs/jobs.js";
+import * as setupMailer from "./setup/mailer/mailer.js";
+import * as setupMiddleware from "./setup/middleware/middleware.js";
+import * as setupMonitoring from "./setup/monitoring/monitoring.js";
+import * as setupPackage from "./setup/package/package.js";
+import * as setupRealtime from "./setup/realtime/realtime.js";
+import * as setupServerFile from "./setup/server-file/serverFile.js";
+import * as setupTsconfig from "./setup/tsconfig/tsconfig.js";
+import * as setupUi from "./setup/ui/ui.js";
+import * as setupUploads from "./setup/uploads/uploads.js";
+import * as setupVite from "./setup/vite/vite.js";
+const command = "setup <command>";
+const description = "Initialize project config and install packages";
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTsconfig).command(setupUi).command(setupUploads).command(setupVite).demandCommand().middleware(detectRxVersion).epilogue(
+  `Also see the ${terminalLink(
+    "Redwood CLI Reference",
+    "https://redwoodjs.com/docs/cli-commands#setup"
+  )}`
+);
+export {
+  builder,
+  command,
+  description
+};

package/dist/commands/studio.js

@@ -0,0 +1,23 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const command = "studio";
+const description = "Run the Redwood development studio";
+function builder(yargs) {
+  yargs.option("open", {
+    default: true,
+    description: "Open the studio in your browser"
+  });
+}
+async function handler(options) {
+  recordTelemetryAttributes({
+    command: "studio",
+    open: options.open
+  });
+  const { handler: handler2 } = await import("./studioHandler.js");
+  return handler2(options);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/studioHandler.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import fs from "fs-extra";
+import semver from "semver";
+import { getPaths } from "@cedarjs/project-config";
+import { isModuleInstalled, installModule } from "../lib/packages.js";
+const handler = async (options) => {
+  try {
+    if (!isModuleInstalled("@cedarjs/studio")) {
+      const minVersions = ["7.0.0-canary.889", "7.x", "8.0.0-0"];
+      assertRedwoodVersion(minVersions);
+      console.log(
+        "The studio package is not installed, installing it for you, this may take a moment..."
+      );
+      await installModule("@cedarjs/studio", "12");
+      console.log("Studio package installed successfully.");
+      const installedRealtime = await installModule("@cedarjs/realtime");
+      if (installedRealtime) {
+        console.log(
+          "Added @cedarjs/realtime to your project, as it's used by Studio"
+        );
+      }
+      const installedApiServer = await installModule("@cedarjs/api-server");
+      if (installedApiServer) {
+        console.log(
+          "Added @cedarjs/api-server to your project, as it's used by Studio"
+        );
+      }
+    }
+    const { serve } = await import("@cedarjs/studio");
+    await serve({ open: options.open, enableWeb: true });
+  } catch (e) {
+    console.log("Cannot start the development studio");
+    console.log(e);
+    process.exit(1);
+  }
+};
+function assertRedwoodVersion(minVersions) {
+  const rwVersion = getProjectRedwoodVersion();
+  const coercedRwVersion = semver.coerce(rwVersion);
+  if (minVersions.some((minVersion) => {
+    const v = semver.valid(minVersion) || semver.coerce(minVersion);
+    const coercedMin = semver.coerce(minVersion);
+    return semver.gte(rwVersion, v) && (coercedRwVersion.major === coercedMin.major ? semver.prerelease(rwVersion)?.[0] === semver.prerelease(v)?.[0] : true);
+  })) {
+    return;
+  }
+  console.error(
+    `The studio command requires Redwood version ${minVersions[0]} or greater, you are using ${rwVersion}.`
+  );
+  process.exit(1);
+}
+function getProjectRedwoodVersion() {
+  const { devDependencies } = fs.readJSONSync(
+    path.join(getPaths().base, "package.json")
+  );
+  return devDependencies["@cedarjs/core"];
+}
+export {
+  assertRedwoodVersion,
+  handler
+};

package/dist/commands/test.js

@@ -0,0 +1,44 @@
+import terminalLink from "terminal-link";
+import c from "../lib/colors.js";
+import { sides } from "../lib/project.js";
+const command = "test [filter..]";
+const description = "Run Jest tests. Defaults to watch mode";
+const builder = (yargs) => {
+  yargs.strict(false).positional("filter", {
+    default: sides(),
+    description: "Which side(s) to test, and/or a regular expression to match against your test files to filter by",
+    type: "array"
+  }).option("watch", {
+    describe: "Run tests related to changed files based on hg/git. Specify the name or path to a file to focus on a specific set of tests",
+    type: "boolean",
+    default: true
+  }).option("collect-coverage", {
+    describe: "Show test coverage summary and output info to coverage directory",
+    type: "boolean",
+    default: false
+  }).option("db-push", {
+    describe: "Syncs the test database with your Prisma schema without requiring a migration. It creates a test database if it doesn't already exist.",
+    type: "boolean",
+    default: true
+  }).epilogue(
+    `For all available flags, run jest cli directly ${c.tip(
+      "yarn jest --help"
+    )}
+
+Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#test"
+    )}
+`
+  );
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./testHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/testHandler.js

@@ -0,0 +1,138 @@
+import path from "path";
+import execa from "execa";
+import fs from "fs-extra";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { ensurePosixPath } from "@cedarjs/project-config";
+import { errorTelemetry, timedTelemetry } from "@cedarjs/telemetry";
+import c from "../lib/colors.js";
+import { getPaths } from "../lib/index.js";
+import * as project from "../lib/project.js";
+function isInGitRepository() {
+  try {
+    execa.commandSync("git rev-parse --is-inside-work-tree");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInMercurialRepository() {
+  try {
+    execa.commandSync("hg --cwd . root");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isJestConfigFile(sides) {
+  for (let side of sides) {
+    try {
+      if (sides.includes(side)) {
+        const jestConfigExists = fs.existsSync(path.join(side, "jest.config.js")) || fs.existsSync(path.join(side, "jest.config.ts"));
+        if (!jestConfigExists) {
+          console.error(
+            c.error(
+              `
+Error: Missing Jest config file ${side}/jest.config.js
+To add this file, run \`npx @cedarjs/codemods update-jest-config\`
+`
+            )
+          );
+          throw new Error(`Error: Jest config file not found in ${side} side`);
+        }
+      }
+    } catch (e) {
+      errorTelemetry(process.argv, e.message);
+      process.exit(e?.exitCode || 1);
+    }
+  }
+}
+const handler = async ({
+  filter: filterParams = [],
+  watch = true,
+  collectCoverage = false,
+  dbPush = true,
+  ...others
+}) => {
+  recordTelemetryAttributes({
+    command: "test",
+    watch,
+    collectCoverage,
+    dbPush
+  });
+  const rwjsPaths = getPaths();
+  const forwardJestFlags = Object.keys(others).flatMap((flagName) => {
+    if ([
+      "collect-coverage",
+      "db-push",
+      "loadEnvFiles",
+      "watch",
+      "$0",
+      "_"
+    ].includes(flagName)) {
+      return [];
+    } else {
+      const flag = flagName.length > 1 ? `--${flagName}` : `-${flagName}`;
+      const flagValue = others[flagName];
+      if (Array.isArray(flagValue)) {
+        return flagValue.flatMap((val) => [flag, val]);
+      } else {
+        return [flag, flagValue];
+      }
+    }
+  });
+  const sides = filterParams.filter(
+    (filterString) => project.sides().includes(filterString)
+  );
+  const jestFilterArgs = [
+    ...filterParams.filter(
+      (filterString) => !project.sides().includes(filterString)
+    )
+  ];
+  const jestArgs = [
+    ...jestFilterArgs,
+    ...forwardJestFlags,
+    collectCoverage ? "--collectCoverage" : null,
+    "--passWithNoTests"
+  ].filter((flagOrValue) => flagOrValue !== null);
+  if (watch && !process.env.CI && !collectCoverage) {
+    const hasSourceControl = isInGitRepository() || isInMercurialRepository();
+    jestArgs.push(hasSourceControl ? "--watch" : "--watchAll");
+  }
+  if (!sides.length) {
+    project.sides().forEach((side) => sides.push(side));
+  }
+  if (sides.length > 0) {
+    jestArgs.push("--projects", ...sides);
+  }
+  isJestConfigFile(sides);
+  try {
+    const cacheDirDb = `file:${ensurePosixPath(
+      rwjsPaths.generated.base
+    )}/test.db`;
+    const DATABASE_URL = process.env.TEST_DATABASE_URL || cacheDirDb;
+    if (sides.includes("api") && !dbPush) {
+      process.env.SKIP_DB_PUSH = "1";
+    }
+    const runCommand = async () => {
+      await execa("yarn jest", jestArgs, {
+        cwd: rwjsPaths.base,
+        shell: true,
+        stdio: "inherit",
+        env: { DATABASE_URL }
+      });
+    };
+    if (watch) {
+      await runCommand();
+    } else {
+      await timedTelemetry(process.argv, { type: "test" }, async () => {
+        await runCommand();
+      });
+    }
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  handler
+};

package/dist/commands/ts-to-js.js

@@ -0,0 +1,20 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import {
+  convertTsProjectToJs,
+  convertTsScriptsToJs
+} from "@cedarjs/internal/dist/ts2js";
+import { getPaths } from "@cedarjs/project-config";
+const command = "ts-to-js";
+const description = "[DEPRECATED]\nConvert a TypeScript project to JavaScript";
+const handler = () => {
+  recordTelemetryAttributes({
+    command: "ts-to-js"
+  });
+  convertTsProjectToJs(getPaths().base);
+  convertTsScriptsToJs(getPaths().base);
+};
+export {
+  command,
+  description,
+  handler
+};

package/dist/commands/type-check.js

@@ -0,0 +1,41 @@
+import terminalLink from "terminal-link";
+import { sides } from "../lib/project.js";
+const command = "type-check [sides..]";
+const aliases = ["tsc", "tc"];
+const description = "Run a TypeScript compiler check on your project";
+const builder = (yargs) => {
+  yargs.strict(false).positional("sides", {
+    default: sides(),
+    description: "Which side(s) to run a typecheck on",
+    type: "array"
+  }).option("prisma", {
+    type: "boolean",
+    default: true,
+    description: "Generate the Prisma client"
+  }).option("generate", {
+    type: "boolean",
+    default: true,
+    description: "Regenerate types within the project"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more",
+    type: "boolean"
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#type-check"
+    )}`
+  );
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./type-checkHandler.js");
+  return handler2(options);
+};
+export {
+  aliases,
+  builder,
+  command,
+  description,
+  handler
+};