@cedarjs/cli 0.0.4

package/dist/lib/project.js

@@ -0,0 +1,30 @@
+import path from "path";
+import fs from "fs-extra";
+import { getPaths } from "./index.js";
+const isTypeScriptProject = () => {
+  const paths = getPaths();
+  return fs.existsSync(path.join(paths.web.base, "tsconfig.json")) || fs.existsSync(path.join(paths.api.base, "tsconfig.json"));
+};
+const sides = () => {
+  const paths = getPaths();
+  let sides2 = [];
+  if (fs.existsSync(path.join(paths.web.base, "package.json"))) {
+    sides2 = [...sides2, "web"];
+  }
+  if (fs.existsSync(path.join(paths.api.base, "package.json"))) {
+    sides2 = [...sides2, "api"];
+  }
+  return sides2;
+};
+const serverFileExists = () => {
+  const serverFilePath = path.join(
+    getPaths().api.src,
+    `server.${isTypeScriptProject() ? "ts" : "js"}`
+  );
+  return fs.existsSync(serverFilePath);
+};
+export {
+  isTypeScriptProject,
+  serverFileExists,
+  sides
+};

package/dist/lib/rollback.js

@@ -0,0 +1,72 @@
+import path from "path";
+import fs from "fs-extra";
+let rollback = [];
+function addFunctionToRollback(func, atEnd = false) {
+  const step = { type: "func", func };
+  if (atEnd) {
+    rollback.unshift(step);
+  } else {
+    rollback.push(step);
+  }
+}
+function addFileToRollback(path2, atEnd = false) {
+  const step = {
+    type: "file",
+    path: path2,
+    content: fs.existsSync(path2) ? fs.readFileSync(path2) : null
+  };
+  if (atEnd) {
+    rollback.unshift(step);
+  } else {
+    rollback.push(step);
+  }
+}
+async function executeRollback(_ = null, task = null) {
+  if (task) {
+    task.title = "Reverting generator actions...";
+  }
+  while (rollback.length > 0) {
+    const step = rollback.pop();
+    switch (step.type) {
+      case "func":
+        await step.func();
+        break;
+      case "file":
+        if (step.content === null) {
+          fs.unlinkSync(step.path);
+          let parent = path.dirname(step.path);
+          if (parent !== "." && fs.readdirSync(parent).length === 0) {
+            fs.rmdirSync(parent);
+          }
+          parent = path.dirname(parent);
+          if (parent !== "." && fs.readdirSync(parent).length === 0) {
+            fs.rmdirSync(parent);
+          }
+        } else {
+          fs.writeFileSync(step.path, step.content);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  if (task) {
+    task.title = `Reverted because: ${task.task.message.error}`;
+  }
+}
+function resetRollback() {
+  rollback.length = 0;
+}
+function prepareForRollback(tasks) {
+  resetRollback();
+  tasks.tasks?.forEach((task) => {
+    task.task.rollback = executeRollback;
+  });
+}
+export {
+  addFileToRollback,
+  addFunctionToRollback,
+  executeRollback,
+  prepareForRollback,
+  resetRollback
+};

package/dist/lib/runTransform.js

@@ -0,0 +1,66 @@
+import * as jscodeshift from "jscodeshift/src/Runner.js";
+const defaultJscodeshiftOpts = {
+  // 0, 1 or 2
+  verbose: 0,
+  dry: false,
+  // Doesn't do anything when running programmatically
+  print: false,
+  babel: true,
+  extensions: "js,ts,jsx,tsx",
+  ignorePattern: "**/node_modules/**",
+  ignoreConfig: [],
+  runInBand: false,
+  silent: true,
+  parser: "babel",
+  parserConfig: {},
+  // `silent` has to be `false` for this option to do anything
+  failOnError: false,
+  stdin: false
+};
+const runTransform = async ({
+  transformPath,
+  targetPaths,
+  parser = "tsx",
+  options = {}
+}) => {
+  if (process.env.NODE_ENV === "test" && process.env.RWJS_CWD) {
+    process.chdir(process.env.RWJS_CWD);
+  }
+  const { output, stdoutWrite } = patchStdoutWrite();
+  const result = await jscodeshift.run(transformPath, targetPaths, {
+    ...defaultJscodeshiftOpts,
+    parser,
+    babel: process.env.NODE_ENV === "test",
+    ...options
+    // Putting options here lets users override all the defaults.
+  });
+  restoreStdoutWrite(stdoutWrite);
+  let error;
+  if (result.error) {
+    error = output.value.split("\n").find((line) => line.startsWith("Error: "))?.slice("Error: ".length);
+  }
+  return {
+    ...result,
+    error,
+    output: output.value
+  };
+};
+function patchStdoutWrite() {
+  const stdoutWrite = process.stdout.write;
+  const output = {
+    value: ""
+  };
+  process.stdout.write = (chunk) => {
+    if (typeof chunk === "string") {
+      output.value += chunk;
+    }
+    return true;
+  };
+  return { output, stdoutWrite };
+}
+function restoreStdoutWrite(stdoutWrite) {
+  process.stdout.write = stdoutWrite;
+}
+export {
+  runTransform
+};

package/dist/lib/rwPluralize.js

@@ -0,0 +1,56 @@
+import plurals from "pluralize";
+const mappings = {
+  toSingular: {},
+  toPlural: {}
+};
+function lastWord(str) {
+  const capitals = str.match(/[A-Z]/g);
+  const lastIndex = str.lastIndexOf(capitals?.slice(-1)[0]);
+  return lastIndex >= 0 ? str.slice(lastIndex) : str;
+}
+function pluralize(word) {
+  if (mappings.toPlural[word]) {
+    return mappings.toPlural[word];
+  }
+  const singular = lastWord(word);
+  const base = word.slice(0, word.length - singular.length);
+  if (mappings.toPlural[singular]) {
+    return base + mappings.toPlural[singular];
+  }
+  return base + plurals.plural(singular);
+}
+function singularize(word) {
+  if (mappings.toSingular[word]) {
+    return mappings.toSingular[word];
+  }
+  const plural = lastWord(word);
+  const base = word.slice(0, word.length - plural.length);
+  if (mappings.toSingular[plural]) {
+    return base + mappings.toSingular[plural];
+  }
+  return base + plurals.singular(plural);
+}
+function isPlural(word) {
+  return plurals.isPlural(lastWord(word));
+}
+function isSingular(word) {
+  return plurals.isSingular(lastWord(word));
+}
+function addSingularPlural(singular, plural) {
+  const existingPlural = Object.keys(mappings.toSingular).find(
+    (key) => mappings.toSingular[key] === singular
+  );
+  delete mappings.toSingular[existingPlural];
+  delete mappings.toPlural[existingPlural];
+  mappings.toPlural[singular] = plural;
+  mappings.toPlural[plural] = plural;
+  mappings.toSingular[plural] = singular;
+  mappings.toSingular[singular] = singular;
+}
+export {
+  addSingularPlural,
+  isPlural,
+  isSingular,
+  pluralize,
+  singularize
+};

package/dist/lib/schemaHelpers.js

@@ -0,0 +1,95 @@
+import prismaInternals from "@prisma/internals";
+import { ensureUniquePlural } from "./pluralHelpers.js";
+import { singularize, isPlural } from "./rwPluralize.js";
+import { getPaths } from "./index.js";
+const { getConfig, getDMMF, getSchema: getSchemaPrisma } = prismaInternals;
+const schemaMemo = {};
+const getExistingModelName = async (name) => {
+  if (!name) {
+    return void 0;
+  }
+  const modelName = name.replace(/[_-]/g, "").toLowerCase();
+  for (let model of Object.values(schemaMemo)) {
+    if (model.name.toLowerCase() === modelName) {
+      return model.name;
+    }
+  }
+  const schema = (await getSchemaDefinitions()).datamodel;
+  for (let model of schema.models) {
+    if (model.name.toLowerCase() === modelName) {
+      return model.name;
+    }
+  }
+  return void 0;
+};
+const getSchema = async (name) => {
+  const schema = (await getSchemaDefinitions()).datamodel;
+  if (!name) {
+    return schema;
+  }
+  const modelName = await getExistingModelName(name);
+  if (!modelName) {
+    throw new Error(
+      `No schema definition found for \`${name}\` in schema.prisma file`
+    );
+  }
+  if (schemaMemo[modelName]) {
+    return schemaMemo[modelName];
+  }
+  const model = schema.models.find((model2) => model2.name === modelName);
+  if (!model) {
+    return void 0;
+  }
+  model.fields.forEach((field) => {
+    const fieldEnum = schema.enums.find((e) => field.type === e.name);
+    if (fieldEnum) {
+      field.enumValues = fieldEnum.values;
+    }
+  });
+  schemaMemo[modelName] = model;
+  return model;
+};
+const getEnum = async (name) => {
+  const schema = await getSchemaDefinitions();
+  if (!name) {
+    return schema.metadata.datamodel.enums;
+  }
+  const model = schema.datamodel.enums.find((model2) => model2.name === name);
+  if (!model) {
+    throw new Error(
+      `No enum schema definition found for \`${name}\` in schema.prisma file`
+    );
+  }
+  return model;
+};
+const getDataModel = (path = getPaths().api.dbSchema) => {
+  return getSchemaPrisma(path);
+};
+const getSchemaDefinitions = () => {
+  return getDMMF({ datamodel: getDataModel() });
+};
+const getSchemaConfig = () => getConfig({
+  datamodel: getDataModel()
+});
+async function verifyModelName(options) {
+  const modelName = await getExistingModelName(options.name) || await getExistingModelName(singularize(options.name));
+  if (modelName === void 0) {
+    throw new Error(
+      `"${options.name}" model not found, check if it exists in "./api/db/schema.prisma"`
+    );
+  }
+  await ensureUniquePlural({
+    model: modelName,
+    isDestroyer: options.isDestroyer,
+    forcePrompt: isPlural(modelName)
+  });
+  return { ...options, name: modelName };
+}
+export {
+  getDataModel,
+  getEnum,
+  getSchema,
+  getSchemaConfig,
+  getSchemaDefinitions,
+  verifyModelName
+};

package/dist/lib/templates/storybook.preview.tsx.template

@@ -0,0 +1,19 @@
+import * as React from 'react'
+
+import type { GlobalTypes } from '@storybook/csf'
+import type { Preview, StoryContext, StoryFn } from '@storybook/react'
+
+/** @see {@link https://storybook.js.org/docs/7/essentials/toolbars-and-globals#global-types-and-the-toolbar-annotation | Global types and the toolbar annotation}  */
+export const globalTypes: GlobalTypes = {}
+
+/**
+ * An example, no-op storybook decorator. Use a function like this to create decorators.
+ * @see {@link https://storybook.js.org/docs/7/essentials/toolbars-and-globals#create-a-decorator | Create a decorator}
+ */
+const _exampleDecorator = (StoryFn: StoryFn, _context: StoryContext) => (
+  <StoryFn />
+)
+
+const preview: Preview = {
+  decorators: [],
+}

package/dist/lib/test.js

@@ -0,0 +1,106 @@
+import path from "path";
+import fs from "fs-extra";
+import { vi } from "vitest";
+import "./mockTelemetry.js";
+vi.mock("@cedarjs/internal/dist/generate/generate", () => {
+  return {
+    generate: () => {
+      return { errors: [] };
+    }
+  };
+});
+vi.mock("@cedarjs/project-config", async (importOriginal) => {
+  const path2 = await import("path");
+  const originalProjectConfig = await importOriginal();
+  return {
+    ...originalProjectConfig,
+    getPaths: () => {
+      const BASE_PATH = "/path/to/project";
+      return {
+        base: BASE_PATH,
+        api: {
+          dataMigrations: path2.join(BASE_PATH, "./api/prisma/dataMigrations"),
+          db: path2.join(globalThis.__dirname, "fixtures"),
+          // this folder
+          dbSchema: path2.join(
+            globalThis.__dirname,
+            "fixtures",
+            "schema.prisma"
+          ),
+          // this folder
+          generators: path2.join(BASE_PATH, "./api/generators"),
+          src: path2.join(BASE_PATH, "./api/src"),
+          jobs: path2.join(BASE_PATH, "./api/src/jobs"),
+          services: path2.join(BASE_PATH, "./api/src/services"),
+          directives: path2.join(BASE_PATH, "./api/src/directives"),
+          graphql: path2.join(BASE_PATH, "./api/src/graphql"),
+          functions: path2.join(BASE_PATH, "./api/src/functions")
+        },
+        web: {
+          base: path2.join(BASE_PATH, "./web"),
+          config: path2.join(BASE_PATH, "./web/config"),
+          src: path2.join(BASE_PATH, "./web/src"),
+          generators: path2.join(BASE_PATH, "./web/generators"),
+          routes: path2.join(BASE_PATH, "web/src/Routes.js"),
+          components: path2.join(BASE_PATH, "/web/src/components"),
+          layouts: path2.join(BASE_PATH, "/web/src/layouts"),
+          pages: path2.join(BASE_PATH, "/web/src/pages"),
+          app: path2.join(BASE_PATH, "/web/src/App.js")
+        },
+        scripts: path2.join(BASE_PATH, "scripts"),
+        generated: {
+          base: path2.join(BASE_PATH, ".redwood"),
+          schema: path2.join(BASE_PATH, ".redwood/schema.graphql"),
+          types: {
+            includes: path2.join(BASE_PATH, ".redwood/types/includes"),
+            mirror: path2.join(BASE_PATH, ".redwood/types/mirror")
+          }
+        }
+      };
+    }
+  };
+});
+vi.mock("@cedarjs/cli-helpers", async (importOriginal) => {
+  const originalCliHelpers = await importOriginal();
+  return {
+    ...originalCliHelpers,
+    isTypeScriptProject: () => false
+  };
+});
+vi.mock("./project", () => ({
+  isTypeScriptProject: () => false,
+  sides: () => ["web", "api"]
+}));
+globalThis.__prettierPath = path.resolve(
+  import.meta.dirname,
+  "./__tests__/fixtures/prettier.config.js"
+);
+vi.spyOn(Math, "random").mockReturnValue(0.123456789);
+const generatorsRootPath = path.join(
+  import.meta.dirname,
+  "..",
+  "commands",
+  "generate"
+);
+const loadGeneratorFixture = (generator, name) => {
+  return loadFixture(
+    path.join(
+      import.meta.dirname,
+      "..",
+      "commands",
+      "generate",
+      generator,
+      "__tests__",
+      "fixtures",
+      name
+    )
+  );
+};
+const loadFixture = (filepath) => {
+  return fs.readFileSync(filepath).toString();
+};
+export {
+  generatorsRootPath,
+  loadFixture,
+  loadGeneratorFixture
+};

package/dist/lib/updateCheck.js

@@ -0,0 +1,202 @@
+import path from "path";
+import boxen from "boxen";
+import chalk from "chalk";
+import fs from "fs-extra";
+import latestVersion from "latest-version";
+import semver from "semver";
+import { getConfig } from "@cedarjs/project-config";
+import { spawnBackgroundProcess } from "./background.js";
+import { isLockSet, setLock, unsetLock } from "./locking.js";
+import { getPaths } from "./index.js";
+const CHECK_PERIOD = 24 * 60 * 6e4;
+const SHOW_PERIOD = 24 * 60 * 6e4;
+const DEFAULT_DATETIME_MS = 9466848e5;
+const CHECK_LOCK_IDENTIFIER = "UPDATE_CHECK";
+const SHOW_LOCK_IDENTIFIER = "UPDATE_CHECK_SHOW";
+const EXCLUDED_COMMANDS = ["upgrade", "ts-to-js"];
+let persistenceDirectory;
+function getPersistenceDirectory() {
+  if (persistenceDirectory) {
+    return persistenceDirectory;
+  }
+  persistenceDirectory = path.join(getPaths().generated.base, "updateCheck");
+  return persistenceDirectory;
+}
+async function check() {
+  try {
+    console.time("Update Check");
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(getPaths().base, "package.json"))
+    );
+    let localVersion = packageJson.devDependencies["@cedarjs/core"];
+    while (!/\d/.test(localVersion.charAt(0))) {
+      localVersion = localVersion.substring(1);
+    }
+    console.log(`Detected the current version of Cedar: '${localVersion}'`);
+    const remoteVersions = /* @__PURE__ */ new Map();
+    for (const tag of getConfig().notifications.versionUpdates) {
+      console.log(`Checking for new versions for npm tag: '${tag}'`);
+      try {
+        remoteVersions.set(
+          tag,
+          await latestVersion("@cedarjs/core", { version: tag })
+        );
+      } catch (error) {
+        console.error(`Couldn't find a version for tag: '${tag}'`);
+        console.error(error);
+      }
+    }
+    console.log(`Detected the latest versions of Cedar as:`);
+    console.log(JSON.stringify([...remoteVersions.entries()], void 0, 2));
+    console.log("Saving updated version information for future checks...");
+    updateUpdateDataFile({
+      localVersion,
+      remoteVersions,
+      checkedAt: (/* @__PURE__ */ new Date()).getTime()
+    });
+  } finally {
+    unsetLock(CHECK_LOCK_IDENTIFIER);
+    console.timeEnd("Update Check");
+  }
+}
+function isEnabled() {
+  return getConfig().notifications.versionUpdates.length > 0;
+}
+function shouldCheck() {
+  if (isLockSet(CHECK_LOCK_IDENTIFIER)) {
+    return false;
+  }
+  const data = readUpdateDataFile();
+  return data.checkedAt < (/* @__PURE__ */ new Date()).getTime() - CHECK_PERIOD;
+}
+function shouldShow() {
+  if (isLockSet(SHOW_LOCK_IDENTIFIER)) {
+    return false;
+  }
+  const data = readUpdateDataFile();
+  let newerVersion = false;
+  data.remoteVersions.forEach((version) => {
+    newerVersion ||= semver.gt(version, data.localVersion);
+  });
+  return data.shownAt < (/* @__PURE__ */ new Date()).getTime() - SHOW_PERIOD && newerVersion;
+}
+function showUpdateMessage() {
+  console.log(getUpdateMessage());
+  updateUpdateDataFile({ shownAt: (/* @__PURE__ */ new Date()).getTime() });
+}
+function getUpdateMessage() {
+  const data = readUpdateDataFile();
+  const localTag = extractTagFromVersion(data.localVersion) || "latest";
+  let updateCount = 0;
+  let message = " New updates to Cedar are available via `yarn rw upgrade#REPLACEME#` ";
+  data.remoteVersions.forEach((version, tag) => {
+    if (semver.gt(version, data.localVersion)) {
+      updateCount += 1;
+      if (tag === localTag) {
+        message += `
+
+ \u2756  ${chalk.underline(chalk.bold(tag))}:
+     v${data.localVersion} -> v${version} `;
+      } else {
+        message += `
+
+ \u2756  ${tag}:
+     v${version} `;
+      }
+    }
+  });
+  message += "\n\n See release notes at: https://github.com/cedarjs/cedar/releases ";
+  message = message.replace("#REPLACEME#", updateCount > 1 ? " -t [tag]" : "");
+  return boxen(message, {
+    padding: 0,
+    margin: 1,
+    title: `Cedar Update${updateCount > 1 ? "s " : " "}available \u{1F389}`,
+    borderColor: "#0b8379",
+    // The RedwoodJS colour
+    borderStyle: "round"
+  });
+}
+function readUpdateDataFile() {
+  try {
+    if (!fs.existsSync(getPersistenceDirectory())) {
+      fs.mkdirSync(getPersistenceDirectory(), { recursive: true });
+    }
+    const persistedData = JSON.parse(
+      fs.readFileSync(path.join(getPersistenceDirectory(), "data.json"))
+    );
+    persistedData.remoteVersions = new Map(
+      Object.entries(persistedData.remoteVersions)
+    );
+    return persistedData;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        localVersion: "0.0.0",
+        remoteVersions: /* @__PURE__ */ new Map(),
+        checkedAt: DEFAULT_DATETIME_MS,
+        shownAt: DEFAULT_DATETIME_MS
+      };
+    }
+    throw error;
+  }
+}
+function updateUpdateDataFile({
+  localVersion,
+  remoteVersions,
+  checkedAt,
+  shownAt
+} = {}) {
+  const existingData = readUpdateDataFile();
+  const updatedData = {
+    localVersion: localVersion ?? existingData.localVersion,
+    remoteVersions: Object.fromEntries(
+      remoteVersions ?? existingData.remoteVersions
+    ),
+    checkedAt: checkedAt ?? existingData.checkedAt,
+    shownAt: shownAt ?? existingData.shownAt
+  };
+  fs.writeFileSync(
+    path.join(getPersistenceDirectory(), "data.json"),
+    JSON.stringify(updatedData, null, 2)
+  );
+}
+function extractTagFromVersion(version) {
+  const tagIndex = version.indexOf("-");
+  if (tagIndex === -1) {
+    return "";
+  }
+  const tag = version.substring(tagIndex + 1).trim();
+  return tag.includes(".") ? tag.split(".")[0] : tag;
+}
+function updateCheckMiddleware(argv) {
+  if (EXCLUDED_COMMANDS.includes(argv._[0])) {
+    return;
+  }
+  if (shouldShow()) {
+    setLock(SHOW_LOCK_IDENTIFIER);
+    process.on("exit", () => {
+      showUpdateMessage();
+      unsetLock(SHOW_LOCK_IDENTIFIER);
+    });
+  }
+  if (shouldCheck()) {
+    setLock(CHECK_LOCK_IDENTIFIER);
+    spawnBackgroundProcess("updateCheck", "yarn", [
+      "node",
+      path.join(import.meta.dirname, "updateCheckExecute.js")
+    ]);
+  }
+}
+export {
+  CHECK_LOCK_IDENTIFIER,
+  DEFAULT_DATETIME_MS,
+  EXCLUDED_COMMANDS,
+  SHOW_LOCK_IDENTIFIER,
+  check,
+  isEnabled,
+  readUpdateDataFile,
+  shouldCheck,
+  shouldShow,
+  showUpdateMessage,
+  updateCheckMiddleware
+};

package/dist/lib/updateCheckExecute.js

@@ -0,0 +1,2 @@
+import { check } from "./updateCheck.js";
+check();

package/dist/middleware/checkNodeVersion.js

@@ -0,0 +1,23 @@
+import semver from "semver";
+import c from "../lib/colors.js";
+function checkNodeVersion() {
+  const checks = { ok: true };
+  const pVersion = process.version;
+  const pVersionC = semver.clean(pVersion);
+  const LOWER_BOUND = "v20.0.0";
+  const LOWER_BOUND_C = semver.clean(LOWER_BOUND);
+  if (semver.gt(pVersionC, LOWER_BOUND_C)) {
+    return checks;
+  }
+  checks.ok = false;
+  checks.message = [
+    `Your Node.js version is ${c.warning(
+      pVersion
+    )}, but Redwood requires ${c.important(`>=${LOWER_BOUND}`)}.`,
+    "Upgrade your Node.js version using `nvm` or a similar tool. See https://redwoodjs.com/docs/how-to/using-nvm."
+  ].join("\n");
+  return checks;
+}
+export {
+  checkNodeVersion
+};

package/dist/middleware/detectProjectRxVersion.js

@@ -0,0 +1,12 @@
+import { getInstalledCedarVersion } from "../lib/index.js";
+async function detectRxVersion(argv) {
+  if (!argv.rwVersion) {
+    return {
+      rwVersion: await getInstalledCedarVersion()
+    };
+  }
+  return {};
+}
+export {
+  detectRxVersion as default
+};