@open-mercato/cli 0.6.3-develop.3876.1.d40fe4ec2d → 0.6.3-develop.3894.1.352abf4240

package/dist/mercato.js

@@ -16,6 +16,12 @@ import {
   resolveLazySchedulerRestart
 } from "./lib/auto-spawn-scheduler.js";
 import { startLazySchedulerSupervisor } from "./lib/scheduler-supervisor.js";
+import {
+  startInProcessGenerateWatcher
+} from "./lib/in-process-generate-watcher.js";
+import {
+  resolveGenerateWatcherMode
+} from "./lib/in-process-generate-watcher-mode.js";
 import { parseModuleInstallArgs } from "./lib/module-install-args.js";
 import { resolveNextBuildIdCandidate } from "./lib/next-build-id.js";
 import { acquireServerStartLock } from "./lib/server-start-lock.js";
@@ -414,6 +420,45 @@ async function runPostGenerateStructuralCachePurge(quiet) {
     }
   }
 }
+async function runGeneratorSuite(quiet) {
+  const { createResolver } = await import("./lib/resolver.js");
+  const {
+    generateEntityIds,
+    generateModuleRegistry,
+    generateModuleRegistryApp,
+    generateModuleRegistryCli,
+    generateModuleEntities,
+    generateModuleDi,
+    generateModulePackageSources,
+    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 });
+}
+function createGenerateWatchChecksumFn() {
+  return async () => {
+    const { createResolver } = await import("./lib/resolver.js");
+    const { calculateStructureChecksum } = await import("./lib/utils.js");
+    const resolver = createResolver();
+    const tracked = /* @__PURE__ */ new Set([
+      path.join(resolver.getAppDir(), "src", "modules.ts"),
+      path.join(resolver.getAppDir(), "src", "modules")
+    ]);
+    for (const entry of resolver.loadEnabledModules()) {
+      const roots = resolver.getModulePaths(entry);
+      tracked.add(roots.appBase);
+      tracked.add(roots.pkgBase);
+    }
+    return calculateStructureChecksum(Array.from(tracked));
+  };
+}
 async function buildAllModules() {
   const modules = getCliModules();
   let appCli = [];
@@ -1204,28 +1249,6 @@ async function run(argv = process.argv) {
       }
     ]
   });
-  const runGeneratorSuite = async (quiet) => {
-    const { createResolver } = await import("./lib/resolver.js");
-    const {
-      generateEntityIds,
-      generateModuleRegistry,
-      generateModuleRegistryApp,
-      generateModuleRegistryCli,
-      generateModuleEntities,
-      generateModuleDi,
-      generateModulePackageSources,
-      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 });
-  };
   all.push({
     id: "generate",
     cli: [
@@ -1242,70 +1265,40 @@ async function run(argv = process.argv) {
       {
         command: "watch",
         run: async (args) => {
-          const { createResolver } = await import("./lib/resolver.js");
-          const { calculateStructureChecksum } = await import("./lib/utils.js");
           const quiet = args.includes("--quiet") || args.includes("-q");
           const skipInitial = args.includes("--skip-initial");
           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;
-          let previousChecksum = "";
-          let running = false;
-          let pending = false;
-          const getTrackedPaths = () => {
-            const resolver = createResolver();
-            const tracked = /* @__PURE__ */ new Set([
-              path.join(resolver.getAppDir(), "src", "modules.ts"),
-              path.join(resolver.getAppDir(), "src", "modules")
-            ]);
-            for (const entry of resolver.loadEnabledModules()) {
-              const roots = resolver.getModulePaths(entry);
-              tracked.add(roots.appBase);
-              tracked.add(roots.pkgBase);
-            }
-            return Array.from(tracked);
-          };
-          const runWatchGeneration = async (reason) => {
-            if (running) {
-              pending = true;
-              return;
-            }
-            running = true;
-            try {
-              if (!quiet) {
-                console.log(`[generate:watch] Regenerating (${reason})...`);
-              }
+          const watcher = startInProcessGenerateWatcher({
+            pollMs: intervalMs,
+            skipInitial,
+            quiet,
+            computeStructureChecksum: createGenerateWatchChecksumFn(),
+            runGenerators: async () => {
               await runGeneratorSuite(true);
               await runPostGenerateStructuralCachePurge(true);
-              if (!quiet) {
-                console.log("[generate:watch] Generators completed.");
-              }
-            } catch (error) {
-              console.error("[generate:watch] Generation failed:", error instanceof Error ? error.message : error);
-            } finally {
-              running = false;
-              if (pending) {
-                pending = false;
-                await runWatchGeneration("queued change");
-              }
             }
+          });
+          const shutdownSignals = ["SIGINT", "SIGTERM"];
+          let shuttingDown = false;
+          const handleSignal = () => {
+            if (shuttingDown) return;
+            shuttingDown = true;
+            void watcher.close();
           };
-          if (!skipInitial) {
-            await runWatchGeneration("initial");
+          for (const signal of shutdownSignals) {
+            process.once(signal, handleSignal);
           }
-          previousChecksum = calculateStructureChecksum(getTrackedPaths());
-          if (!quiet) {
-            if (skipInitial) {
-              console.log("[generate:watch] Skipping initial regeneration and watching the current generated state.");
+          const keepAlive = setInterval(() => {
+          }, 1 << 30);
+          try {
+            await watcher.done;
+          } finally {
+            clearInterval(keepAlive);
+            for (const signal of shutdownSignals) {
+              process.removeListener(signal, handleSignal);
             }
-            console.log(`[generate:watch] Watching structural module files every ${intervalMs}ms`);
-          }
-          while (true) {
-            await new Promise((resolve) => setTimeout(resolve, intervalMs));
-            const nextChecksum = calculateStructureChecksum(getTrackedPaths());
-            if (nextChecksum === previousChecksum) continue;
-            previousChecksum = nextChecksum;
-            await runWatchGeneration("structure change");
           }
         }
       },
@@ -1400,6 +1393,8 @@ async function run(argv = process.argv) {
           let envChangePromiseResolve = null;
           let activeLazySupervisor = null;
           let activeLazySchedulerSupervisor = null;
+          let activeGenerateWatcher = null;
+          const generateWatcherMode = resolveGenerateWatcherMode(process.env);
           const envReloader = createDevEnvReloader(appDir, process.env, initialProcessEnvironmentEntries);
           function cleanup() {
             console.log("[server] Shutting down...");
@@ -1414,6 +1409,9 @@ async function run(argv = process.argv) {
             if (activeLazySchedulerSupervisor) {
               void activeLazySchedulerSupervisor.close().catch(() => void 0);
             }
+            if (activeGenerateWatcher) {
+              void activeGenerateWatcher.close().catch(() => void 0);
+            }
           }
           async function cleanupAndWait() {
             cleanup();
@@ -1439,6 +1437,13 @@ async function run(argv = process.argv) {
               }
               activeLazySchedulerSupervisor = null;
             }
+            if (activeGenerateWatcher) {
+              try {
+                await activeGenerateWatcher.close();
+              } catch {
+              }
+              activeGenerateWatcher = null;
+            }
             const lockFile = path.join(appDir, ".mercato", "next", "dev", "lock");
             try {
               fs.unlinkSync(lockFile);
@@ -1569,6 +1574,25 @@ async function run(argv = process.argv) {
                   managedExitPromises.push(waitForManagedProcessExit(schedulerProcess, "Scheduler polling engine"));
                 }
               }
+              if (generateWatcherMode === "in-process") {
+                console.log("[server] In-process generate watcher enabled \u2014 structural changes will regenerate without a sidecar process.");
+                activeGenerateWatcher = startInProcessGenerateWatcher({
+                  // `--skip-initial` equivalent: `yarn dev` always runs an
+                  // initial `mercato generate` before reaching the server
+                  // command, so the watcher must not re-run generators at
+                  // boot time. Otherwise dev startup pays a generator pass
+                  // twice in a row.
+                  skipInitial: true,
+                  quiet: false,
+                  computeStructureChecksum: createGenerateWatchChecksumFn(),
+                  runGenerators: async () => {
+                    await runGeneratorSuite(true);
+                    await runPostGenerateStructuralCachePurge(true);
+                  }
+                });
+              } else {
+                console.log("[server] Legacy out-of-process generate watcher selected via OM_DEV_GENERATE_WATCH_MODE=legacy \u2014 expect the dev orchestrator to spawn `mercato generate watch --skip-initial`.");
+              }
               const firstExit = await Promise.race(managedExitPromises);
               await cleanupAndWait();
               envChangePromiseResolve = null;