@cedarjs/cli 0.0.4

package/dist/lib/merge/index.js

@@ -0,0 +1,163 @@
+import { parse, traverse } from "@babel/core";
+import generate from "@babel/generator";
+import { VISITOR_KEYS } from "@babel/types";
+import { partition, forEachRight } from "lodash";
+import prettier from "prettier";
+import { forEachFunctionOn, nodeIs } from "./algorithms.js";
+import { semanticIdentity } from "./semanticIdentity.js";
+import { isOpaque } from "./strategy.js";
+function extractProperty(property, fromObject) {
+  if (property === void 0) {
+    return void 0;
+  }
+  const tmp = fromObject[property];
+  delete fromObject[property];
+  return tmp;
+}
+function getProgramPath(ast) {
+  let programPath;
+  traverse(ast, {
+    Program(path) {
+      programPath = path;
+      return;
+    }
+  });
+  if (programPath === void 0) {
+    throw new Error("Unable to find Program node in AST");
+  }
+  return programPath;
+}
+function skipChildren(path) {
+  for (const key of VISITOR_KEYS[path.type]) {
+    path.skipKey(key);
+  }
+}
+function makeProxy(path) {
+  return new Proxy(path, {
+    get(target, property) {
+      if (property === "path") {
+        return target;
+      } else {
+        return target.node[property];
+      }
+    },
+    set(target, property, value) {
+      if (property === "path") {
+        throw new Error("You can't set a path on a proxy!");
+      } else {
+        target.node[property] = value;
+        return true;
+      }
+    },
+    has(target, property) {
+      return property in target.node;
+    }
+  });
+}
+function expressionUses(exp, ...ids) {
+  let result = false;
+  exp.traverse({
+    Identifier(path) {
+      if (!path.parentPath.isNodeType("VariableDeclarator") && ids.includes(path.node.name)) {
+        result = true;
+        return;
+      }
+    }
+  });
+  return result;
+}
+function insertBeforeFirstUsage(expression, program) {
+  const body = program.get("body");
+  const pos = body.findIndex(
+    (exp) => expressionUses(exp, ...Object.keys(expression.getBindingIdentifiers()))
+  );
+  return pos !== -1 ? body[pos].insertBefore(expression.node) : program.pushContainer("body", expression.node);
+}
+function insertAfterLastImport(expression, program) {
+  const body = program.get("body");
+  return body[body.findLastIndex((bodyExpr) => bodyExpr.isNodeType("ImportDeclaration"))].insertAfter(expression.node);
+}
+function prune(path) {
+  switch (path.parentPath.type) {
+    // If pruning 'path' would yield an ill-formed parent (e.g, '{foo:}' or 'const x;'), prune it.
+    case "ObjectProperty":
+    case "VariableDeclarator":
+      return path.parentPath.remove();
+    default:
+      console.log(`Warning: default prune strategy for ${path.parentPath.type}`);
+    // eslint-disable-next-line no-fallthrough
+    case "Program":
+    case "ArrayExpression":
+      return path.remove();
+  }
+}
+function stripTrailingCommentsStrategy() {
+  return {
+    enter(path) {
+      path.node.trailingComments = [];
+    }
+  };
+}
+function mergeAST(baseAST, extAST, strategy = {}) {
+  const identity = extractProperty("identity", strategy) ?? semanticIdentity;
+  const identities = {};
+  const baseVisitor = { ...stripTrailingCommentsStrategy() };
+  const extVisitor = { ...stripTrailingCommentsStrategy() };
+  forEachFunctionOn(strategy, (typename, strat) => {
+    extVisitor[typename] = {
+      enter(path) {
+        const id = identity(path);
+        id && (identities[id] ||= []).push(path);
+      }
+    };
+    baseVisitor[typename] = {
+      enter(path) {
+        if (isOpaque(strat)) {
+          skipChildren(path);
+        }
+      },
+      exit(path) {
+        const exts = extractProperty(identity(path), identities);
+        if (exts) {
+          const proxyPath = makeProxy(path);
+          exts.map(makeProxy).forEach((ext) => {
+            strat(proxyPath, ext);
+            prune(ext.path);
+          });
+        }
+      }
+    };
+  });
+  traverse(extAST, extVisitor);
+  traverse(baseAST, baseVisitor);
+  const baseProgram = getProgramPath(baseAST);
+  const [imports, others] = partition(
+    getProgramPath(extAST).get("body"),
+    nodeIs("ImportDeclaration")
+  );
+  imports.forEach((exp) => insertAfterLastImport(exp, baseProgram));
+  forEachRight(others, (exp) => insertBeforeFirstUsage(exp, baseProgram));
+}
+async function merge(base, extension, strategy) {
+  function parseReact(code2) {
+    return parse(code2, {
+      filename: "merged.tsx",
+      // required to prevent babel error. The .tsx is relevant
+      presets: ["@babel/preset-typescript"]
+    });
+  }
+  const baseAST = parseReact(base);
+  const extAST = parseReact(extension);
+  mergeAST(baseAST, extAST, strategy);
+  const { code } = generate(baseAST);
+  return process.env.VITEST_POOL_ID ? await prettier.format(code, {
+    parser: "babel-ts",
+    bracketSpacing: true,
+    tabWidth: 2,
+    semi: false,
+    singleQuote: true
+  }) : code;
+}
+export {
+  merge
+};

package/dist/lib/merge/semanticIdentity.js

@@ -0,0 +1,18 @@
+function semanticIdentity(path) {
+  const identity = {
+    get(path2) {
+      return path2.type in this ? this[path2.type](path2) : [path2.type];
+    },
+    ObjectProperty: (path2) => [path2.node.key.name],
+    VariableDeclarator: (path2) => [path2.node.id.name],
+    ImportDeclaration: (path2) => [
+      "ImportDeclaration",
+      "source",
+      path2.node.source.value
+    ]
+  };
+  return path.getAncestry().reduce((acc, i) => [...identity.get(i), ...acc], []).join(".");
+}
+export {
+  semanticIdentity
+};

package/dist/lib/merge/strategy.js

@@ -0,0 +1,136 @@
+import * as t from "@babel/types";
+import _ from "lodash";
+import { nodeIs, sieve } from "./algorithms.js";
+const OPAQUE_UID_TAG = "RW_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
+function requireSameType(base, ext) {
+  if (base.path.type !== ext.path.type) {
+    throw new Error(
+      "Attempting to merge nodes with different types. This is not yet supported."
+    );
+  }
+}
+function requireStrategyExists(base, _ext, strategy, strategyName) {
+  if (!(base.path.type in strategy)) {
+    throw new Error(
+      `Attempting to ${strategyName} nodes that do not have an ${strategyName} strategy.`
+    );
+  }
+}
+const strictEquality = (lhs, rhs) => lhs === rhs;
+const byName = (lhs, rhs) => lhs.name === rhs.name;
+const byKeyName = (lhs, rhs) => lhs.key.name === rhs.key.name;
+const byValue = (lhs, rhs) => lhs.value === rhs.value;
+function defaultEquality(baseContainer, extContainer) {
+  const sample = baseContainer.length && baseContainer[0] || extContainer.length && extContainer[0];
+  const defaults = {
+    BigIntLiteral: byValue,
+    BooleanLiteral: byValue,
+    Identifier: byName,
+    NumericLiteral: byValue,
+    ObjectProperty: byKeyName,
+    StringLiteral: byValue
+  };
+  return sample && sample.type in defaults ? defaults[sample.type] : strictEquality;
+}
+function opaquely(strategy) {
+  strategy[OPAQUE_UID_TAG] = true;
+  return strategy;
+}
+function isOpaque(strategy) {
+  return strategy[OPAQUE_UID_TAG] === true;
+}
+const keepBase = opaquely(() => {
+});
+const keepBoth = opaquely((base, ext) => {
+  base.path.insertAfter(ext.path.node);
+});
+const keepExtension = opaquely((base, ext) => {
+  base.path.replaceWith(ext.path);
+});
+const keepBothStatementParents = opaquely((base, ext) => {
+  base.path.getStatementParent().insertAfter(ext.path.getStatementParent().node);
+});
+const interleaveStrategy = {
+  ImportDeclaration(baseImport, extImport) {
+    const baseSpecs = baseImport.specifiers;
+    const extSpecs = extImport.specifiers;
+    const importSpecifierEquality = (lhs, rhs) => lhs.type === rhs.type && lhs.imported?.name === rhs.imported?.name && lhs.local?.name == rhs.local?.name;
+    const uniqueSpecifiersOfType = (type) => _.uniqWith(
+      [...baseSpecs, ...extSpecs].filter(nodeIs(type)),
+      importSpecifierEquality
+    );
+    if (!baseSpecs.length !== !extSpecs.length) {
+      return keepBothStatementParents(baseImport, extImport);
+    }
+    const defaultPosition = (specs) => specs.some(nodeIs("ImportDefaultSpecifier")) ? -1 : 0;
+    const namespacePosition = (specs) => specs.some(nodeIs("ImportNamespaceSpecifier")) || specs.some(nodeIs("ImportSpecifier")) ? -1 : specs.length;
+    const importPosition = (specs) => specs.some(nodeIs("ImportNamespaceIdentifier")) ? -1 : specs.length;
+    const [firstSpecifierList, ...rest] = sieve(
+      [uniqueSpecifiersOfType("ImportDefaultSpecifier"), defaultPosition],
+      [uniqueSpecifiersOfType("ImportNamespaceSpecifier"), namespacePosition],
+      [uniqueSpecifiersOfType("ImportSpecifier"), importPosition]
+    );
+    baseImport.specifiers = firstSpecifierList;
+    if (rest.length) {
+      baseImport.path.insertAfter(
+        rest.map((specs) => t.importDeclaration(specs, baseImport.source))
+      );
+    }
+  }
+};
+function interleave(base, ext) {
+  requireSameType(base, ext);
+  requireStrategyExists(base, ext, interleaveStrategy, "interleave");
+  return interleaveStrategy[base.path.type](base, ext);
+}
+const concatStrategy = {
+  ArrayExpression(base, ext) {
+    base.elements = [...base.elements, ...ext.elements];
+  },
+  ObjectExpression(base, ext) {
+    base.properties = [...base.properties, ...ext.properties];
+  },
+  StringLiteral(base, ext) {
+    base.value = base.value.concat(ext.value);
+  }
+};
+function concat(base, ext) {
+  requireSameType(base, ext);
+  requireStrategyExists(base, ext, concatStrategy, "concat");
+  return concatStrategy[base.path.type](base, ext);
+}
+const concatUniqueStrategy = {
+  ArrayExpression(base, ext, eq) {
+    eq ||= defaultEquality(base.elements, ext.elements);
+    base.elements = _.uniqWith([...base.elements, ...ext.elements], eq);
+  },
+  ObjectExpression(base, ext, eq) {
+    eq ||= defaultEquality(base.properties, ext.properties);
+    base.properties = _.uniqWith([...base.properties, ...ext.properties], eq);
+  }
+};
+function concatUnique(baseOrEq, ext) {
+  if (arguments.length === 1) {
+    return (base, ext2) => {
+      requireSameType(base, ext2);
+      requireStrategyExists(base, ext2, concatUniqueStrategy, "concatUnique");
+      return concatUniqueStrategy[base.path.type](base, ext2, baseOrEq);
+    };
+  }
+  if (arguments.length === 2) {
+    requireSameType(baseOrEq, ext);
+    requireStrategyExists(baseOrEq, ext, concatUniqueStrategy, "concatUnique");
+    return concatUniqueStrategy[baseOrEq.path.type](baseOrEq, ext);
+  }
+}
+export {
+  concat,
+  concatUnique,
+  interleave,
+  isOpaque,
+  keepBase,
+  keepBoth,
+  keepBothStatementParents,
+  keepExtension,
+  opaquely
+};

package/dist/lib/mockTelemetry.js

@@ -0,0 +1,7 @@
+import { vi } from "vitest";
+vi.mock("@cedarjs/telemetry", () => {
+  return {
+    errorTelemetry: () => vi.fn(),
+    timedTelemetry: () => vi.fn()
+  };
+});

package/dist/lib/packages.js

@@ -0,0 +1,77 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import execa from "execa";
+import fs from "fs-extra";
+import { getPaths } from "./index.js";
+async function installModule(name, version = void 0) {
+  if (isModuleInstalled(name)) {
+    return false;
+  }
+  if (version === void 0) {
+    return installRedwoodModule(name);
+  } else {
+    await execa.command(`yarn add -D ${name}@${version}`, {
+      stdio: "inherit",
+      cwd: getPaths().base
+    });
+  }
+  return true;
+}
+async function installRedwoodModule(module) {
+  const packageJson = await import("@cedarjs/cli/package.json", { with: { type: "json" } });
+  let version = packageJson.default.version;
+  if (!isModuleInstalled(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
+    });
+    await execa.command(`yarn dedupe`, {
+      stdio: "inherit",
+      cwd: getPaths().base
+    });
+    return true;
+  }
+  return false;
+}
+function isModuleInstalled(module) {
+  const { dependencies, devDependencies } = fs.readJSONSync(
+    path.join(getPaths().base, "package.json")
+  );
+  const deps = {
+    ...dependencies,
+    ...devDependencies
+  };
+  if (deps[module]) {
+    return true;
+  }
+  const createdRequire = createRequire(import.meta.url);
+  return createdRequire.resolve.paths(`${module}/package.json`).some((requireResolvePath) => {
+    return fs.existsSync(path.join(requireResolvePath, module));
+  });
+}
+export {
+  installModule,
+  installRedwoodModule,
+  isModuleInstalled
+};

package/dist/lib/plugin.js

@@ -0,0 +1,206 @@
+import path from "path";
+import chalk from "chalk";
+import enquirer from "enquirer";
+import fs from "fs-extra";
+import { getCompatibilityData } from "@cedarjs/cli-helpers";
+import { installModule, isModuleInstalled } from "./packages.js";
+import { getPaths } from "./index.js";
+const { Select } = enquirer;
+const PLUGIN_CACHE_FILENAME = "commandCache.json";
+const PLUGIN_CACHE_DEFAULT = {
+  "@cedarjs/cli-storybook-vite": {
+    storybook: {
+      aliases: ["sb"],
+      description: "Launch Storybook: a tool for building UI components and pages in isolation"
+    }
+  },
+  "@cedarjs/cli-data-migrate": {
+    "data-migrate <command>": {
+      aliases: ["dataMigrate", "dm"],
+      description: "Migrate the data in your database"
+    }
+  }
+};
+const PLUGIN_CACHE_BUILTIN = [
+  "build",
+  "check",
+  "diagnostics",
+  "console",
+  "c",
+  "deploy",
+  "destroy",
+  "d",
+  "dev",
+  "exec",
+  "experimental",
+  "exp",
+  "generate",
+  "g",
+  "info",
+  "lint",
+  "prerender",
+  "render",
+  "prisma",
+  "record",
+  "serve",
+  "setup",
+  "test",
+  "ts-to-js",
+  "type-check",
+  "tsc",
+  "tc",
+  "upgrade"
+];
+function loadCommandCache() {
+  let pluginCommandCache = PLUGIN_CACHE_DEFAULT;
+  const commandCachePath = path.join(
+    getPaths().generated.base,
+    PLUGIN_CACHE_FILENAME
+  );
+  try {
+    const localCommandCache = JSON.parse(fs.readFileSync(commandCachePath));
+    let valid = true;
+    for (const [key, value] of Object.entries(localCommandCache)) {
+      if (key === "_builtin") {
+        continue;
+      }
+      valid &&= !Array.isArray(value);
+    }
+    if (valid) {
+      pluginCommandCache = {
+        ...localCommandCache,
+        ...PLUGIN_CACHE_DEFAULT
+      };
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error(`Error loading plugin command cache at ${commandCachePath}`);
+      console.error(error);
+    }
+  }
+  pluginCommandCache._builtin = PLUGIN_CACHE_BUILTIN;
+  return pluginCommandCache;
+}
+function saveCommandCache(pluginCommandCache) {
+  const commandCachePath = path.join(
+    getPaths().generated.base,
+    PLUGIN_CACHE_FILENAME
+  );
+  try {
+    fs.writeFileSync(
+      commandCachePath,
+      JSON.stringify(pluginCommandCache, void 0, 2)
+    );
+  } catch (error) {
+    console.error(`Error saving plugin command cache at ${commandCachePath}`);
+    console.error(error);
+  }
+}
+function checkPluginListAndWarn(plugins) {
+  for (const plugin of plugins) {
+    if (!plugin.package) {
+      console.warn(
+        chalk.yellow(`\u26A0\uFE0F  A plugin is missing a package, it cannot be loaded.`)
+      );
+    }
+  }
+  const pluginPackages = plugins.map((p) => p.package).filter((p) => p !== void 0);
+  if (pluginPackages.length !== new Set(pluginPackages).size) {
+    console.warn(
+      chalk.yellow(
+        "\u26A0\uFE0F  Duplicate plugin packages found in redwood.toml, duplicates will be ignored."
+      )
+    );
+  }
+  const namespaces = plugins.map((p) => p.package?.split("/")[0]);
+  namespaces.forEach((ns) => {
+    if (ns !== void 0 && !ns.startsWith("@")) {
+      console.warn(
+        chalk.yellow(
+          `\u26A0\uFE0F  Plugin "${ns}" is missing a scope/namespace, it will not be loaded.`
+        )
+      );
+    }
+  });
+}
+async function loadPluginPackage(packageName, packageVersion, autoInstall) {
+  if (isModuleInstalled(packageName)) {
+    return await import(packageName);
+  }
+  if (!autoInstall) {
+    console.warn(
+      chalk.yellow(
+        `\u26A0\uFE0F  Plugin "${packageName}" cannot be loaded because it is not installed and "autoInstall" is disabled.`
+      )
+    );
+    return null;
+  }
+  console.log(chalk.green(`Installing plugin "${packageName}"...`));
+  const installed = await installPluginPackage(packageName, packageVersion);
+  if (installed) {
+    return await import(packageName);
+  }
+  return null;
+}
+async function installPluginPackage(packageName, packageVersion) {
+  let versionToInstall = packageVersion;
+  const isRedwoodPackage = packageName.startsWith("@cedarjs/");
+  if (!isRedwoodPackage && versionToInstall === void 0) {
+    versionToInstall = "latest";
+    try {
+      const compatibilityData = await getCompatibilityData(
+        packageName,
+        versionToInstall
+      );
+      versionToInstall = compatibilityData.compatible.version;
+      console.log(
+        chalk.green(
+          `Installing the latest compatible version: ${versionToInstall}`
+        )
+      );
+    } catch (error) {
+      console.log(
+        "The following error occurred while checking plugin compatibility for automatic installation:"
+      );
+      const errorMessage = error.message ?? error;
+      console.log(errorMessage);
+      if (errorMessage.includes("does not have a tag") || errorMessage.includes("does not have a version")) {
+        process.exit(1);
+      }
+      const prompt = new Select({
+        name: "versionDecision",
+        message: "What would you like to do?",
+        choices: [
+          {
+            name: "cancel",
+            message: "Cancel"
+          },
+          {
+            name: "continue",
+            message: "Continue and install the 'latest' version"
+          }
+        ]
+      });
+      const decision = await prompt.run();
+      if (decision === "cancel") {
+        process.exit(1);
+      }
+    }
+  }
+  try {
+    await installModule(packageName, versionToInstall);
+    return true;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+}
+export {
+  PLUGIN_CACHE_BUILTIN,
+  PLUGIN_CACHE_DEFAULT,
+  PLUGIN_CACHE_FILENAME,
+  checkPluginListAndWarn,
+  loadCommandCache,
+  loadPluginPackage,
+  saveCommandCache
+};

package/dist/lib/pluralHelpers.js

@@ -0,0 +1,50 @@
+import prompts from "prompts";
+import { isSingular, isPlural, addSingularPlural } from "./rwPluralize.js";
+const isWordPluralizable = (word) => {
+  return isPlural(word) !== isSingular(word);
+};
+const validatePlural = (plural, singular) => {
+  const trimmedPlural = plural.trim();
+  if (trimmedPlural === singular) {
+    return "Plural can not be same as singular.";
+  }
+  if (trimmedPlural.match(/[\n\r\s]+/)) {
+    return "Only one word please!";
+  }
+  if (trimmedPlural.match(/^[\n\r\s\u0017]*$/)) {
+    return "Plural can not be empty.";
+  }
+  return true;
+};
+const ensureUniquePlural = async ({
+  model,
+  isDestroyer = false,
+  forcePrompt = false
+}) => {
+  if (!forcePrompt && isWordPluralizable(model)) {
+    return;
+  }
+  const generateMessage = `Cannot determine the plural of "${model}". 
+To continue, the generator requires a unique plural form:`;
+  const destroyMessage = `Cannot determine the plural of "${model}" originally used to generate the files. 
+To continue, the destroy command requires the plural form:`;
+  const promptMessage = isDestroyer ? destroyMessage : generateMessage;
+  const initialPlural = model.slice(-1) === "s" ? `${model}es` : `${model}s`;
+  const promptResult = await prompts({
+    type: "text",
+    name: "plural",
+    message: promptMessage,
+    initial: initialPlural,
+    validate: (pluralInput) => validatePlural(pluralInput, model)
+  });
+  const pluralToUse = promptResult.plural?.trim().replace(/\u0017/g, "");
+  if (!pluralToUse) {
+    throw Error("Plural name must not be empty");
+  }
+  addSingularPlural(model, pluralToUse);
+};
+export {
+  ensureUniquePlural,
+  isWordPluralizable,
+  validatePlural
+};

package/dist/lib/ports.js

@@ -0,0 +1,17 @@
+import portfinder from "portfinder";
+async function getFreePort(requestedPort, excludePorts = []) {
+  try {
+    let freePort = await portfinder.getPortPromise({
+      port: requestedPort
+    });
+    if (excludePorts.includes(freePort)) {
+      freePort = await getFreePort(freePort + 1, excludePorts);
+    }
+    return freePort;
+  } catch (error) {
+    return -1;
+  }
+}
+export {
+  getFreePort
+};