@open-mercato/cli 0.6.7-develop.6553.1.2ec7246e04 → 0.6.7-develop.6565.1.1026d85fff

package/dist/mercato.js

@@ -565,29 +565,75 @@ async function runGeneratorSuite(quiet) {
     generateOpenApi
   } = await import("./lib/generators/index.js");
   const resolver = createResolver();
-  await generateEntityIds({ resolver, quiet });
-  await generateModuleRegistry({ resolver, quiet });
-  await generateModuleRegistryApp({ resolver, quiet });
-  await generateModuleRegistryCli({ resolver, quiet });
-  await generateModuleEntities({ resolver, quiet });
-  await generateModuleDi({ resolver, quiet });
-  await generateModulePackageSources({ resolver, quiet });
-  await generateOpenApi({ resolver, quiet });
+  const results = [
+    await generateEntityIds({ resolver, quiet }),
+    await generateModuleRegistry({ resolver, quiet }),
+    await generateModuleRegistryApp({ resolver, quiet }),
+    await generateModuleRegistryCli({ resolver, quiet }),
+    await generateModuleEntities({ resolver, quiet }),
+    await generateModuleDi({ resolver, quiet }),
+    await generateModulePackageSources({ resolver, quiet }),
+    await generateOpenApi({ resolver, quiet })
+  ];
+  return results.some((result) => (result?.filesWritten.length ?? 0) > 0);
 }
-function createGenerateWatchChecksumFn() {
-  return async () => {
-    const { createResolver } = await import("./lib/resolver.js");
-    const { calculateGenerateWatchStructureChecksum } = await import("./lib/generate-watch-structure.js");
+async function runGeneratorSuiteWithStructuralInvalidation(quiet) {
+  const generatedFilesChanged = await runGeneratorSuite(quiet);
+  if (!generatedFilesChanged) {
+    if (!quiet) {
+      console.log("[generate] Generated outputs unchanged; skipping structural cache purge.");
+    }
+    return;
+  }
+  await runPostGenerateStructuralCachePurge(quiet);
+}
+async function createGenerateWatchRuntime() {
+  const [
+    { createResolver },
+    { calculateGenerateWatchStructureChecksum },
+    { createGenerateWatchChangeSignal },
+    { resolveStandaloneSourceMirrorBase }
+  ] = await Promise.all([
+    import("./lib/resolver.js"),
+    import("./lib/generate-watch-structure.js"),
+    import("./lib/generate-watch-events.js"),
+    import("./lib/generators/scanner.js")
+  ]);
+  const collectWatchState = () => {
     const resolver = createResolver();
     const moduleRoots = [];
     for (const entry of resolver.loadEnabledModules()) {
       const roots = resolver.getModulePaths(entry);
       moduleRoots.push({ appBase: roots.appBase, pkgBase: roots.pkgBase });
     }
-    return calculateGenerateWatchStructureChecksum({
-      modulesFile: path.join(resolver.getAppDir(), "src", "modules.ts"),
+    return {
+      modulesFile: resolver.getModulesConfigPath(),
       moduleRoots
-    });
+    };
+  };
+  return {
+    computeStructureChecksum: async () => {
+      return calculateGenerateWatchStructureChecksum(collectWatchState());
+    },
+    changeSignal: createGenerateWatchChangeSignal({
+      getWatchTargets: () => {
+        const state = collectWatchState();
+        const targets = [{
+          directory: path.dirname(state.modulesFile),
+          recursive: false,
+          fileName: path.basename(state.modulesFile)
+        }];
+        for (const roots of state.moduleRoots) {
+          targets.push({ directory: path.dirname(roots.appBase), recursive: true });
+          targets.push({ directory: path.dirname(roots.pkgBase), recursive: true });
+          const sourceMirror = resolveStandaloneSourceMirrorBase(roots.pkgBase);
+          if (sourceMirror) {
+            targets.push({ directory: path.dirname(sourceMirror), recursive: true });
+          }
+        }
+        return targets;
+      }
+    })
   };
 }
 async function buildAllModules() {
@@ -1425,8 +1471,7 @@ async function run(argv = process.argv) {
         run: async (args) => {
           const quiet = args.includes("--quiet") || args.includes("-q");
           console.log("Running all generators...");
-          await runGeneratorSuite(quiet);
-          await runPostGenerateStructuralCachePurge(quiet);
+          await runGeneratorSuiteWithStructuralInvalidation(quiet);
           console.log("All generators completed.");
         }
       },
@@ -1438,14 +1483,14 @@ async function run(argv = process.argv) {
           const intervalArg = args.find((arg) => arg.startsWith("--interval="));
           const parsedInterval = intervalArg ? Number.parseInt(intervalArg.split("=")[1] ?? "", 10) : NaN;
           const intervalMs = Number.isFinite(parsedInterval) && parsedInterval >= 250 ? parsedInterval : 1e3;
+          const generateWatchRuntime = await createGenerateWatchRuntime();
           const watcher = startInProcessGenerateWatcher({
             pollMs: intervalMs,
             skipInitial,
             quiet,
-            computeStructureChecksum: createGenerateWatchChecksumFn(),
+            ...generateWatchRuntime,
             runGenerators: async () => {
-              await runGeneratorSuite(true);
-              await runPostGenerateStructuralCachePurge(true);
+              await runGeneratorSuiteWithStructuralInvalidation(true);
             }
           });
           const shutdownSignals = ["SIGINT", "SIGTERM"];
@@ -1813,6 +1858,7 @@ async function run(argv = process.argv) {
               });
               if (generateWatcherMode === "in-process") {
                 console.log("[server] In-process generate watcher enabled \u2014 structural changes will regenerate without a sidecar process.");
+                const generateWatchRuntime = await createGenerateWatchRuntime();
                 activeGenerateWatcher = startInProcessGenerateWatcher({
                   // `--skip-initial` equivalent: `yarn dev` always runs an
                   // initial `mercato generate` before reaching the server
@@ -1821,10 +1867,9 @@ async function run(argv = process.argv) {
                   // twice in a row.
                   skipInitial: true,
                   quiet: false,
-                  computeStructureChecksum: createGenerateWatchChecksumFn(),
+                  ...generateWatchRuntime,
                   runGenerators: async () => {
-                    await runGeneratorSuite(true);
-                    await runPostGenerateStructuralCachePurge(true);
+                    await runGeneratorSuiteWithStructuralInvalidation(true);
                   }
                 });
               } else {