@cedarjs/cli 4.2.1-next.0 → 4.2.1-next.269

package/dist/lib/index.js

@@ -1,6 +1,6 @@
-import https from "https";
 import fs from "node:fs";
-import path from "path";
+import https from "node:https";
+import path from "node:path";
 import * as babel from "@babel/core";
 import boxen from "boxen";
 import camelcase from "camelcase";
@@ -14,14 +14,18 @@ import pascalcase from "pascalcase";
 import { format } from "prettier";
 import { colors as c } from "@cedarjs/cli-helpers";
 import {
-  getConfig as getRedwoodConfig,
-  getPaths as getRedwoodPaths,
+  addRootPackages,
+  addWorkspacePackages
+} from "@cedarjs/cli-helpers/packageManager/packages";
+import {
+  getConfig as getCedarConfig,
+  getPaths as getCedarPaths,
   resolveFile as internalResolveFile,
   findUp
 } from "@cedarjs/project-config";
 import { pluralize, singularize } from "@cedarjs/utils/cedarPluralize";
 import { addFileToRollback } from "./rollback.js";
-const nameVariants = (name) => {
+function nameVariants(name) {
   const normalizedName = pascalcase(paramCase(singularize(name)));
   return {
     pascalName: pascalcase(paramCase(name)),
@@ -35,8 +39,8 @@ const nameVariants = (name) => {
     singularConstantName: decamelize(normalizedName).toUpperCase(),
     pluralConstantName: decamelize(pluralize(normalizedName)).toUpperCase()
   };
-};
-const generateTemplate = (templateFilename, { name, ...rest }) => {
+}
+function generateTemplate(templateFilename, { name, ...rest }) {
   try {
     const templateFn = template(readFile(templateFilename).toString());
     const renderedTemplate = templateFn({
@@ -46,18 +50,22 @@ const generateTemplate = (templateFilename, { name, ...rest }) => {
     });
     return prettify(templateFilename, renderedTemplate);
   } catch (error) {
-    error.message = `Error applying template at ${templateFilename} for ${name}: ${error.message}`;
-    throw error;
+    const originalMessage = error instanceof Error ? error.message : String(error);
+    const wrappedError = new Error(
+      `Error applying template at ${templateFilename} for ${name}: ` + originalMessage
+    );
+    throw wrappedError;
   }
-};
+}
 const prettify = async (templateFilename, renderedTemplate) => {
-  const parser = {
+  const parserMap = {
     ".css": "css",
     ".js": "babel",
     ".jsx": "babel",
     ".ts": "babel-ts",
     ".tsx": "babel-ts"
-  }[path.extname(templateFilename.replace(".template", ""))];
+  };
+  const parser = parserMap[path.extname(templateFilename.replace(".template", ""))];
   if (typeof parser === "undefined") {
     return renderedTemplate;
   }
@@ -128,30 +136,43 @@ async function getInstalledCedarVersion() {
     const packageJson = await import("../../package.json", { with: { type: "json" } });
     return packageJson.default.version;
   } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
     console.error(c.error("Could not find installed Cedar version"));
+    console.error(c.error(message));
     process.exit(1);
   }
 }
-const bytes = (contents) => Buffer.byteLength(contents, "utf8");
 const _getPaths = () => {
   try {
-    return getRedwoodPaths();
+    return getCedarPaths();
   } catch (e) {
-    console.error(c.error(e.message));
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(c.error(message));
     process.exit(1);
   }
 };
 const getPaths = memoize(_getPaths);
 const resolveFile = internalResolveFile;
-const getGraphqlPath = () => resolveFile(path.join(getPaths().api.functions, "graphql"));
+const getGraphqlPath = () => {
+  const functionsDir = getPaths().api.functions;
+  if (!functionsDir) {
+    throw new Error("Could not resolve the API functions directory");
+  }
+  return resolveFile(path.join(functionsDir, "graphql"));
+};
 const graphFunctionDoesExist = () => {
-  return fs.existsSync(getGraphqlPath());
+  const graphqlPath = getGraphqlPath();
+  if (!graphqlPath) {
+    return false;
+  }
+  return fs.existsSync(graphqlPath);
 };
 const getConfig = () => {
   try {
-    return getRedwoodConfig();
+    return getCedarConfig();
   } catch (e) {
-    console.error(c.error(e.message));
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(c.error(message));
     process.exit(1);
   }
 };
@@ -162,7 +183,7 @@ const getPrettierOptions = async () => {
     const prettierConfigPath = fs.existsSync(cjsPath) ? cjsPath : mjsPath;
     const { default: prettierOptions } = await import(`file://${prettierConfigPath}`);
     return prettierOptions;
-  } catch (e) {
+  } catch {
     if (process.env.VITEST_POOL_ID !== void 0) {
       return {
         trailingComma: "es5",
@@ -185,10 +206,10 @@ const getPrettierOptions = async () => {
   }
 };
 const transformTSToJS = async (filename, content) => {
-  const { code } = babel.transform(content, {
+  const result = babel.transform(content, {
     filename,
-    // If you ran `yarn cedar generate` in `./web` transformSync would import the `.babelrc.js` file,
-    // in `./web`? despite us setting `configFile: false`.
+    // If you ran `yarn cedar generate` in `./web` transformSync would import
+    // the `.babelrc.js` file, in `./web` despite us setting `configFile: false`
     cwd: process.env.NODE_ENV === "test" ? void 0 : getPaths().base,
     configFile: false,
     plugins: [
@@ -202,16 +223,34 @@ const transformTSToJS = async (filename, content) => {
     ],
     retainLines: true
   });
-  return prettify(filename.replace(/\.ts(x)?$/, ".js$1"), code);
+  if (result?.code == null) {
+    throw new Error(
+      `Could not transform ${filename} from TypeScript to JavaScript`
+    );
+  }
+  return prettify(filename.replace(/\.ts(x)?$/, ".js$1"), result.code);
+};
+const transformTSToJSMap = async (files, typescript) => {
+  return files.reduce(
+    async (accP, [outputPath, content]) => {
+      const acc = await accP;
+      const template2 = typescript ? content : await transformTSToJS(outputPath, content);
+      return {
+        [outputPath]: template2,
+        ...acc
+      };
+    },
+    Promise.resolve({})
+  );
 };
-const writeFilesTask = (files, options) => {
+const writeFilesTask = (files, options = {}) => {
   const { base } = getPaths();
   return new Listr(
     Object.keys(files).map((file) => {
       const contents = files[file];
       return {
         title: `...waiting to write file \`./${path.relative(base, file)}\`...`,
-        task: (ctx, task) => writeFile(file, contents, options, task)
+        task: (_ctx, task) => writeFile(file, contents, options, task)
       };
     })
   );
@@ -266,10 +305,10 @@ const cleanupEmptyDirsTask = (files) => {
     })
   );
 };
-const wrapWithSet = (routesContent, layout, routes, newLineAndIndent, props = {}) => {
+function wrapWithSet(routesContent, layout, routes, newLineAndIndent, props = {}) {
   const [_, indentOne, indentTwo] = routesContent.match(
     /([ \t]*)<Router.*?>[^<]*[\r\n]+([ \t]+)/
-  ) || ["", 0, 2];
+  ) || ["", "", ""];
   const oneLevelIndent = indentTwo.slice(0, indentTwo.length - indentOne.length);
   const newRoutesWithExtraIndent = routes.map((route) => oneLevelIndent + route);
   const propsString = Object.entries(props).map((values) => `${values[0]}="${values[1]}"`).join(" ");
@@ -278,15 +317,17 @@ const wrapWithSet = (routesContent, layout, routes, newLineAndIndent, props = {}
     ...newRoutesWithExtraIndent,
     `</Set>`
   ].join(newLineAndIndent);
-};
-const addRoutesToRouterTask = (routes, layout, setProps = {}) => {
-  const redwoodPaths = getPaths();
-  const routesContent = readFile(redwoodPaths.web.routes).toString();
+}
+function addRoutesToRouterTask(routes, layout, setProps = {}) {
+  const cedarPaths = getPaths();
+  const routesContent = readFile(cedarPaths.web.routes).toString();
   let newRoutes = routes.filter((route) => !routesContent.match(route));
   if (newRoutes.length) {
-    const [routerStart, routerParams, newLineAndIndent] = routesContent.match(
-      /\s*<Router(.*?)>(\s*)/s
-    );
+    const routerMatch = routesContent.match(/\s*<Router(.*?)>(\s*)/s);
+    if (!routerMatch) {
+      throw new Error("Could not find a <Router> element in the routes file");
+    }
+    const [routerStart, routerParams, newLineAndIndent] = routerMatch;
     if (/trailingSlashes={?(["'])always\1}?/.test(routerParams)) {
       newRoutes = newRoutes.map((route) => {
         if (route.length > 2e3) {
@@ -307,11 +348,11 @@ ${route}`);
       routerStart,
       `${routerStart + routesBatch + newLineAndIndent}`
     );
-    writeFile(redwoodPaths.web.routes, newRoutesContent, {
+    writeFile(cedarPaths.web.routes, newRoutesContent, {
       overwriteExisting: true
     });
   }
-};
+}
 const addScaffoldImport = () => {
   const appJsPath = getPaths().web.app;
   let appJsContents = readFile(appJsPath).toString();
@@ -325,11 +366,13 @@ const addScaffoldImport = () => {
   writeFile(appJsPath, appJsContents, { overwriteExisting: true });
   return "Added scaffold import to App.{jsx,tsx}";
 };
-const removeEmtpySet = (routesContent, layout) => {
+function removeEmtpySet(routesContent, layout) {
   const setWithLayoutReg = new RegExp(
     `\\s*<Set[^>]*wrap={${layout}}[^<]*>([^<]*)</Set>`
   );
-  const [matchedSet, childContent] = routesContent.match(setWithLayoutReg) || [];
+  const match = routesContent.match(setWithLayoutReg);
+  const matchedSet = match?.[0] ?? "";
+  const childContent = match?.[1] ?? "";
   if (!matchedSet) {
     return routesContent;
   }
@@ -338,19 +381,19 @@ const removeEmtpySet = (routesContent, layout) => {
     return routesContent;
   }
   return routesContent.replace(setWithLayoutReg, "");
-};
-const removeRoutesFromRouterTask = (routes, layout) => {
-  const redwoodPaths = getPaths();
-  const routesContent = readFile(redwoodPaths.web.routes).toString();
+}
+function removeRoutesFromRouterTask(routes, layout) {
+  const cedarPaths = getPaths();
+  const routesContent = readFile(cedarPaths.web.routes).toString();
   const newRoutesContent = routes.reduce((content, route) => {
     const matchRouteByName = new RegExp(`\\s*<Route[^>]*name="${route}"[^>]*/>`);
     return content.replace(matchRouteByName, "");
   }, routesContent);
   const routesWithoutEmptySet = layout ? removeEmtpySet(newRoutesContent, layout) : newRoutesContent;
-  writeFile(redwoodPaths.web.routes, routesWithoutEmptySet, {
+  writeFile(cedarPaths.web.routes, routesWithoutEmptySet, {
     overwriteExisting: true
   });
-};
+}
 const addPackagesTask = async ({
   packages,
   side = "project",
@@ -364,57 +407,48 @@ const addPackagesTask = async ({
       return pkg;
     }
   });
-  let installCommand;
-  if (side !== "project") {
-    installCommand = [
-      "yarn",
-      [
-        "workspace",
-        side,
-        "add",
-        devDependency && "--dev",
-        ...packagesWithSameRWVersion
-      ].filter(Boolean)
-    ];
-  } else {
-    installCommand = [
-      "yarn",
-      ["add", devDependency && "--dev", ...packagesWithSameRWVersion].filter(
-        Boolean
-      )
-    ];
-  }
   return {
     title: `Adding dependencies to ${side}`,
     task: async () => {
-      await execa(...installCommand);
+      if (side !== "project") {
+        await addWorkspacePackages(side, packagesWithSameRWVersion, {
+          dev: devDependency
+        });
+      } else {
+        await addRootPackages(packagesWithSameRWVersion, {
+          dev: devDependency
+        });
+      }
     }
   };
 };
-const runCommandTask = async (commands, { verbose, silent }) => {
+const runCommandTask = async (commands, { verbose, silent } = {}) => {
   const tasks = new Listr(
-    commands.map(({ title, cmd, args, opts = {}, cwd = getPaths().base }) => ({
-      title,
-      task: async () => {
-        return execa(cmd, args, {
-          cwd,
-          stdio: verbose && !silent ? "inherit" : "pipe",
-          extendEnv: true,
-          cleanup: true,
-          ...opts
-        });
-      }
-    })),
+    commands.map(
+      ({ title, cmd, args = [], opts = {}, cwd = getPaths().base }) => ({
+        title,
+        task: async () => {
+          return execa(cmd, args, {
+            cwd,
+            stdio: verbose && !silent ? "inherit" : "pipe",
+            extendEnv: true,
+            cleanup: true,
+            ...opts
+          });
+        }
+      })
+    ),
     {
       renderer: silent ? "silent" : verbose ? "verbose" : "default",
-      rendererOptions: { collapseSubtasks: false, dateFormat: false }
+      rendererOptions: { collapseSubtasks: false }
     }
   );
   try {
     await tasks.run();
     return true;
   } catch (e) {
-    console.log(c.error(e.message));
+    const message = e instanceof Error ? e.message : String(e);
+    console.log(c.error(message));
     return false;
   }
 };
@@ -428,8 +462,8 @@ const getDefaultArgs = (builder) => {
   );
 };
 const usingVSCode = () => {
-  const redwoodPaths = getPaths();
-  const VS_CODE_PATH = path.join(redwoodPaths.base, ".vscode");
+  const cedarPaths = getPaths();
+  const VS_CODE_PATH = path.join(cedarPaths.base, ".vscode");
   return fs.existsSync(VS_CODE_PATH);
 };
 const printSetupNotes = (notes) => {
@@ -441,7 +475,7 @@ const printSetupNotes = (notes) => {
  ${boxen(notes.join("\n"), {
         padding: { top: 1, bottom: 1, right: 1, left: 1 },
         margin: 1,
-        borderColour: "gray"
+        borderColor: "gray"
       })}  
 `;
     }
@@ -452,7 +486,6 @@ export {
   addPackagesTask,
   addRoutesToRouterTask,
   addScaffoldImport,
-  bytes,
   cleanupEmptyDirsTask,
   deleteFile,
   deleteFilesTask,
@@ -475,6 +508,7 @@ export {
   runCommandTask,
   saveRemoteFileToDisk,
   transformTSToJS,
+  transformTSToJSMap,
   usingVSCode,
   writeFile,
   writeFilesTask

package/dist/lib/merge/algorithms.js

@@ -16,9 +16,12 @@ function sieve(...listRulePairs) {
   }
   return result;
 }
+function isAnyFn(value) {
+  return typeof value === "function";
+}
 function forEachFunctionOn(object, callback) {
   forOwn(object, (value, key) => {
-    if (typeof value === "function") {
+    if (isAnyFn(value)) {
       callback(key, value);
     }
   });

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,23 +67,36 @@ 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":
@@ -95,6 +106,7 @@ function prune(path) {
 function stripTrailingCommentsStrategy() {
   return {
     enter(path) {
+      ;
       path.node.trailingComments = [];
     }
   };
@@ -104,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(".");