wacth: track worker thread dependencies in --watch mode for cjs files

Author: SudhansuBandha

lib/internal/modules/cjs/loader.js

@@ -329,6 +329,28 @@ function reportModuleNotFoundToWatchMode(basePath, extensions) {
   }
 }
 
+/**
+ * Tell the watch mode that a module was required, from within a worker thread.
+ * @param {string} filename Absolute path of the module
+ * @returns {void}
+ */
+function reportModuleToWatchModeFromWorker(filename) {
+  if (!shouldReportRequiredModules()) {
+    return;
+  }
+  const { isMainThread } = internalBinding('worker');
+  if (isMainThread) {
+    return;
+  }
+  // Lazy require to avoid circular dependency: worker_threads is loaded after
+  // the CJS loader is fully set up.
+  const { parentPort } = require('worker_threads');
+  if (!parentPort) {
+    return;
+  }
+  parentPort.postMessage({ 'watch:require': [filename] });
+}
+
 /**
  * Create a new module instance.
  * @param {string} id
@@ -1245,6 +1267,7 @@ Module._load = function(request, parent, isMain, internalResolveOptions = kEmpty
     relResolveCacheIdentifier = `${parent.path}\x00${request}`;
     const filename = relativeResolveCache[relResolveCacheIdentifier];
     reportModuleToWatchMode(filename);
+    reportModuleToWatchModeFromWorker(filename);
     if (filename !== undefined) {
       const cachedModule = Module._cache[filename];
       if (cachedModule !== undefined) {
@@ -1335,6 +1358,7 @@ Module._load = function(request, parent, isMain, internalResolveOptions = kEmpty
     }
 
     reportModuleToWatchMode(filename);
+    reportModuleToWatchModeFromWorker(filename);
     Module._cache[filename] = module;
     module[kIsCachedByESMLoader] = false;
     // If there are resolve hooks, carry the context information into the

lib/internal/watch_mode/files_watcher.js

@@ -179,9 +179,6 @@ class FilesWatcher extends EventEmitter {
         if (ArrayIsArray(message['watch:import'])) {
           ArrayPrototypeForEach(message['watch:import'], (file) => this.filterFile(fileURLToPath(file), key));
         }
-        if (ArrayIsArray(message['watch:worker'])) {
-           ArrayPrototypeForEach(message['watch:worker'], (file) => this.filterFile(file, key));
-        }
       } catch {
         // Failed watching file. ignore
       }

lib/internal/worker.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   ArrayPrototypeForEach,
   ArrayPrototypeMap,
   ArrayPrototypePush,
@@ -195,17 +196,6 @@ class HeapProfileHandle {
   }
 }
 
-/**
- * Tell the watch mode that a worker file was instantiated.
- * @param {string} filename Absolute path of the worker file
- * @returns {void}
- */
-function reportWorkerToWatchMode(filename) {
-  if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
-    process.send({ 'watch:worker': [filename] });
-  }
-}
-
 class Worker extends EventEmitter {
   constructor(filename, options = kEmptyObject) {
     throwIfBuildingSnapshot('Creating workers');
@@ -286,11 +276,6 @@ class Worker extends EventEmitter {
       name = StringPrototypeTrim(options.name);
     }
 
-    // Report to watch mode if this is a regular file (not eval, internal, or data URL)
-    if (!isInternal && doEval === false) {
-      reportWorkerToWatchMode(filename);
-    }
-
     debug('instantiating Worker.', `url: ${url}`, `doEval: ${doEval}`);
     // Set up the C++ handle for the worker, as well as some internal wiring.
     this[kHandle] = new WorkerImpl(url,
@@ -349,6 +334,15 @@ class Worker extends EventEmitter {
       this[kPublicPort].on(event, (message) => this.emit(event, message));
     });
     setupPortReferencing(this[kPublicPort], this, 'message');
+
+    // relay events from worker thread to watcher
+    if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
+      this[kPublicPort].on('message', (message) => {
+        if (ArrayIsArray(message?.['watch:require'])) {
+          process.send({ 'watch:require': message['watch:require'] });
+        }
+      });
+    }
     this[kPort].postMessage({
       argv,
       type: messageTypes.LOAD_SCRIPT,