@gtkx/cli 2.0.0-beta.1 → 2.0.0-beta.10

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, relative } 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,31 @@ 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[];
+    changedPaths: Set<string>;
+    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 +134,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 +145,94 @@ 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 changed = changedWatchPaths(previous, paths);
+
+    closeWatchers(state);
+
+    if (state.watch !== undefined) {
+        state.watch.paths = paths;
+    }
+
+    if (state.isShuttingDown) {
+        return;
+    }
+
+    installConfigWatchers(state);
+
+    if (changed.length > 0 && !state.isRestartPending) {
+        scheduleRestart(state, changed);
+    }
+};
+
+const consumeChangedPaths = (state: SupervisorState): string => {
+    const changed = [...state.changedPaths].map((path) => relative(state.cwd, path));
+    state.changedPaths.clear();
+
+    return changed.length === 0 ? basename(state.configFile) : changed.join(", ");
 };
 
 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(`${consumeChangedPaths(state)} 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 +241,8 @@ const restart = async (state: SupervisorState): Promise<void> => {
     const current = state.child;
 
     if (current === null) {
-        state.isRestarting = false;
         launch(state);
+        runPendingRestart(state);
 
         return;
     }
@@ -193,29 +254,103 @@ const restart = async (state: SupervisorState): Promise<void> => {
     forwardSignal(current, "SIGTERM");
 };
 
-const scheduleRestart = (state: SupervisorState, timer: DebounceTimer): void => {
+const scheduleRestart = (state: SupervisorState, changedPaths: string[] = []): void => {
+    const timer = state.restartTimer;
+
+    for (const path of changedPaths) {
+        state.changedPaths.add(path);
+    }
+
     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 => {
+const watchedChangePath = (
+    state: SupervisorState,
+    directory: string,
+    names: Set<string>,
+    filename: string | Buffer | null,
+): string | undefined => {
     if (filename === null || state.isShuttingDown) {
+        return undefined;
+    }
+
+    const name = basename(filename.toString());
+
+    return names.has(name) ? join(directory, name) : undefined;
+};
+
+const isDirectory = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+    } catch {
         return false;
     }
+};
 
-    return names.has(basename(filename.toString()));
+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 changedWatchPaths = (
+    previous: ReadonlyMap<string, string | null>,
+    paths: string[],
+): string[] =>
+    [...watchTargets(paths)].filter((path) => {
+        const current = watchPathState(path);
+
+        return previous.has(path) ? previous.get(path) !== current : current !== null;
+    });
+
 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 +361,23 @@ 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) => {
+            const changed = watchedChangePath(state, directory, names, filename);
+
+            if (changed !== undefined) {
+                scheduleRestart(state, [changed]);
+            }
+        });
 
-    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 +387,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 +396,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 +405,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 +433,23 @@ 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: [],
+        changedPaths: new Set(),
+        restartTimer: { handle: null },
         fork,
         child: null,
         isShuttingDown: false,
         isRestarting: false,
+        isRestartPending: false,
         capturedChildExit: undefined,
     };
 

package/src/dev/vite-dev-server.ts

@@ -1,5 +1,7 @@
 import type { InlineConfig, Plugin } from "vite";
+import { warn } from "@gtkx/utils";
 import { join } from "node:path";
+import { createWatchIgnore } from "./watch-ignore.js";
 
 type DevServerModule = object;
 type DevServerWatchEvent = "add" | "change" | "unlink";
@@ -59,13 +61,29 @@ const isServerConfigFile = (config: DevServerConfig, changedPath: string): boole
     return envFilesForMode(config).includes(changedPath);
 };
 
-const createDevServerConfig = (root: string, plugins: Plugin[]): InlineConfig => ({
+const watchErrorPlugin = (): Plugin => ({
+    name: "gtkx:watch-errors",
+    enforce: "pre",
+
+    configureServer(server) {
+        server.watcher.on("error", (cause) => {
+            warn("File watch error; the dev server keeps watching.", cause);
+        });
+    },
+});
+
+const createDevServerConfig = (
+    root: string,
+    deployOutDir: string | undefined,
+    plugins: Plugin[],
+): InlineConfig => ({
     root,
     appType: "custom",
-    plugins,
+    plugins: [watchErrorPlugin(), ...plugins],
     server: {
         middlewareMode: true,
         watch: {
+            ignored: createWatchIgnore(root, deployOutDir),
             awaitWriteFinish: {
                 stabilityThreshold: WRITE_STABILITY_THRESHOLD_MS,
                 pollInterval: WRITE_POLL_INTERVAL_MS,

package/src/dev/watch-ignore.ts

@@ -0,0 +1,16 @@
+import { isPathInside, isPathWithin } from "@gtkx/utils";
+import { resolve } from "node:path";
+import { deployOutDirFor } from "../internal/deploy-out-dir.js";
+
+const REFERENCE_DIR = ".gtkx";
+
+const createWatchIgnore = (root: string, deployOutDir: string | undefined): ((path: string) => boolean) => {
+    const projectRoot = resolve(root);
+    const generated = [deployOutDirFor(projectRoot, deployOutDir), resolve(projectRoot, REFERENCE_DIR)].filter(
+        (directory) => isPathInside(projectRoot, directory),
+    );
+
+    return (path) => generated.some((directory) => isPathWithin(directory, resolve(path)));
+};
+
+export { createWatchIgnore };

package/src/i18n/catalogs.ts

@@ -28,11 +28,17 @@ type CatalogProject = {
 };
 
 type PreparedCatalog = {
+    content: Buffer;
     isChanged: boolean;
     output: string;
     target: string;
 };
 
+type WrittenCatalog = {
+    content: Buffer;
+    path: string;
+};
+
 const PO_DIRNAME = "po";
 const LOCALE_DIRNAME = "locale";
 const LINGUAS_FILENAME = "LINGUAS";
@@ -133,6 +139,7 @@ const initializeCatalog = (catalog: Catalog, template: string, output: string):
             `--input=${template}`,
             `--output-file=${output}`,
         ],
+        options: { stdio: "pipe" },
         target: catalog.path,
     });
 };
@@ -164,16 +171,25 @@ const prepareCatalog = (
         initializeCatalog(catalog, template, output);
     }
 
+    const content = readFileSync(output);
+
     return {
-        isChanged: !isExisting || !readFileSync(output).equals(readFileSync(catalog.path)),
+        content,
+        isChanged: !isExisting || !content.equals(readFileSync(catalog.path)),
         output,
         target: catalog.path,
     };
 };
 
-const synchronizeCatalogs = (project: CatalogProject): void => {
+const replaceCatalog = (catalog: PreparedCatalog): WrittenCatalog => {
+    renameSync(catalog.output, catalog.target);
+
+    return { content: catalog.content, path: catalog.target };
+};
+
+const synchronizeCatalogs = (project: CatalogProject): WrittenCatalog[] => {
     if (project.catalogs.length === 0) {
-        return;
+        return [];
     }
 
     const template = join(project.poDir, `${project.domain}.pot`);
@@ -184,11 +200,7 @@ const synchronizeCatalogs = (project: CatalogProject): void => {
         const merged = project.catalogs.map((catalog, index) =>
             prepareCatalog(catalog, index, template, stagingDir));
 
-        for (const catalog of merged) {
-            if (catalog.isChanged) {
-                renameSync(catalog.output, catalog.target);
-            }
-        }
+        return merged.filter((catalog) => catalog.isChanged).map((catalog) => replaceCatalog(catalog));
     } finally {
         rmSync(stagingDir, { recursive: true, force: true });
     }
@@ -214,4 +226,5 @@ export {
     requiresCatalogInitialization,
     resolveCatalogProject,
     synchronizeCatalogs,
+    type WrittenCatalog,
 };