watch: only watch the parent directory where entries are reported

Signed-off-by: marcopiraccini <marco.piraccini@gmail.com>

Author: marcopiraccini

lib/internal/watch_mode/files_watcher.js

@@ -25,6 +25,9 @@ const { setTimeout, clearTimeout } = require('timers');
 const supportsRecursiveWatching = process.platform === 'win32' ||
   process.platform === 'darwin';
 
+const supportsDirectoryWatching = supportsRecursiveWatching ||
+  process.platform === 'linux';
+
 const isParentPath = (parentCandidate, childCandidate) => {
   const parent = resolve(parentCandidate);
   const child = resolve(childCandidate);
@@ -114,15 +117,15 @@ class FilesWatcher extends EventEmitter {
     if (this.#isPathWatched(path)) {
       return;
     }
-    const { allowMissing = false } = options;
+    // `watchEntries` tells that `path` is a directory whose entries are
+    // reported by name, as opposed to a single watched file.
+    const { allowMissing = false, watchEntries = recursive } = options;
 
     const watcher = watch(path, { recursive, signal: this.#signal, throwIfNoEntry: !allowMissing });
     watcher.on('change', (eventType, fileName) => {
       // `fileName` can be `null` if it cannot be determined. See
       // https://github.com/nodejs/node/pull/49891#issuecomment-1744673430.
-      // `path` is the watched directory (see `filterFile`), so resolve the
-      // changed entry against it to get the absolute path of the trigger.
-      this.#onChange(resolve(path, fileName ?? ''), eventType);
+      this.#onChange(watchEntries ? resolve(path, fileName ?? '') : path, eventType);
     });
     this.#watchers.set(path, { handle: watcher, recursive });
     if (recursive) {
@@ -134,14 +137,16 @@ class FilesWatcher extends EventEmitter {
     if (!file) return;
     if (supportsRecursiveWatching) {
       this.watchPath(dirname(file), true, options);
-    } else {
+    } else if (supportsDirectoryWatching) {
       // Watch the parent directory non-recursively rather than the file
       // itself. A watch bound to the file's inode stops receiving events once
       // the file is replaced via unlink+create or rename (atomic saves, Docker
       // Compose watch, ...), so only the first replacement would be detected.
       // Watching the directory keeps working across replacements, and unrelated
       // siblings are discarded by the `filter` mode check in `#onChange`.
-      this.watchPath(dirname(file), false, options);
+      this.watchPath(dirname(file), false, { __proto__: null, ...options, watchEntries: true });
+    } else {
+      this.watchPath(file, false, options);
     }
     this.#filteredFiles.add(file);
     if (owner) {

test/parallel/test-watch-mode-files_watcher.mjs

@@ -17,6 +17,9 @@ if (common.isIBMi)
   common.skip('IBMi does not support `fs.watch()`');
 
 const supportsRecursiveWatching = common.isMacOS || common.isWindows;
+// Elsewhere a directory watch does not report changes to its entries by name,
+// so the files are watched directly.
+const watchesParentDirectory = supportsRecursiveWatching || common.isLinux;
 
 const { FilesWatcher } = watcher;
 tmpdir.refresh();
@@ -65,7 +68,7 @@ describe('watch mode file watcher', () => {
     assert.strictEqual(changesCount, 1);
   });
 
-  it('should keep detecting files replaced via unlink and create', async () => {
+  it('should keep detecting files replaced via unlink and create', { skip: !watchesParentDirectory }, async () => {
     // Regression test for https://github.com/nodejs/node/issues/51621: a watch
     // bound to the file inode stops firing after the first replacement, so the
     // second `replaceAndWaitForChanges` call would hang on the buggy behavior.
@@ -230,9 +233,12 @@ describe('watch mode file watcher', () => {
     const child = spawn(process.execPath, [file], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'], encoding: 'utf8' });
     watcher.watchChildProcessModules(child);
     await once(child, 'exit');
-    // The parent directory is watched on every platform so that files replaced
-    // via unlink+create or rename are still detected.
-    const expected = [file, tmpdir.resolve('file')].map((file) => path.dirname(file));
+    let expected = [file, tmpdir.resolve('file')];
+    if (watchesParentDirectory) {
+      // The parent directory is watched so that files replaced via
+      // unlink+create or rename are still detected.
+      expected = expected.map((file) => path.dirname(file));
+    }
     assert.deepStrictEqual(watcher.watchedPaths, expected);
   });
 });