watch: fix --env-file-if-exists crashing on linux if the file is missing

PR-URL: #61870
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>

Author: efekrskl

doc/api/fs.md

@@ -4784,6 +4784,9 @@ The `atime` and `mtime` arguments follow these rules:
 <!-- YAML
 added: v0.5.10
 changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/61870
+ description: Added `throwIfNoEntry` option.
  - version: v19.1.0
  pr-url: https://github.com/nodejs/node/pull/45098
  description: Added recursive support for Linux, AIX and IBMi.
@@ -4812,6 +4815,8 @@ changes:
  * `encoding` {string} Specifies the character encoding to be used for the
  filename passed to the listener. **Default:** `'utf8'`.
  * `signal` {AbortSignal} allows closing the watcher with an AbortSignal.
+ * `throwIfNoEntry` {boolean} Indicates whether an exception should be thrown when the
+ path does not exist. **Default:** `true`.
  * `ignore` {string|RegExp|Function|Array} Pattern(s) to ignore. Strings are
  glob patterns (using [`minimatch`][]), RegExp patterns are tested against
  the filename, and functions receive the filename and return `true` to

lib/fs.js

@@ -2512,6 +2512,7 @@ function appendFileSync(path, data, options) {
  * recursive?: boolean;
  * encoding?: string;
  * signal?: AbortSignal;
+ * throwIfNoEntry?: boolean;
  * }} [options]
  * @param {(
  * eventType?: string,
@@ -2530,6 +2531,7 @@ function watch(filename, options, listener) {
 
 if(options.persistent===undefined)options.persistent=true;
 if(options.recursive===undefined)options.recursive=false;
+if(options.throwIfNoEntry===undefined)options.throwIfNoEntry=true;
 
 letwatcher;
 constwatchers=require('internal/fs/watchers');
@@ -2547,7 +2549,8 @@ function watch(filename, options, listener) {
 options.persistent,
 options.recursive,
 options.encoding,
-options.ignore);
+options.ignore,
+options.throwIfNoEntry);
 }
 
 if(listener){

lib/internal/fs/recursive_watch.js

@@ -52,6 +52,7 @@ class FSWatcher extends EventEmitter {
 assert(typeofoptions==='object');
 
 const{ persistent, recursive, signal, encoding, ignore }=options;
+let{ throwIfNoEntry }=options;
 
 // TODO(anonrig): Add non-recursive support to non-native-watcher for IBMi & AIX support.
 if(recursive!=null){
@@ -66,6 +67,12 @@ class FSWatcher extends EventEmitter {
 validateAbortSignal(signal,'options.signal');
 }
 
+if(throwIfNoEntry!=null){
+validateBoolean(throwIfNoEntry,'options.throwIfNoEntry');
+}else{
+throwIfNoEntry=true;
+}
+
 if(encoding!=null){
 // This is required since on macOS and Windows it throws ERR_INVALID_ARG_VALUE
 if(typeofencoding!=='string'){
@@ -76,7 +83,7 @@ class FSWatcher extends EventEmitter {
 validateIgnoreOption(ignore,'options.ignore');
 this.#ignoreMatcher =createIgnoreMatcher(ignore);
 
-this.#options ={ persistent, recursive, signal, encoding };
+this.#options ={ persistent, recursive, signal, encoding, throwIfNoEntry};
 }
 
 close(){
@@ -222,7 +229,7 @@ class FSWatcher extends EventEmitter {
 this.#watchFolder(filename);
 }
 }catch(error){
-if(error.code==='ENOENT'){
+if(!this.#options.throwIfNoEntry&&error.code==='ENOENT'){
 error.filename=filename;
 throwerror;
 }

lib/internal/fs/watchers.js

@@ -35,7 +35,7 @@ const {
 }=internalBinding('fs');
 
 const{ FSEvent }=internalBinding('fs_event_wrap');
-const{UV_ENOSPC}=internalBinding('uv');
+const{UV_ENOSPC,UV_ENOENT}=internalBinding('uv');
 const{ EventEmitter }=require('events');
 
 const{
@@ -293,7 +293,8 @@ FSWatcher.prototype[kFSWatchStart] = function(filename,
 persistent,
 recursive,
 encoding,
-ignore){
+ignore,
+throwIfNoEntry=true){
 if(this._handle===null){// closed
 return;
 }
@@ -313,6 +314,10 @@ FSWatcher.prototype[kFSWatchStart] = function(filename,
 recursive,
 encoding);
 if(err){
+if(!throwIfNoEntry&&err===UV_ENOENT){
+return;
+}
+
 consterror=newUVException({
 errno: err,
 syscall: 'watch',

lib/internal/main/watch_mode.js

@@ -34,10 +34,8 @@ markBootstrapComplete();
 
 constkKillSignal=convertToValidSignal(getOptionValue('--watch-kill-signal'));
 constkShouldFilterModules=getOptionValue('--watch-path').length===0;
-constkEnvFiles=[
- ...getOptionValue('--env-file'),
- ...getOptionValue('--env-file-if-exists'),
-];
+constkEnvFiles=getOptionValue('--env-file');
+constkOptionalEnvFiles=getOptionValue('--env-file-if-exists');
 constkWatchedPaths=ArrayPrototypeMap(getOptionValue('--watch-path'),(path)=>resolve(path));
 constkPreserveOutput=getOptionValue('--watch-preserve-output');
 constkCommand=ArrayPrototypeSlice(process.argv,1);
@@ -105,6 +103,10 @@ function start() {
 if(kEnvFiles.length>0){
 ArrayPrototypeForEach(kEnvFiles,(file)=>watcher.filterFile(resolve(file)));
 }
+if(kOptionalEnvFiles.length>0){
+ArrayPrototypeForEach(kOptionalEnvFiles,
+(file)=>watcher.filterFile(resolve(file),undefined,{allowMissing: true}));
+}
 child.once('exit',(code)=>{
 exited=true;
 constwaitingForChanges='Waiting for file changes before restarting...';
@@ -160,6 +162,7 @@ async function stop(child) {
 }
 
 letrestarting=false;
+
 asyncfunctionrestart(child){
 if(restarting)return;
 restarting=true;
@@ -198,5 +201,6 @@ function signalHandler(signal) {
 process.exit(exitCode??kNoFailure);
 };
 }
+
 process.on('SIGTERM',signalHandler('SIGTERM'));
 process.on('SIGINT',signalHandler('SIGINT'));

lib/internal/watch_mode/files_watcher.js

@@ -110,11 +110,13 @@ class FilesWatcher extends EventEmitter {
 return[...this.#watchers.keys()];
 }
 
-watchPath(path,recursive=true){
+watchPath(path,recursive=true,options=kEmptyObject){
 if(this.#isPathWatched(path)){
 return;
 }
-constwatcher=watch(path,{ recursive,signal: this.#signal });
+const{ allowMissing =false}=options;
+
+constwatcher=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.
@@ -126,14 +128,14 @@ class FilesWatcher extends EventEmitter {
 }
 }
 
-filterFile(file,owner){
+filterFile(file,owner,options=kEmptyObject){
 if(!file)return;
 if(supportsRecursiveWatching){
-this.watchPath(dirname(file));
+this.watchPath(dirname(file),true,options);
 }else{
 // Having multiple FSWatcher's seems to be slower
 // than a single recursive FSWatcher
-this.watchPath(file,false);
+this.watchPath(file,false,options);
 }
 this.#filteredFiles.add(file);
 if(owner){

test/parallel/test-fs-watch-enoent.js

@@ -43,6 +43,29 @@ tmpdir.refresh();
 );
 }
 
+{
+assert.throws(
+()=>fs.watch(nonexistentFile,{throwIfNoEntry: true},common.mustNotCall()),
+{
+path: nonexistentFile,
+filename: nonexistentFile,
+code: /^(ENOENT|ENODEV)$/,
+},
+);
+}
+
+{
+if(common.isAIX){
+assert.throws(
+()=>fs.watch(nonexistentFile,{throwIfNoEntry: false},common.mustNotCall()),
+{code: 'ENODEV'},
+);
+}else{
+constwatcher=fs.watch(nonexistentFile,{throwIfNoEntry: false},common.mustNotCall());
+watcher.close();
+}
+}
+
 {
 if(common.isMacOS||common.isWindows){
 constfile=tmpdir.resolve('file-to-watch');

test/sequential/test-watch-mode.mjs

@@ -277,6 +277,27 @@ describe('watch mode', { concurrency: !process.env.TEST_PARALLEL, timeout: 60_00
 }
 });
 
+it('should not crash when --env-file-if-exists points to a missing file',async()=>{
+constenvKey=`TEST_ENV_${Date.now()}`;
+constjsFile=createTmpFile(`console.log('ENV: ' + process.env.${envKey});`);
+constmissingEnvFile=path.join(tmpdir.path,`missing-${Date.now()}.env`);
+const{ done, restart }=runInBackground({
+args: ['--watch-path',tmpdir.path,`--env-file-if-exists=${missingEnvFile}`,jsFile],
+});
+
+try{
+const{ stderr, stdout }=awaitrestart();
+
+assert.doesNotMatch(stderr,/ENOENT:nosuchfileordirectory,watch/);
+assert.deepStrictEqual(stdout,[
+'ENV: undefined',
+`Completed running ${inspect(jsFile)}. Waiting for file changes before restarting...`,
+]);
+}finally{
+awaitdone();
+}
+});
+
 it('should watch changes to a failing file',async()=>{
 constfile=createTmpFile('throw new Error("fails");');
 const{ stderr, stdout }=awaitrunWriteSucceed({