@gtkx/cli 2.0.0-beta.2 → 2.0.0-beta.4

package/src/dev/supervisor.ts

@@ -1,9 +1,9 @@
 import { error, exitCodeForSignal, info, installGracefulShutdown } from "@gtkx/utils";
 import { fork as nodeFork } from "node:child_process";
-import { type FSWatcher, watch as watchFs } from "node:fs";
-import { basename, dirname } from "node:path";
+import { type FSWatcher, statSync, watch as watchFs } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { DEV_ENTRY_ENV } from "./entry-env.js";
+import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
 
 type SupervisedChild = {
     killed: boolean;
@@ -18,25 +18,30 @@ type ForkRunner = (modulePath: string, args: string[], env: NodeJS.ProcessEnv, c
 
 type DevWatch = {
     paths: string[];
-    regenerate: () => Promise<void>;
+    resolvePaths: () => string[];
+    regenerate: () => Promise<string[]>;
 };
 
 type SupervisorState = {
     runnerPath: string;
     entryPath: string;
+    configFile: string;
     cwd: string;
     args: string[];
     watch: DevWatch | undefined;
     watchers: FSWatcher[];
+    restartTimer: DebounceTimer;
     fork: ForkRunner;
     child: SupervisedChild | null;
     isShuttingDown: boolean;
     isRestarting: boolean;
+    isRestartPending: boolean;
     capturedChildExit: number | undefined;
 };
 
 type DevSupervisorOptions = {
     entryPath: string;
+    configFile: string;
     cwd: string;
     args?: string[] | undefined;
     watch?: DevWatch | undefined;
@@ -128,7 +133,7 @@ const launch = (state: SupervisorState): void => {
     const child = state.fork(
         state.runnerPath,
         state.args,
-        { ...process.env, [DEV_ENTRY_ENV]: state.entryPath },
+        { ...process.env, [DEV_CONFIG_ENV]: state.configFile, [DEV_ENTRY_ENV]: state.entryPath },
         state.cwd,
     );
 
@@ -139,39 +144,87 @@ const launch = (state: SupervisorState): void => {
     });
 };
 
-const isRestartBlocked = (state: SupervisorState): boolean => state.isRestarting || state.isShuttingDown;
-
-const relaunchAfterExit = (state: SupervisorState): void => {
+const runPendingRestart = (state: SupervisorState): void => {
     state.isRestarting = false;
 
+    if (!state.isRestartPending || state.isShuttingDown) {
+        return;
+    }
+
+    state.isRestartPending = false;
+    void restart(state);
+};
+
+const relaunchAfterExit = (state: SupervisorState): void => {
     if (state.isShuttingDown) {
+        state.isRestarting = false;
+
         return;
     }
 
     info("Restarting dev runner...");
     launch(state);
+    runPendingRestart(state);
+};
+
+const isSupervisorShuttingDown = (state: SupervisorState): boolean => state.isShuttingDown;
+
+const reconcileConfigWatchers = (
+    state: SupervisorState,
+    paths: string[],
+    previous: ReadonlyMap<string, string | null>,
+): void => {
+    const didChange = didWatchPathsChange(previous, paths);
+
+    closeWatchers(state);
+
+    if (state.watch !== undefined) {
+        state.watch.paths = paths;
+    }
+
+    if (state.isShuttingDown) {
+        return;
+    }
+
+    installConfigWatchers(state);
+
+    if (didChange && !state.isRestartPending) {
+        scheduleRestart(state);
+    }
 };
 
 const restart = async (state: SupervisorState): Promise<void> => {
     const watch = state.watch;
 
-    if (watch === undefined || isRestartBlocked(state)) {
+    if (watch === undefined || state.isShuttingDown) {
+        return;
+    }
+
+    if (state.isRestarting) {
+        state.isRestartPending = true;
+
         return;
     }
 
     state.isRestarting = true;
-    info("gtkx.config.ts changed; regenerating bindings...");
+    info(`${basename(state.configFile)} changed; regenerating bindings...`);
+    closeWatchers(state);
+    watch.paths = watch.resolvePaths();
+    const previous = snapshotWatchPaths(watch.paths);
+    installConfigWatchers(state);
 
     try {
-        await watch.regenerate();
+        const paths = await watch.regenerate();
+        reconcileConfigWatchers(state, paths, previous);
     } catch (error_) {
+        reconcileConfigWatchers(state, watch.resolvePaths(), previous);
         error("Codegen failed; keeping the current dev runner. Fix the error and save again.", error_);
-        state.isRestarting = false;
+        runPendingRestart(state);
 
         return;
     }
 
-    if (state.isShuttingDown) {
+    if (isSupervisorShuttingDown(state)) {
         state.isRestarting = false;
 
         return;
@@ -180,8 +233,8 @@ const restart = async (state: SupervisorState): Promise<void> => {
     const current = state.child;
 
     if (current === null) {
-        state.isRestarting = false;
         launch(state);
+        runPendingRestart(state);
 
         return;
     }
@@ -193,12 +246,17 @@ const restart = async (state: SupervisorState): Promise<void> => {
     forwardSignal(current, "SIGTERM");
 };
 
-const scheduleRestart = (state: SupervisorState, timer: DebounceTimer): void => {
+const scheduleRestart = (state: SupervisorState): void => {
+    const timer = state.restartTimer;
+
     if (timer.handle !== null) {
         clearTimeout(timer.handle);
     }
 
-    timer.handle = setTimeout(() => void restart(state), CONFIG_DEBOUNCE_MS);
+    timer.handle = setTimeout(() => {
+        timer.handle = null;
+        void restart(state);
+    }, CONFIG_DEBOUNCE_MS);
 };
 
 const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: string | Buffer | null): boolean => {
@@ -209,13 +267,76 @@ const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: s
     return names.has(basename(filename.toString()));
 };
 
+const isDirectory = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+    } catch {
+        return false;
+    }
+};
+
+const nearestWatchTarget = (path: string): { directory: string; name: string } => {
+    let directory = dirname(path);
+    let name = basename(path);
+
+    while (!isDirectory(directory)) {
+        const parent = dirname(directory);
+
+        if (parent === directory) {
+            break;
+        }
+
+        name = basename(directory);
+        directory = parent;
+    }
+
+    return { directory, name };
+};
+
+const watchTargets = (paths: string[]): Set<string> =>
+    new Set(paths.flatMap((path) => {
+        const { directory, name } = nearestWatchTarget(path);
+
+        return [path, join(directory, name)];
+    }));
+
+const watchPathState = (path: string): string | null => {
+    try {
+        const stat = statSync(path, { bigint: true, throwIfNoEntry: false });
+
+        return stat === undefined
+            ? null
+            : [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+    } catch {
+        return null;
+    }
+};
+
+const snapshotWatchPaths = (paths: string[]): Map<string, string | null> =>
+    new Map([...watchTargets(paths)].map((path) => [path, watchPathState(path)]));
+
+const didWatchPathsChange = (
+    previous: ReadonlyMap<string, string | null>,
+    paths: string[],
+): boolean => {
+    for (const path of watchTargets(paths)) {
+        const current = watchPathState(path);
+
+        if (previous.has(path) ? previous.get(path) !== current : current !== null) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
 const groupWatchNamesByDirectory = (paths: string[]): Map<string, Set<string>> => {
     const namesByDirectory: Map<string, Set<string>> = new Map();
 
     for (const path of paths) {
-        const directory = dirname(path);
+        const { directory, name } = nearestWatchTarget(path);
         const names = namesByDirectory.get(directory) ?? new Set<string>();
-        names.add(basename(path));
+        names.add(name);
         namesByDirectory.set(directory, names);
     }
 
@@ -226,16 +347,21 @@ const watchConfigDirectory = (
     state: SupervisorState,
     directory: string,
     names: Set<string>,
-    timer: DebounceTimer,
 ): void => {
-    const watcher = watchFs(directory, (_event, filename) => {
-        if (isWatchedChange(state, names, filename)) {
-            scheduleRestart(state, timer);
-        }
-    });
+    try {
+        const watcher = watchFs(directory, (_event, filename) => {
+            if (isWatchedChange(state, names, filename)) {
+                scheduleRestart(state);
+            }
+        });
 
-    watcher.on("error", (): void => undefined);
-    state.watchers.push(watcher);
+        watcher.on("error", (cause) => {
+            error(`Configuration watch failed for ${directory}`, cause);
+        });
+        state.watchers.push(watcher);
+    } catch (error_) {
+        error(`Configuration watch failed for ${directory}`, error_);
+    }
 };
 
 const installConfigWatchers = (state: SupervisorState): void => {
@@ -245,10 +371,8 @@ const installConfigWatchers = (state: SupervisorState): void => {
         return;
     }
 
-    const timer: DebounceTimer = { handle: null };
-
     for (const [directory, names] of groupWatchNamesByDirectory(watch.paths)) {
-        watchConfigDirectory(state, directory, names, timer);
+        watchConfigDirectory(state, directory, names);
     }
 };
 
@@ -256,6 +380,8 @@ const closeWatchers = (state: SupervisorState): void => {
     for (const watcher of state.watchers) {
         watcher.close();
     }
+
+    state.watchers = [];
 };
 
 const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promise<void> =>
@@ -263,6 +389,11 @@ const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promi
         state.isShuttingDown = true;
         closeWatchers(state);
 
+        if (state.restartTimer.handle !== null) {
+            clearTimeout(state.restartTimer.handle);
+            state.restartTimer.handle = null;
+        }
+
         if (!state.child) {
             resolve();
 
@@ -286,19 +417,22 @@ const installShutdown = (state: SupervisorState): void => {
 };
 
 const runDevSupervisor = async (options: DevSupervisorOptions): Promise<never> => {
-    const { entryPath, cwd, args = [], watch, fork = defaultForkRunner } = options;
+    const { entryPath, configFile, cwd, args = [], watch, fork = defaultForkRunner } = options;
 
     const state: SupervisorState = {
         runnerPath: fileURLToPath(DEV_RUNNER_URL),
         entryPath,
+        configFile,
         cwd,
         args,
         watch,
         watchers: [],
+        restartTimer: { handle: null },
         fork,
         child: null,
         isShuttingDown: false,
         isRestarting: false,
+        isRestartPending: false,
         capturedChildExit: undefined,
     };
 

package/src/i18n/catalogs.ts

@@ -133,6 +133,7 @@ const initializeCatalog = (catalog: Catalog, template: string, output: string):
             `--input=${template}`,
             `--output-file=${output}`,
         ],
+        options: { stdio: "pipe" },
         target: catalog.path,
     });
 };