@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/lib/merge/index.js

@@ -8,9 +8,6 @@ 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;
@@ -29,7 +26,7 @@ function getProgramPath(ast) {
   return programPath;
 }
 function skipChildren(path) {
-  for (const key of VISITOR_KEYS[path.type]) {
+  for (const key of VISITOR_KEYS[path.type] ?? []) {
     path.skipKey(key);
   }
 }
@@ -46,6 +43,7 @@ function makeProxy(path) {
       if (property === "path") {
         throw new Error("You can't set a path on a proxy!");
       } else {
+        ;
         target.node[property] = value;
         return true;
       }
@@ -59,7 +57,7 @@ function expressionUses(exp, ...ids) {
   let result = false;
   exp.traverse({
     Identifier(path) {
-      if (!path.parentPath.isNodeType("VariableDeclarator") && ids.includes(path.node.name)) {
+      if (!path.parentPath?.isNodeType("VariableDeclarator") && ids.includes(path.node.name)) {
         result = true;
         return;
       }
@@ -69,22 +67,37 @@ function expressionUses(exp, ...ids) {
 }
 function insertBeforeFirstUsage(expression, program) {
   const body = program.get("body");
-  const pos = body.findIndex(
-    (exp) => expressionUses(exp, ...Object.keys(expression.getBindingIdentifiers()))
+  const bindingIds = Object.keys(
+    expression.getBindingIdentifiers()
   );
-  return pos !== -1 ? body[pos].insertBefore(expression.node) : program.pushContainer("body", expression.node);
+  const pos = body.findIndex((exp) => expressionUses(exp, ...bindingIds));
+  if (pos !== -1) {
+    return body[pos].insertBefore(expression.node);
+  } else {
+    return 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);
+  let lastImportIdx = -1;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i].isNodeType("ImportDeclaration")) {
+      lastImportIdx = i;
+    }
+  }
+  return body[lastImportIdx].insertAfter(expression.node);
 }
 function prune(path) {
-  switch (path.parentPath.type) {
+  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}`);
+      console.log(
+        `Warning: default prune strategy for ${path.parentPath?.type}`
+      );
+    // eslint-disable-next-line no-fallthrough
     case "Program":
     case "ArrayExpression":
       return path.remove();
@@ -93,6 +106,7 @@ function prune(path) {
 function stripTrailingCommentsStrategy() {
   return {
     enter(path) {
+      ;
       path.node.trailingComments = [];
     }
   };
@@ -102,48 +116,71 @@ function mergeAST(baseAST, extAST, strategy = {}) {
   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);
+  forEachFunctionOn(
+    strategy,
+    (typename, strat) => {
+      extVisitor[typename] = {
+        enter(path) {
+          const id = identity(path);
+          if (id) {
+            ;
+            (identities[id] ||= []).push(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);
-          });
+      };
+      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);
+      };
+    }
+  );
+  traverse(
+    extAST,
+    extVisitor
+  );
+  traverse(
+    baseAST,
+    baseVisitor
+  );
   const baseProgram = getProgramPath(baseAST);
+  const body = getProgramPath(extAST).get("body");
   const [imports, others] = partition(
-    getProgramPath(extAST).get("body"),
-    nodeIs("ImportDeclaration")
+    body,
+    // nodeIs returns (node: Node) => boolean; here we have NodePaths, so we
+    // check path.node to stay type-safe.
+    (path) => nodeIs("ImportDeclaration")(path.node)
   );
   imports.forEach((exp) => insertAfterLastImport(exp, baseProgram));
-  forEachRight(others, (exp) => insertBeforeFirstUsage(exp, baseProgram));
+  forEachRight(
+    others,
+    (exp) => insertBeforeFirstUsage(exp, baseProgram)
+  );
 }
 async function merge(base, extension, strategy) {
   function parseReact(code2) {
-    return parse(code2, {
-      filename: "merged.tsx",
+    const result = parse(code2, {
       // required to prevent babel error. The .tsx is relevant
+      filename: "merged.tsx",
       presets: ["@babel/preset-typescript"]
     });
+    if (result === null) {
+      throw new Error("Failed to parse code");
+    }
+    return result;
   }
   const baseAST = parseReact(base);
   const extAST = parseReact(extension);

package/dist/lib/merge/semanticIdentity.js

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

package/dist/lib/merge/strategy.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import uniqWith from "lodash/uniqWith.js";
 import { nodeIs, sieve } from "./algorithms.js";
-const OPAQUE_UID_TAG = "RW_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
+const OPAQUE_UID_TAG = "CEDAR_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
 function requireSameType(base, ext) {
   if (base.path.type !== ext.path.type) {
     throw new Error(
@@ -17,9 +17,21 @@ function requireStrategyExists(base, _ext, strategy, strategyName) {
   }
 }
 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 hasName(v) {
+  return typeof v === "object" && v !== null && "name" in v;
+}
+function hasKey(v) {
+  return typeof v === "object" && v !== null && "key" in v;
+}
+function hasKeyName(v) {
+  return hasKey(v) && hasName(v.key);
+}
+function hasValue(v) {
+  return typeof v === "object" && v !== null && "value" in v;
+}
+const byName = (lhs, rhs) => hasName(lhs) && hasName(rhs) && lhs.name === rhs.name;
+const byKeyName = (lhs, rhs) => hasKeyName(lhs) && hasKeyName(rhs) && lhs.key.name === rhs.key.name;
+const byValue = (lhs, rhs) => hasValue(lhs) && hasValue(rhs) && lhs.value === rhs.value;
 function defaultEquality(baseContainer, extContainer) {
   const sample = baseContainer.length && baseContainer[0] || extContainer.length && extContainer[0];
   const defaults = {
@@ -30,14 +42,13 @@ function defaultEquality(baseContainer, extContainer) {
     ObjectProperty: byKeyName,
     StringLiteral: byValue
   };
-  return sample && sample.type in defaults ? defaults[sample.type] : strictEquality;
+  return sample && typeof sample === "object" && "type" in sample && typeof sample.type === "string" && sample.type in defaults ? defaults[sample.type] : strictEquality;
 }
-function opaquely(strategy) {
-  strategy[OPAQUE_UID_TAG] = true;
-  return strategy;
+function opaquely(reducer) {
+  return Object.assign(reducer, { [OPAQUE_UID_TAG]: true });
 }
-function isOpaque(strategy) {
-  return strategy[OPAQUE_UID_TAG] === true;
+function isOpaque(fn) {
+  return OPAQUE_UID_TAG in fn && fn[OPAQUE_UID_TAG] === true;
 }
 const keepBase = opaquely(() => {
 });
@@ -47,20 +58,36 @@ const keepBoth = opaquely((base, ext) => {
 const keepExtension = opaquely((base, ext) => {
   base.path.replaceWith(ext.path);
 });
-const keepBothStatementParents = opaquely((base, ext) => {
-  base.path.getStatementParent().insertAfter(ext.path.getStatementParent().node);
-});
+const keepBothStatementParents = opaquely(
+  (base, ext) => {
+    const extParent = ext.path.getStatementParent();
+    if (extParent) {
+      base.path.getStatementParent()?.insertAfter(extParent.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;
+  ImportDeclaration(base, ext) {
+    if (!t.isImportDeclaration(base) || !t.isImportDeclaration(ext)) {
+      return;
+    }
+    const baseSpecs = base.specifiers;
+    const extSpecs = ext.specifiers;
+    const importSpecifierEquality = (lhs, rhs) => {
+      if (lhs.type !== rhs.type) {
+        return false;
+      }
+      if (lhs.type === "ImportSpecifier" && rhs.type === "ImportSpecifier") {
+        return lhs.imported.type === "Identifier" && rhs.imported.type === "Identifier" && lhs.imported.name === rhs.imported.name && lhs.local?.name === rhs.local?.name;
+      }
+      return 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);
+      return keepBothStatementParents(base, ext);
     }
     const defaultPosition = (specs) => specs.some(nodeIs("ImportDefaultSpecifier")) ? -1 : 0;
     const namespacePosition = (specs) => specs.some(nodeIs("ImportNamespaceSpecifier")) || specs.some(nodeIs("ImportSpecifier")) ? -1 : specs.length;
@@ -70,10 +97,10 @@ const interleaveStrategy = {
       [uniqueSpecifiersOfType("ImportNamespaceSpecifier"), namespacePosition],
       [uniqueSpecifiersOfType("ImportSpecifier"), importPosition]
     );
-    baseImport.specifiers = firstSpecifierList;
+    base.specifiers = firstSpecifierList;
     if (rest.length) {
-      baseImport.path.insertAfter(
-        rest.map((specs) => t.importDeclaration(specs, baseImport.source))
+      base.path.insertAfter(
+        rest.map((specs) => t.importDeclaration(specs, base.source))
       );
     }
   }
@@ -81,47 +108,70 @@ const interleaveStrategy = {
 function interleave(base, ext) {
   requireSameType(base, ext);
   requireStrategyExists(base, ext, interleaveStrategy, "interleave");
-  return interleaveStrategy[base.path.type](base, ext);
+  interleaveStrategy[base.path.type]?.(base, ext);
 }
 const concatStrategy = {
   ArrayExpression(base, ext) {
+    if (!t.isArrayExpression(base) || !t.isArrayExpression(ext)) {
+      return;
+    }
     base.elements = [...base.elements, ...ext.elements];
   },
   ObjectExpression(base, ext) {
+    if (!t.isObjectExpression(base) || !t.isObjectExpression(ext)) {
+      return;
+    }
     base.properties = [...base.properties, ...ext.properties];
   },
   StringLiteral(base, ext) {
+    if (!t.isStringLiteral(base) || !t.isStringLiteral(ext)) {
+      return;
+    }
     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);
+  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);
+    if (!t.isArrayExpression(base) || !t.isArrayExpression(ext)) {
+      return;
+    }
+    const equalFn = eq ?? defaultEquality(base.elements, ext.elements);
+    base.elements = uniqWith([...base.elements, ...ext.elements], equalFn);
   },
   ObjectExpression(base, ext, eq) {
-    eq ||= defaultEquality(base.properties, ext.properties);
-    base.properties = uniqWith([...base.properties, ...ext.properties], eq);
+    if (!t.isObjectExpression(base) || !t.isObjectExpression(ext)) {
+      return;
+    }
+    const equalFn = eq ?? defaultEquality(base.properties, ext.properties);
+    base.properties = uniqWith([...base.properties, ...ext.properties], equalFn);
   }
 };
 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 (typeof baseOrEq === "function") {
+    const eq = baseOrEq;
+    return (base2, innerExt) => {
+      requireSameType(base2, innerExt);
+      requireStrategyExists(
+        base2,
+        innerExt,
+        concatUniqueStrategy,
+        "concatUnique"
+      );
+      concatUniqueStrategy[base2.path.type]?.(base2, innerExt, eq);
     };
   }
-  if (arguments.length === 2) {
-    requireSameType(baseOrEq, ext);
-    requireStrategyExists(baseOrEq, ext, concatUniqueStrategy, "concatUnique");
-    return concatUniqueStrategy[baseOrEq.path.type](baseOrEq, ext);
+  const base = baseOrEq;
+  if (!ext) {
+    return;
   }
+  requireSameType(base, ext);
+  requireStrategyExists(base, ext, concatUniqueStrategy, "concatUnique");
+  concatUniqueStrategy[base.path.type]?.(base, ext);
 }
 export {
   concat,

package/dist/lib/packages.js

@@ -2,22 +2,26 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import execa from "execa";
+import { dedupe } from "@cedarjs/cli-helpers/packageManager";
+import { addRootPackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { getPackageManager } from "@cedarjs/project-config/packageManager";
 import { getPaths } from "./index.js";
 async function installModule(name, version = void 0) {
   if (isModuleInstalled(name)) {
     return false;
   }
   if (version === void 0) {
-    return installRedwoodModule(name);
+    return installCedarModule(name);
   } else {
-    await execa.command(`yarn add -D ${name}@${version}`, {
+    await addRootPackages([`${name}@${version}`], {
+      dev: true,
       stdio: "inherit",
       cwd: getPaths().base
     });
   }
   return true;
 }
-async function installRedwoodModule(module) {
+async function installCedarModule(module) {
   const packageJson = await import("@cedarjs/cli/package.json", { with: { type: "json" } });
   let version = packageJson.default.version;
   if (!isModuleInstalled(module)) {
@@ -35,21 +39,27 @@ async function installRedwoodModule(module) {
       }
     } catch (error) {
       throw new Error(
-        `Couldn't fetch packument for ${module}: ${error.message}`
+        `Couldn't fetch packument for ${module}: ${error instanceof Error ? error.message : String(error)}`
       );
     }
-    const versionIsPublished = Object.keys(packument.versions).includes(version);
+    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`, {
+    await addRootPackages([`${module}@${version}`], {
+      dev: true,
       stdio: "inherit",
       cwd: getPaths().base
     });
+    const dedupeCommand = dedupe();
+    if (dedupeCommand) {
+      await execa(getPackageManager(), [dedupeCommand], {
+        stdio: "inherit",
+        cwd: getPaths().base
+      });
+    }
     return true;
   }
   return false;
@@ -66,12 +76,12 @@ function isModuleInstalled(module) {
     return true;
   }
   const createdRequire = createRequire(import.meta.url);
-  return createdRequire.resolve.paths(`${module}/package.json`).some((requireResolvePath) => {
+  return createdRequire.resolve.paths(`${module}/package.json`)?.some((requireResolvePath) => {
     return fs.existsSync(path.join(requireResolvePath, module));
-  });
+  }) ?? false;
 }
 export {
+  installCedarModule,
   installModule,
-  installRedwoodModule,
   isModuleInstalled
 };

package/dist/lib/plugin.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "path";
 import ansis from "ansis";
 import enquirer from "enquirer";
-import { getCompatibilityData } from "@cedarjs/cli-helpers";
+import { getCompatibilityData } from "@cedarjs/cli-helpers/version";
 import { installModule, isModuleInstalled } from "./packages.js";
 import { getPaths } from "./index.js";
 const { Select } = enquirer;
@@ -45,22 +45,28 @@ const PLUGIN_CACHE_BUILTIN = [
   "serve",
   "setup",
   "test",
-  "ts-to-js",
   "type-check",
   "tsc",
   "tc",
   "upgrade"
 ];
+function isErrorWithCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
 function loadCommandCache() {
-  let pluginCommandCache = PLUGIN_CACHE_DEFAULT;
+  let pluginCommandCache = { ...PLUGIN_CACHE_DEFAULT };
   const commandCachePath = path.join(
     getPaths().generated.base,
     PLUGIN_CACHE_FILENAME
   );
   try {
-    const localCommandCache = JSON.parse(fs.readFileSync(commandCachePath));
+    const localCommandCache = JSON.parse(
+      fs.readFileSync(commandCachePath, "utf8")
+    );
     let valid = true;
-    for (const [key, value] of Object.entries(localCommandCache)) {
+    for (const [key, value] of Object.entries(
+      localCommandCache
+    )) {
       if (key === "_builtin") {
         continue;
       }
@@ -73,7 +79,7 @@ function loadCommandCache() {
       };
     }
   } catch (error) {
-    if (error.code !== "ENOENT") {
+    if (!isErrorWithCode(error, "ENOENT")) {
       console.error(`Error loading plugin command cache at ${commandCachePath}`);
       console.error(error);
     }
@@ -162,7 +168,7 @@ async function installPluginPackage(packageName, packageVersion) {
       console.log(
         "The following error occurred while checking plugin compatibility for automatic installation:"
       );
-      const errorMessage = error.message ?? error;
+      const errorMessage = error instanceof Error ? error.message : String(error);
       console.log(errorMessage);
       if (errorMessage.includes("does not have a tag") || errorMessage.includes("does not have a version")) {
         process.exit(1);

package/dist/lib/pluralHelpers.js

@@ -1,5 +1,9 @@
 import prompts from "prompts";
-import { isSingular, isPlural, addSingularPlural } from "./cedarPluralize.js";
+import {
+  isSingular,
+  isPlural,
+  addSingularPlural
+} from "@cedarjs/utils/cedarPluralize";
 const isWordPluralizable = (word) => {
   return isPlural(word) !== isSingular(word);
 };
@@ -29,7 +33,7 @@ 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 initialPlural = model.endsWith("s") ? `${model}es` : `${model}s`;
   const promptResult = await prompts({
     type: "text",
     name: "plural",

package/dist/lib/project.js

@@ -5,7 +5,9 @@ const isTypeScriptProject = () => {
   const paths = getPaths();
   return fs.existsSync(path.join(paths.web.base, "tsconfig.json")) || fs.existsSync(path.join(paths.api.base, "tsconfig.json"));
 };
-function workspaces({ includePackages = false } = {}) {
+function workspaces({
+  includePackages = false
+} = {}) {
   const cedarPaths = getPaths();
   let workspaces2 = [];
   if (fs.existsSync(path.join(cedarPaths.web.base, "package.json"))) {

package/dist/lib/rollback.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "path";
-let rollback = [];
+const rollback = [];
 function addFunctionToRollback(func, atEnd = false) {
   const step = { type: "func", func };
   if (atEnd) {
@@ -9,11 +9,11 @@ function addFunctionToRollback(func, atEnd = false) {
     rollback.push(step);
   }
 }
-function addFileToRollback(path2, atEnd = false) {
+function addFileToRollback(filePath, atEnd = false) {
   const step = {
     type: "file",
-    path: path2,
-    content: fs.existsSync(path2) ? fs.readFileSync(path2) : null
+    path: filePath,
+    content: fs.existsSync(filePath) ? fs.readFileSync(filePath) : null
   };
   if (atEnd) {
     rollback.unshift(step);
@@ -21,7 +21,7 @@ function addFileToRollback(path2, atEnd = false) {
     rollback.push(step);
   }
 }
-async function executeRollback(_ = null, task = null) {
+const executeRollback = async (_, task) => {
   if (task) {
     task.title = "Reverting generator actions...";
   }
@@ -51,9 +51,9 @@ async function executeRollback(_ = null, task = null) {
     }
   }
   if (task) {
-    task.title = `Reverted because: ${task.task.message.error}`;
+    task.title = `Reverted because: ${task.task.message?.error ?? "unknown error"}`;
   }
-}
+};
 function resetRollback() {
   rollback.length = 0;
 }