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

package/dist/lib/extendFile.js

@@ -1,8 +1,8 @@
 import fs from "node:fs";
-function fileIncludes(path, str) {
-  return fs.existsSync(path) && fs.readFileSync(path).toString().includes(str);
+function fileIncludes(filePath, str) {
+  return fs.existsSync(filePath) && fs.readFileSync(filePath).toString().includes(str);
 }
-function extendJSXFile(path, {
+function extendJSXFile(filePath, {
   insertComponent: {
     name = void 0,
     props = void 0,
@@ -14,7 +14,7 @@ function extendJSXFile(path, {
   imports = [],
   moduleScopeLines = []
 }) {
-  const content = fs.readFileSync(path).toString().split("\n");
+  const content = fs.readFileSync(filePath).toString().split("\n");
   if (moduleScopeLines?.length) {
     content.splice(
       content.findLastIndex((l) => l.trimStart().startsWith("import")) + 1,
@@ -41,15 +41,22 @@ function extendJSXFile(path, {
       insertAfter
     });
   }
-  fs.writeFileSync(path, content.filter((e) => e !== void 0).join("\n"));
+  fs.writeFileSync(filePath, content.join("\n"));
 }
-function insertComponent(content, { component, props, around, within, insertBefore, insertAfter }) {
+function insertComponent(content, {
+  component,
+  props,
+  around,
+  within,
+  insertBefore,
+  insertAfter
+}) {
   if (around && within || !(around || within)) {
     throw new Error(
       "Exactly one of (around | within) must be defined. Choose one."
     );
   }
-  const target = around ?? within;
+  const target = `(?:${around ?? within})`;
   const findTagIndex = (regex) => content.findIndex((line) => regex.test(line));
   let open = findTagIndex(new RegExp(`([^\\S\r
 ]*)<${target}\\s*(.*)\\s*>`));
@@ -62,16 +69,16 @@ function insertComponent(content, { component, props, around, within, insertBefo
     open++;
     close--;
   }
-  const [, componentDepth] = content[open].match(/([^\S\r\n]*).*/);
+  const depthMatch = content[open].match(/([^\S\r\n]*).*/);
+  const componentDepth = depthMatch?.[1] ?? "";
   content.splice(
     open,
     close - open,
-    // "Delete" the wrapped component contents. We put it back below.
-    insertBefore && componentDepth + insertBefore,
+    ...insertBefore ? [componentDepth + insertBefore] : [],
     componentDepth + buildOpeningTag(component, props),
     ...content.slice(open, close).map((line) => "  " + line),
     componentDepth + `</${component}>`,
-    insertAfter && componentDepth + insertAfter
+    ...insertAfter ? [componentDepth + insertAfter] : []
   );
 }
 function buildOpeningTag(componentName, props) {
@@ -92,11 +99,14 @@ function buildOpeningTag(componentName, props) {
   const possibleSpace = propsString.length ? " " : "";
   return `<${componentName}${possibleSpace}${propsString}>`;
 }
-function objectToComponentProps(obj, options = { exclude: [], raw: false }) {
+function objectToComponentProps(obj, options = {
+  exclude: [],
+  raw: false
+}) {
   const props = [];
   const doRaw = (key) => options.raw === true || Array.isArray(options.raw) && options.raw.includes(key);
   for (const [key, value] of Object.entries(obj)) {
-    if (options.exclude && options.exclude.includes(key)) {
+    if (options.exclude?.includes(key)) {
       continue;
     }
     if (doRaw(key)) {

package/dist/lib/generatePrismaClient.js

@@ -1,8 +1,11 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
-import { runCommandTask, getPaths } from "../lib/index.js";
+import { getConfig, getPrismaSchemas } from "@cedarjs/project-config";
+import { runCommandTask, getPaths } from "./index.js";
 const generatePrismaCommand = async () => {
+  const config = getConfig();
   const createdRequire = createRequire(import.meta.url);
   const prismaIndexPath = createdRequire.resolve("prisma/build/index.js");
   return {
@@ -10,22 +13,52 @@ const generatePrismaCommand = async () => {
     args: [
       prismaIndexPath,
       "generate",
-      `--config=${getPaths().api.prismaConfig}`
+      `--config=${getPaths().api.prismaConfig}`,
+      ...config.api.prismaGenerateArgs
     ]
   };
 };
-const generatePrismaClient = async ({
+async function computePrismaSchemaHash() {
+  try {
+    const hash = createHash("sha256");
+    const configPath = getPaths().api.prismaConfig;
+    if (fs.existsSync(configPath)) {
+      hash.update(fs.readFileSync(configPath));
+    }
+    const { schemas } = await getPrismaSchemas();
+    for (const schema of schemas) {
+      hash.update(schema[1]);
+    }
+    return hash.digest("hex");
+  } catch {
+    return null;
+  }
+}
+function getHashFilePath() {
+  const generatedBase = getPaths().generated.base;
+  return path.join(generatedBase, "prisma-schema-hash");
+}
+function getStoredSchemaHash() {
+  const hashFile = getHashFilePath();
+  if (fs.existsSync(hashFile)) {
+    return fs.readFileSync(hashFile, "utf-8").trim();
+  }
+  return null;
+}
+function storeSchemaHash(hash) {
+  const hashFile = getHashFilePath();
+  fs.mkdirSync(path.dirname(hashFile), { recursive: true });
+  fs.writeFileSync(hashFile, hash);
+}
+async function generatePrismaClient({
   verbose = true,
-  force = true,
+  force = false,
   silent = false
-}) => {
+} = {}) {
+  const hash = await computePrismaSchemaHash();
   if (!force) {
-    const prismaClientPath = path.join(
-      getPaths().base,
-      "node_modules/.prisma/client/index.js"
-    );
-    const prismaClientFile = fs.readFileSync(prismaClientPath, "utf8");
-    if (!prismaClientFile.includes("@prisma/client did not initialize yet.") && prismaClientFile.includes("exports.Prisma.")) {
+    const storedHash = hash ? getStoredSchemaHash() : null;
+    if (hash !== null && hash === storedHash) {
       return;
     }
   }
@@ -41,7 +74,10 @@ const generatePrismaClient = async ({
       silent
     }
   );
-};
+  if (hash !== null) {
+    storeSchemaHash(hash);
+  }
+}
 export {
   generatePrismaClient,
   generatePrismaCommand

package/dist/lib/index.js

@@ -1,7 +1,6 @@
-import https from "https";
 import fs from "node:fs";
-import path from "path";
-import * as babel from "@babel/core";
+import https from "node:https";
+import path from "node:path";
 import boxen from "boxen";
 import camelcase from "camelcase";
 import { paramCase } from "change-case";
@@ -12,16 +11,21 @@ import memoize from "lodash/memoize.js";
 import template from "lodash/template.js";
 import pascalcase from "pascalcase";
 import { format } from "prettier";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 import {
-  getConfig as getRedwoodConfig,
-  getPaths as getRedwoodPaths,
+  addRootPackages,
+  addWorkspacePackages
+} from "@cedarjs/cli-helpers/packageManager/packages";
+import { transpileTSToJS } from "@cedarjs/cli-helpers/transpileTSToJS";
+import {
+  getConfig as getCedarConfig,
+  getPaths as getCedarPaths,
   resolveFile as internalResolveFile,
   findUp
 } from "@cedarjs/project-config";
-import { pluralize, singularize } from "./cedarPluralize.js";
-import c from "./colors.js";
+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,33 +206,32 @@ const getPrettierOptions = async () => {
   }
 };
 const transformTSToJS = async (filename, content) => {
-  const { code } = 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`.
-    cwd: process.env.NODE_ENV === "test" ? void 0 : getPaths().base,
-    configFile: false,
-    plugins: [
-      [
-        "@babel/plugin-transform-typescript",
-        {
-          isTSX: true,
-          allExtensions: true
-        }
-      ]
-    ],
-    retainLines: true
-  });
-  return prettify(filename.replace(/\.ts(x)?$/, ".js$1"), code);
+  return prettify(
+    filename.replace(/\.ts(x)?$/, ".js$1"),
+    transpileTSToJS(filename, content)
+  );
+};
+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,27 +286,44 @@ const cleanupEmptyDirsTask = (files) => {
     })
   );
 };
-const wrapWithSet = (routesContent, layout, routes, newLineAndIndent, props = {}) => {
+function wrapWithSet(routesContent, layout, routes, newLineAndIndent, props = {}, privateSetProps) {
   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(" ");
+  if (!privateSetProps) {
+    const newRoutesWithExtraIndent2 = routes.map(
+      (route) => oneLevelIndent + route
+    );
+    return [
+      `<Set wrap={${layout}}${propsString && " " + propsString}>`,
+      ...newRoutesWithExtraIndent2,
+      `</Set>`
+    ].join(newLineAndIndent);
+  }
+  const privateSetPropsString = Object.entries(privateSetProps).map((values) => `${values[0]}="${values[1]}"`).join(" ");
+  const newRoutesWithExtraIndent = routes.map(
+    (route) => oneLevelIndent + oneLevelIndent + route
+  );
   return [
-    `<Set wrap={${layout}}${propsString && " " + propsString}>`,
+    `<PrivateSet${privateSetPropsString && " " + privateSetPropsString}>`,
+    `${oneLevelIndent}<Set wrap={${layout}}${propsString && " " + propsString}>`,
     ...newRoutesWithExtraIndent,
-    `</Set>`
+    `${oneLevelIndent}</Set>`,
+    `</PrivateSet>`
   ].join(newLineAndIndent);
-};
-const addRoutesToRouterTask = (routes, layout, setProps = {}) => {
-  const redwoodPaths = getPaths();
-  const routesContent = readFile(redwoodPaths.web.routes).toString();
+}
+function addRoutesToRouterTask(routes, layout, setProps = {}, privateSetProps) {
+  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) {
@@ -301,17 +338,18 @@ ${route}`);
       layout,
       newRoutes,
       newLineAndIndent,
-      setProps
+      setProps,
+      privateSetProps
     ) : newRoutes.join(newLineAndIndent);
     const newRoutesContent = routesContent.replace(
       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 +363,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 +378,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 +404,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 +459,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 +472,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 +483,6 @@ export {
   addPackagesTask,
   addRoutesToRouterTask,
   addScaffoldImport,
-  bytes,
   cleanupEmptyDirsTask,
   deleteFile,
   deleteFilesTask,
@@ -475,6 +505,7 @@ export {
   runCommandTask,
   saveRemoteFileToDisk,
   transformTSToJS,
+  transformTSToJSMap,
   usingVSCode,
   writeFile,
   writeFilesTask

package/dist/lib/loadEnvFiles.js

@@ -3,7 +3,7 @@ import {
   loadDefaultEnvFiles,
   loadNodeEnvDerivedEnvFile,
   loadUserSpecifiedEnvFiles
-} from "@cedarjs/cli-helpers";
+} from "@cedarjs/cli-helpers/loadEnvFiles";
 export {
   loadDefaultEnvFiles,
   loadEnvFiles,

package/dist/lib/locking.js

@@ -32,11 +32,15 @@ function unsetLock(identifier) {
 }
 function isLockSet(identifier) {
   const lockfilePath = path.join(getPaths().generated.base, "locks", identifier);
-  const exists = fs.existsSync(lockfilePath);
-  if (!exists) {
-    return false;
+  let createdAt;
+  try {
+    createdAt = fs.statSync(lockfilePath).birthtimeMs;
+  } catch (error) {
+    if (isErrorWithCode(error, "ENOENT")) {
+      return false;
+    }
+    throw error;
   }
-  const createdAt = fs.statSync(lockfilePath).birthtimeMs;
   if (Date.now() - createdAt > 36e5) {
     unsetLock(identifier);
     return false;

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);
     }
   });