@mnci/cli 4.17.5 → 4.18.0

package/dist/cli.js

@@ -2971,13 +2971,47 @@ function isNxGoPluginRegistered(workspaceRoot) {
   }
   return (readJson(nxJsonPath).plugins ?? []).some((entry) => (typeof entry === "string" ? entry : entry.plugin) === NX_GO_PLUGIN);
 }
+function modulePrefixFromRemoteUrl(url) {
+  const trimmed = url.trim();
+  const scpLike = /^[^@/]+@([^:]+):(.+)$/.exec(trimmed);
+  const withScheme = /^[a-z][\w+.-]*:\/\/(?:[^@/]+@)?(.+)$/i.exec(trimmed);
+  let path;
+  if (scpLike) {
+    path = `${scpLike[1]}/${scpLike[2]}`;
+  } else if (withScheme) {
+    path = withScheme[1];
+  }
+  if (path === void 0) {
+    return void 0;
+  }
+  const cleaned = path.replace(/\.git$/, "").replace(/\/+$/, "");
+  return cleaned === "" ? void 0 : cleaned;
+}
+function goModulePrefix(workspaceRoot) {
+  const result = runCapture("git", ["remote", "get-url", "origin"], workspaceRoot);
+  return result.status === 0 ? modulePrefixFromRemoteUrl(result.stdout) : void 0;
+}
 function registerNxGoPlugin(workspaceRoot) {
   const nxJsonPath = (0, import_node_path7.join)(workspaceRoot, "nx.json");
-  if (!fileExists(nxJsonPath) || isNxGoPluginRegistered(workspaceRoot)) {
+  if (!fileExists(nxJsonPath)) {
     return false;
   }
+  const modulePrefix = goModulePrefix(workspaceRoot);
+  const entry = modulePrefix === void 0 ? NX_GO_PLUGIN : { plugin: NX_GO_PLUGIN, options: { modulePrefix } };
   const nxJson = readJson(nxJsonPath);
-  writeFileEnsured(nxJsonPath, toJson({ ...nxJson, plugins: [...nxJson.plugins ?? [], NX_GO_PLUGIN] }));
+  const plugins = [...nxJson.plugins ?? []];
+  const index = plugins.findIndex((plugin) => (typeof plugin === "string" ? plugin : plugin.plugin) === NX_GO_PLUGIN);
+  if (index === -1) {
+    plugins.push(entry);
+  } else {
+    const current = plugins[index];
+    const currentPrefix = typeof current === "string" ? void 0 : current.options?.modulePrefix;
+    if (modulePrefix === void 0 || currentPrefix === modulePrefix) {
+      return false;
+    }
+    plugins[index] = entry;
+  }
+  writeFileEnsured(nxJsonPath, toJson({ ...nxJson, plugins }));
   return true;
 }
 
@@ -3322,21 +3356,36 @@ function ensureNxGoPlugin(workspaceRoot) {
   }
 }
 function ensureGoModule(workspaceRoot) {
-  if (fileExists((0, import_node_path10.join)(workspaceRoot, "go.mod"))) {
+  if (fileExists((0, import_node_path10.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path10.join)(workspaceRoot, "go.mod"))) {
     return;
   }
-  logger.step("Bootstrapping the workspace Go module (single root go.mod)");
+  logger.step("Bootstrapping the Go workspace (go.work, one module per project)");
   runNx(["g", "@nx-go/nx-go:init", "--no-interactive"], workspaceRoot);
-  runNx(["g", "@nx-go/nx-go:convert-to-one-mod", "--no-interactive"], workspaceRoot);
 }
-function goModulePath(workspaceRoot) {
+function readGoModModule(goModPath) {
   try {
-    const contents = (0, import_node_fs9.readFileSync)((0, import_node_path10.join)(workspaceRoot, "go.mod"), "utf8");
-    return /^module\s+(\S+)/m.exec(contents)?.[1];
+    return /^module\s+(\S+)/m.exec((0, import_node_fs9.readFileSync)(goModPath, "utf8"))?.[1];
   } catch {
     return void 0;
   }
 }
+function goModulePathFor(workspaceRoot, projectDir) {
+  const projectModule = readGoModModule((0, import_node_path10.join)(workspaceRoot, projectDir, "go.mod"));
+  if (projectModule !== void 0) {
+    return projectModule;
+  }
+  const rootModule = readGoModModule((0, import_node_path10.join)(workspaceRoot, "go.mod"));
+  return rootModule === void 0 ? void 0 : `${rootModule}/${projectDir}`;
+}
+function setGoModulePath(workspaceRoot, projectDir) {
+  const prefix = goModulePrefix(workspaceRoot);
+  const goModPath = (0, import_node_path10.join)(workspaceRoot, projectDir, "go.mod");
+  if (prefix === void 0 || !fileExists(goModPath)) {
+    return;
+  }
+  const rewritten = (0, import_node_fs9.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
+  writeFileEnsured(goModPath, rewritten);
+}
 function goTestTarget() {
   return { executor: "@nx-go/nx-go:test" };
 }
@@ -3533,6 +3582,7 @@ function addGoApp(workspaceRoot, name, options = {}) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `apps/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
@@ -3571,6 +3621,7 @@ function addGoFunctionApp(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `apps/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "apps", name, "project.json"), {
     "build": goBuildTarget(name),
     "test": goTestTarget(),
@@ -3594,15 +3645,16 @@ function addGoLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `packages/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "packages", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
   const slice = reshapeGoLibraryScaffold((0, import_node_path10.join)(workspaceRoot, "packages", name), name);
   registerProjectCommands(workspaceRoot, name, { build: false });
-  const module2 = goModulePath(workspaceRoot);
+  const module2 = goModulePathFor(workspaceRoot, `packages/${name}`);
   if (module2) {
-    logger.step(`Import its starter slice as ${module2}/packages/${name}/${slice}`);
+    logger.step(`Import its starter slice as ${module2}/${slice}`);
   }
 }
 function addGoInternalLib(workspaceRoot, name) {
@@ -3618,15 +3670,16 @@ function addGoInternalLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  setGoModulePath(workspaceRoot, `libs/${name}`);
   addProjectJsonTargets((0, import_node_path10.join)(workspaceRoot, "libs", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
   const slice = reshapeGoLibraryScaffold((0, import_node_path10.join)(workspaceRoot, "libs", name), name);
   registerProjectCommands(workspaceRoot, name, { build: false });
-  const module2 = goModulePath(workspaceRoot);
+  const module2 = goModulePathFor(workspaceRoot, `libs/${name}`);
   if (module2) {
-    logger.step(`Import its starter slice as ${module2}/libs/${name}/${slice}`);
+    logger.step(`Import its starter slice as ${module2}/${slice}`);
   }
 }
 
@@ -6459,6 +6512,23 @@ function checkGoPluginRegistered(workspaceRoot) {
     remedy: "run `mnci upgrade`"
   };
 }
+function checkGoWorkInSync(workspaceRoot) {
+  const goWorkPath = (0, import_node_path24.join)(workspaceRoot, "go.work");
+  if (!fileExists(goWorkPath)) {
+    return void 0;
+  }
+  const contents = (0, import_node_fs17.existsSync)(goWorkPath) ? (0, import_node_fs17.readFileSync)(goWorkPath, "utf8") : "";
+  const blockEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+\(([^)]*)\)/g), (match) => match[1].split("\n")).flat();
+  const singleEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+(\.\S+)/g), (match) => match[1]);
+  const uses = [...blockEntries, ...singleEntries].map((entry) => entry.trim()).filter(Boolean);
+  const stale = uses.filter((entry) => !(0, import_node_fs17.existsSync)((0, import_node_path24.join)(workspaceRoot, entry, "go.mod")));
+  return {
+    check: "every go.work `use` entry points to a module that still exists",
+    ok: stale.length === 0,
+    detail: `go.work lists ${stale.join(", ")} but there is no go.mod there \u2014 \`go list -m\` fails, which breaks the whole Nx project graph`,
+    remedy: "drop the stale `use` line(s) from go.work (mnci owns the file; a removed Go project should have its entry removed)"
+  };
+}
 function checkNativeApps(workspaceRoot) {
   if (!hasNativeGoApp(workspaceRoot)) {
     return [];
@@ -6584,6 +6654,7 @@ function collectFindings(workspaceRoot) {
     ...checkTargetFilesExist(workspaceRoot),
     checkSync(workspaceRoot),
     checkGoPluginRegistered(workspaceRoot),
+    checkGoWorkInSync(workspaceRoot),
     ...checkNativeApps(workspaceRoot)
   ].filter((finding) => finding !== void 0);
 }