@cedarjs/cli 3.0.0-canary.13258 → 3.0.0-canary.13260

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

@@ -1,9 +1,22 @@
-import { createHandler, createBuilder } from "../yargsCommandHelpers.js";
+import {
+  createHandler,
+  createBuilder,
+  getYargsDefaults
+} from "../yargsCommandHelpers.js";
 const command = "package <name>";
 const description = "Generate a workspace Package";
 const builder = createBuilder({
   componentName: "package",
-  addStories: false
+  addStories: false,
+  optionsObj: () => ({
+    ...getYargsDefaults(),
+    workspace: {
+      alias: "w",
+      description: "Which workspace(s) should use this package? One of: 'none', 'api', 'web', 'both'. If provided, the generator will skip the interactive prompt and apply the chosen workspace.",
+      type: "string",
+      choices: ["none", "api", "web", "both"]
+    }
+  })
 });
 const handler = createHandler("package");
 export {

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";
@@ -25,6 +28,8 @@ async function updateTsconfig(task) {
       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"]
     },
     {
@@ -40,38 +45,57 @@ async function updateTsconfig(task) {
       acceptable: ["node20", "nodenext"]
     }
   ];
-  let updatedAny = false;
+  let didUpdate = false;
   for (const target of targets) {
     if (!fs.existsSync(target.path)) {
       continue;
     }
-    const tsconfig = await fs.promises.readFile(target.path, "utf8");
-    const tsconfigLines = tsconfig.split("\n");
-    const moduleLineIndex = tsconfigLines.findIndex(
-      (line) => /^\s*"module":\s*"/.test(line)
+    const tsconfigText = await fs.promises.readFile(target.path, "utf8");
+    const { config: tsconfig, error } = ts.parseConfigFileTextToJson(
+      target.path,
+      tsconfigText
     );
-    if (moduleLineIndex === -1) {
+    if (error) {
+      throw new Error(
+        "Failed to parse tsconfig: " + JSON.stringify(error, null, 2)
+      );
+    }
+    if (!tsconfig?.compilerOptions || typeof tsconfig.compilerOptions.module === "undefined") {
       continue;
     }
-    const moduleLine = tsconfigLines[moduleLineIndex];
-    const lower = moduleLine.toLowerCase();
+    const currentModule = typeof tsconfig.compilerOptions.module === "string" ? tsconfig.compilerOptions.module.toLowerCase() : String(tsconfig.compilerOptions.module).toLowerCase();
     const alreadySet = target.acceptable.some((acc) => {
-      if (lower.includes(acc)) {
-        return true;
-      }
-      return false;
+      return currentModule.includes(acc);
     });
     if (alreadySet) {
       continue;
     }
-    tsconfigLines[moduleLineIndex] = moduleLine.replace(
-      /":\s*"[\w\d]+"/,
-      `": "${target.expectedModule}"`
+    const edits = modify(
+      tsconfigText,
+      ["compilerOptions", "module"],
+      target.expectedModule,
+      {
+        formattingOptions: { insertSpaces: true, tabSize: 2 }
+      }
     );
-    await fs.promises.writeFile(target.path, tsconfigLines.join("\n"));
-    updatedAny = true;
+    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 (!updatedAny) {
+  if (!didUpdate) {
     task.skip("tsconfig already up to date");
     return;
   }
@@ -94,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 });
@@ -165,6 +313,35 @@ const handler = async ({ name, force, ...rest }) => {
           }
         }
       },
+      {
+        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)
@@ -180,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)
@@ -211,8 +449,11 @@ const handler = async ({ name, force, ...rest }) => {
   }
 };
 export {
+  addDependencyToPackageJson,
   handler,
   nameVariants,
+  parseWorkspaceFlag,
   updateGitignore,
-  updateTsconfig
+  updateTsconfig,
+  updateWorkspaceTsconfigReferences
 };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/cli",
-  "version": "3.0.0-canary.13258+84abfd3de",
+  "version": "3.0.0-canary.13260+fc8c011ea",
   "description": "The CedarJS Command Line",
   "repository": {
     "type": "git",
@@ -33,15 +33,15 @@
   "dependencies": {
     "@babel/preset-typescript": "7.28.5",
     "@babel/runtime-corejs3": "7.28.4",
-    "@cedarjs/api-server": "3.0.0-canary.13258",
-    "@cedarjs/cli-helpers": "3.0.0-canary.13258",
-    "@cedarjs/fastify-web": "3.0.0-canary.13258",
-    "@cedarjs/internal": "3.0.0-canary.13258",
-    "@cedarjs/prerender": "3.0.0-canary.13258",
-    "@cedarjs/project-config": "3.0.0-canary.13258",
-    "@cedarjs/structure": "3.0.0-canary.13258",
-    "@cedarjs/telemetry": "3.0.0-canary.13258",
-    "@cedarjs/web-server": "3.0.0-canary.13258",
+    "@cedarjs/api-server": "3.0.0-canary.13260",
+    "@cedarjs/cli-helpers": "3.0.0-canary.13260",
+    "@cedarjs/fastify-web": "3.0.0-canary.13260",
+    "@cedarjs/internal": "3.0.0-canary.13260",
+    "@cedarjs/prerender": "3.0.0-canary.13260",
+    "@cedarjs/project-config": "3.0.0-canary.13260",
+    "@cedarjs/structure": "3.0.0-canary.13260",
+    "@cedarjs/telemetry": "3.0.0-canary.13260",
+    "@cedarjs/web-server": "3.0.0-canary.13260",
     "@listr2/prompt-adapter-enquirer": "2.0.16",
     "@opentelemetry/api": "1.8.0",
     "@opentelemetry/core": "1.22.0",
@@ -68,6 +68,7 @@
     "fast-glob": "3.3.3",
     "humanize-string": "2.1.0",
     "jscodeshift": "17.0.0",
+    "jsonc-parser": "3.3.1",
     "latest-version": "9.0.0",
     "listr2": "7.0.2",
     "lodash": "4.17.21",
@@ -103,5 +104,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "84abfd3de04c3abc2a10118f2f6f5efa7444ffc8"
+  "gitHead": "fc8c011eae3a8664a56932f184759fa74b57e265"
 }