@cedarjs/cli 2.4.1 → 2.4.2-next.143

package/dist/commands/generate/package/packageHandler.js

@@ -1,9 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
+import { ListrEnquirerPromptAdapter } from "@listr2/prompt-adapter-enquirer";
 import { paramCase, camelCase } from "change-case";
 import execa from "execa";
+import { modify, applyEdits } from "jsonc-parser";
 import { Listr } from "listr2";
 import { terminalLink } from "termi-link";
+import ts from "typescript";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 import { getConfig } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
@@ -20,31 +23,89 @@ function nameVariants(nameArg) {
   return { name, folderName, packageName, fileName };
 }
 async function updateTsconfig(task) {
-  const tsconfigPath = path.join(getPaths().api.base, "tsconfig.json");
-  const tsconfig = await fs.promises.readFile(tsconfigPath, "utf8");
-  const tsconfigLines = tsconfig.split("\n");
-  const moduleLineIndex = tsconfigLines.findIndex(
-    (line) => /^\s*"module":\s*"/.test(line)
-  );
-  const moduleLine = tsconfigLines[moduleLineIndex];
-  if (moduleLine.toLowerCase().includes("node20") || // While Cedar doesn't officially endorse the usage of NodeNext, it
-  // will still work here, so I won't overwrite it
-  moduleLine.toLowerCase().includes("nodenext")) {
+  const targets = [
+    {
+      name: "api",
+      path: path.join(getPaths().api.base, "tsconfig.json"),
+      expectedModule: "node20",
+      // While Cedar doesn't officially endorse NodeNext, it will still work
+      // here, so we'll keep it
+      acceptable: ["node20", "nodenext"]
+    },
+    {
+      name: "web",
+      path: path.join(getPaths().web.base, "tsconfig.json"),
+      expectedModule: "esnext",
+      acceptable: ["esnext", "es2022"]
+    },
+    {
+      name: "scripts",
+      path: path.join(getPaths().scripts, "tsconfig.json"),
+      expectedModule: "node20",
+      acceptable: ["node20", "nodenext"]
+    }
+  ];
+  let didUpdate = false;
+  for (const target of targets) {
+    if (!fs.existsSync(target.path)) {
+      continue;
+    }
+    const tsconfigText = await fs.promises.readFile(target.path, "utf8");
+    const { config: tsconfig, error } = ts.parseConfigFileTextToJson(
+      target.path,
+      tsconfigText
+    );
+    if (error) {
+      throw new Error(
+        "Failed to parse tsconfig: " + JSON.stringify(error, null, 2)
+      );
+    }
+    if (!tsconfig?.compilerOptions || typeof tsconfig.compilerOptions.module === "undefined") {
+      continue;
+    }
+    const currentModule = typeof tsconfig.compilerOptions.module === "string" ? tsconfig.compilerOptions.module.toLowerCase() : String(tsconfig.compilerOptions.module).toLowerCase();
+    const alreadySet = target.acceptable.some((acc) => {
+      return currentModule.includes(acc);
+    });
+    if (alreadySet) {
+      continue;
+    }
+    const edits = modify(
+      tsconfigText,
+      ["compilerOptions", "module"],
+      target.expectedModule,
+      {
+        formattingOptions: { insertSpaces: true, tabSize: 2 }
+      }
+    );
+    if (edits.length === 0) {
+      const newConfig = { ...tsconfig };
+      if (!newConfig.compilerOptions) {
+        newConfig.compilerOptions = {};
+      }
+      newConfig.compilerOptions.module = target.expectedModule;
+      await fs.promises.writeFile(
+        target.path,
+        JSON.stringify(newConfig, null, 2),
+        "utf8"
+      );
+    } else {
+      const newText = applyEdits(tsconfigText, edits);
+      await fs.promises.writeFile(target.path, newText, "utf8");
+    }
+    didUpdate = true;
+  }
+  if (!didUpdate) {
     task.skip("tsconfig already up to date");
     return;
   }
-  tsconfigLines[moduleLineIndex] = moduleLine.replace(
-    /":\s*"[\w\d]+"/,
-    '": "Node20"'
-  );
-  await fs.promises.writeFile(tsconfigPath, tsconfigLines.join("\n"));
 }
 async function updateGitignore(task) {
   const gitignorePath = path.join(getPaths().base, ".gitignore");
   const gitignore = await fs.promises.readFile(gitignorePath, "utf8");
   const gitignoreLines = gitignore.split("\n");
   if (gitignoreLines.some((line) => line === "tsconfig.tsbuildinfo")) {
-    task.skip("tsconfig already up to date");
+    task.skip(".gitignore already up to date");
     return;
   }
   const yarnErrorLogLineIndex = gitignoreLines.findIndex(
@@ -57,6 +118,130 @@ async function updateGitignore(task) {
   }
   await fs.promises.writeFile(gitignorePath, gitignoreLines.join("\n"));
 }
+async function addDependencyToPackageJson(task, packageJsonPath, packageName) {
+  if (!fs.existsSync(packageJsonPath)) {
+    task.skip("package.json not found");
+    return;
+  }
+  const packageJson = JSON.parse(
+    await fs.promises.readFile(packageJsonPath, "utf8")
+  );
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  if (packageJson.dependencies[packageName]) {
+    task.skip("Dependency already exists");
+    return;
+  }
+  packageJson.dependencies[packageName] = "workspace:*";
+  await fs.promises.writeFile(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2)
+  );
+}
+function parseWorkspaceFlag(workspace) {
+  if (workspace === void 0 || workspace === null) {
+    return void 0;
+  }
+  const ws = String(workspace).trim().toLowerCase();
+  const allowed = ["none", "api", "web", "both"];
+  if (!allowed.includes(ws)) {
+    throw new Error(
+      `Invalid workspace value "${workspace}". Valid options: ${allowed.join(", ")}`
+    );
+  }
+  return ws;
+}
+function updateWorkspaceTsconfigReferences(task, folderName, targetWorkspaces) {
+  if (!targetWorkspaces || targetWorkspaces === "none") {
+    task.skip("No workspace selected");
+    return;
+  }
+  const workspaces = [];
+  const packageDir = path.join(getPaths().base, "packages", folderName);
+  if (targetWorkspaces === "api" || targetWorkspaces === "both") {
+    const tsconfigPath = path.join(getPaths().api.base, "tsconfig.json");
+    workspaces.push({ name: "api", tsconfigPath, packageDir });
+  }
+  if (targetWorkspaces === "web" || targetWorkspaces === "both") {
+    const tsconfigPath = path.join(getPaths().web.base, "tsconfig.json");
+    workspaces.push({ name: "web", tsconfigPath, packageDir });
+  }
+  if (targetWorkspaces !== "none") {
+    const tsconfigPath = path.join(getPaths().scripts, "tsconfig.json");
+    workspaces.push({ name: "scripts", tsconfigPath, packageDir });
+  }
+  if (workspaces.length === 0) {
+    task.skip("No workspace selected");
+    return;
+  }
+  const subtasks = workspaces.map((ws) => {
+    return {
+      title: `Updating ${ws.name} tsconfig references...`,
+      task: async (_ctx, subtask) => {
+        if (!fs.existsSync(ws.tsconfigPath)) {
+          subtask.skip("tsconfig.json not found");
+          return;
+        }
+        const tsconfigText = await fs.promises.readFile(ws.tsconfigPath, "utf8");
+        const { config: tsconfig, error } = ts.parseConfigFileTextToJson(
+          ws.tsconfigPath,
+          tsconfigText
+        );
+        if (error) {
+          throw new Error(
+            "Failed to parse tsconfig: " + JSON.stringify(error, null, 2)
+          );
+        }
+        const configParseResult = ts.parseJsonConfigFileContent(
+          tsconfig,
+          {
+            ...ts.sys,
+            readFile: (p) => {
+              try {
+                return fs.readFileSync(p, "utf8");
+              } catch (e) {
+                return ts.sys.readFile(p);
+              }
+            },
+            fileExists: (p) => {
+              if (typeof fs.existsSync === "function") {
+                return fs.existsSync(p);
+              }
+              return ts.sys.fileExists(p);
+            }
+          },
+          path.dirname(ws.tsconfigPath)
+        );
+        if (configParseResult.errors && configParseResult.errors.length) {
+          console.error("Parse errors:", configParseResult.errors);
+        }
+        if (!Array.isArray(tsconfig.references)) {
+          tsconfig.references = [];
+        }
+        const packageDir2 = ws.packageDir || path.join(getPaths().base, "packages", folderName);
+        const referencePath = path.relative(path.dirname(ws.tsconfigPath), packageDir2).split(path.sep).join("/");
+        const references = tsconfig.references;
+        if (references.some((ref) => ref && ref.path === referencePath)) {
+          subtask.skip("tsconfig already up to date");
+          return;
+        }
+        const newReferences = references.concat([{ path: referencePath }]);
+        let text = await fs.promises.readFile(ws.tsconfigPath, "utf8");
+        const edits = modify(text, ["references"], newReferences, {
+          formattingOptions: { insertSpaces: true, tabSize: 2 }
+        });
+        const newText = applyEdits(text, edits);
+        const formattedText = newText.replace(
+          /"references": \[\s*\{\s*"path":\s*"([^"]+)"\s*\}\s*\]/,
+          '"references": [{ "path": "' + referencePath + '" }]'
+        );
+        await fs.promises.writeFile(ws.tsconfigPath, formattedText, "utf8");
+      }
+    };
+  });
+  return new Listr(subtasks);
+}
 async function installAndBuild(folderName) {
   const packagePath = path.join("packages", folderName);
   await execa("yarn", ["install"], { stdio: "inherit", cwd: getPaths().base });
@@ -79,7 +264,7 @@ const handler = async ({ name, force, ...rest }) => {
       "https://github.com/cedarjs/cedar/releases"
     );
     console.error(
-      "This is an experimental feature. Please enable it in your redwood.toml file and then run this command again."
+      "This is an experimental feature. Please enable it in your cedar.toml (or redwood.toml) file and then run this command again."
     );
     console.error();
     console.error(`See the ${releaseNotes} for instructions on how to enable.`);
@@ -129,7 +314,36 @@ const handler = async ({ name, force, ...rest }) => {
         }
       },
       {
-        title: "Updating api side tsconfig file...",
+        title: "Choose package workspace(s)...",
+        task: async (ctx, task) => {
+          try {
+            const flagValue = parseWorkspaceFlag(rest.workspace);
+            if (flagValue !== void 0) {
+              ctx.targetWorkspaces = flagValue;
+              task.skip(
+                `Using workspace provided via --workspace: ${flagValue}`
+              );
+              return;
+            }
+          } catch (e) {
+            throw new Error(e.message);
+          }
+          const prompt = task.prompt(ListrEnquirerPromptAdapter);
+          const response = await prompt.run({
+            type: "select",
+            message: "Which workspace(s) should use this package?",
+            choices: [
+              { message: "none (I will add it manually later)", value: "none" },
+              { message: "api", value: "api" },
+              { message: "web", value: "web" },
+              { message: "both", value: "both" }
+            ]
+          });
+          ctx.targetWorkspaces = response;
+        }
+      },
+      {
+        title: "Updating tsconfig files...",
         task: (_ctx, task) => updateTsconfig(task)
       },
       {
@@ -143,6 +357,67 @@ const handler = async ({ name, force, ...rest }) => {
           return writeFilesTask(packageFiles, { overwriteExisting: force });
         }
       },
+      {
+        title: "Adding package to workspace dependencies...",
+        task: async (ctx, task) => {
+          if (!ctx.targetWorkspaces || ctx.targetWorkspaces === "none") {
+            task.skip("No workspace selected");
+            return;
+          }
+          const subtasks = [];
+          if (ctx.targetWorkspaces === "api" || ctx.targetWorkspaces === "both") {
+            subtasks.push({
+              title: "Adding to api package.json...",
+              task: async (_subCtx, subtask) => {
+                const apiPackageJsonPath = path.join(
+                  getPaths().api.base,
+                  "package.json"
+                );
+                return addDependencyToPackageJson(
+                  subtask,
+                  apiPackageJsonPath,
+                  ctx.nameVariants.packageName
+                );
+              }
+            });
+          }
+          if (ctx.targetWorkspaces === "web" || ctx.targetWorkspaces === "both") {
+            subtasks.push({
+              title: "Adding to web package.json...",
+              task: async (_subCtx, subtask) => {
+                const webPackageJsonPath = path.join(
+                  getPaths().web.base,
+                  "package.json"
+                );
+                return addDependencyToPackageJson(
+                  subtask,
+                  webPackageJsonPath,
+                  ctx.nameVariants.packageName
+                );
+              }
+            });
+          }
+          if (subtasks.length === 0) {
+            task.skip("No workspace selected");
+            return;
+          }
+          return new Listr(subtasks);
+        }
+      },
+      {
+        title: "Updating tsconfig references...",
+        task: (ctx, task) => {
+          if (!ctx.targetWorkspaces || ctx.targetWorkspaces === "none") {
+            task.skip("No workspace selected");
+            return;
+          }
+          return updateWorkspaceTsconfigReferences(
+            task,
+            ctx.nameVariants.folderName,
+            ctx.targetWorkspaces
+          );
+        }
+      },
       {
         title: "Installing and building...",
         task: (ctx) => installAndBuild(ctx.nameVariants.folderName)
@@ -174,8 +449,11 @@ const handler = async ({ name, force, ...rest }) => {
   }
 };
 export {
+  addDependencyToPackageJson,
   handler,
   nameVariants,
+  parseWorkspaceFlag,
   updateGitignore,
-  updateTsconfig
+  updateTsconfig,
+  updateWorkspaceTsconfigReferences
 };

package/dist/commands/generate/package/templates/tsconfig.json.template

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
     "composite": true,
-    "target": "ES2023",
-    "module": "Node20",
+    "target": "es2023",
+    "module": "node20",
     "esModuleInterop": true,
     "skipLibCheck": true,
     "baseUrl": ".",

package/dist/commands/generate/service/serviceHandler.js

@@ -25,7 +25,7 @@ const parseSchema = async (model) => {
   });
   return { scalarFields, relations, foreignKeys };
 };
-const scenarioFieldValue = (field) => {
+function scenarioFieldValue(field) {
   const randFloat = Math.random() * 1e7;
   const randInt = parseInt(Math.random() * 1e7);
   const randIntArray = [
@@ -48,6 +48,9 @@ const scenarioFieldValue = (field) => {
     case "Json":
       return { foo: "bar" };
     case "String":
+      if (field.name?.toLowerCase().includes("email")) {
+        return field.isUnique ? `foo${randInt}@bar.com` : "foo@bar.com";
+      }
       return field.isUnique ? `String${randInt}` : "String";
     case "Bytes":
       return `new Uint8Array([${randIntArray}])`;
@@ -57,7 +60,7 @@ const scenarioFieldValue = (field) => {
       }
     }
   }
-};
+}
 const fieldsToScenario = async (scalarFields, relations, foreignKeys) => {
   const data = {};
   scalarFields.forEach((field) => {

package/dist/commands/generate/yargsCommandHelpers.js

@@ -1,19 +1,21 @@
 import { terminalLink } from "termi-link";
 import { isTypeScriptProject } from "@cedarjs/cli-helpers";
-const getYargsDefaults = () => ({
-  force: {
-    alias: "f",
-    default: false,
-    description: "Overwrite existing files",
-    type: "boolean"
-  },
-  typescript: {
-    alias: "ts",
-    default: isTypeScriptProject(),
-    description: "Generate TypeScript files",
-    type: "boolean"
-  }
-});
+function getYargsDefaults() {
+  return {
+    force: {
+      alias: "f",
+      default: false,
+      description: "Overwrite existing files",
+      type: "boolean"
+    },
+    typescript: {
+      alias: "ts",
+      default: isTypeScriptProject(),
+      description: "Generate TypeScript files",
+      type: "boolean"
+    }
+  };
+}
 const appendPositionalsToCmd = (commandString, positionalsObj) => {
   if (Object.keys(positionalsObj).length > 0) {
     const positionalNames = Object.keys(positionalsObj).map((positionalName) => `[${positionalName}]`).join(" ");

package/dist/commands/info.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
+import path from "node:path";
 import envinfo from "envinfo";
 import { terminalLink } from "termi-link";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
-import { getPaths } from "@cedarjs/project-config";
+import { getConfigPath } from "@cedarjs/project-config";
 const command = "info";
 const description = "Print your system environment information";
 const builder = (yargs) => {
@@ -23,9 +24,11 @@ const handler = async () => {
     npmPackages: "@cedarjs/*",
     Databases: ["SQLite"]
   });
-  const redwoodToml = fs.readFileSync(getPaths().base + "/redwood.toml", "utf8");
+  const configTomlPath = getConfigPath();
+  const tomlContent = fs.readFileSync(configTomlPath, "utf8");
   console.log(
-    output + "  redwood.toml:\n" + redwoodToml.split("\n").filter((line) => line.trim().length > 0).filter((line) => !/^#/.test(line)).map((line) => `    ${line}`).join("\n")
+    output + `  ${path.basename(configTomlPath)}:
+` + tomlContent.split("\n").filter((line) => line.trim().length > 0).filter((line) => !/^#/.test(line)).map((line) => `    ${line}`).join("\n")
   );
 };
 export {

package/dist/commands/setup/deploy/helpers/index.js

@@ -1,31 +1,27 @@
 import fs from "node:fs";
-import path from "path";
+import path from "node:path";
 import execa from "execa";
 import { Listr } from "listr2";
+import { getConfigPath } from "@cedarjs/project-config";
 import { getPaths, writeFilesTask } from "../../../../lib/index.js";
-const REDWOOD_TOML_PATH = path.join(getPaths().base, "redwood.toml");
 const updateApiURLTask = (apiUrl) => {
+  const configTomlPath = getConfigPath();
+  const configFileName = path.basename(configTomlPath);
   return {
-    title: "Updating API URL in redwood.toml...",
+    title: `Updating API URL in ${configFileName}...`,
     task: () => {
-      const redwoodToml = fs.readFileSync(REDWOOD_TOML_PATH).toString();
-      let newRedwoodToml = redwoodToml;
-      if (redwoodToml.match(/apiUrl/)) {
-        newRedwoodToml = newRedwoodToml.replace(
-          /apiUrl.*/g,
-          `apiUrl = "${apiUrl}"`
-        );
-      } else if (redwoodToml.match(/\[web\]/)) {
-        newRedwoodToml = newRedwoodToml.replace(
-          /\[web\]/,
-          `[web]
-  apiUrl = "${apiUrl}"`
-        );
+      const tomlContent = fs.readFileSync(configTomlPath, "utf-8");
+      let newToml = tomlContent;
+      if (tomlContent.match(/apiUrl/)) {
+        newToml = newToml.replace(/apiUrl.*/g, `apiUrl = "${apiUrl}"`);
+      } else if (tomlContent.match(/\[web\]/)) {
+        newToml = newToml.replace(/\[web\]/, `[web]
+  apiUrl = "${apiUrl}"`);
       } else {
-        newRedwoodToml += `[web]
+        newToml += `[web]
   apiUrl = "${apiUrl}"`;
       }
-      fs.writeFileSync(REDWOOD_TOML_PATH, newRedwoodToml);
+      fs.writeFileSync(configTomlPath, newToml);
     }
   };
 };