lib: support glob on --watch-path

Author: louiellan

lib/internal/fs/glob.js

@@ -798,4 +798,5 @@ module.exports = {
   __proto__: null,
   Glob,
   matchGlobPattern,
+  createMatcher,
 };

lib/internal/main/watch_mode.js

@@ -1,5 +1,6 @@
 'use strict';
 const {
+  ArrayPrototypeFlatMap,
   ArrayPrototypeForEach,
   ArrayPrototypeIncludes,
   ArrayPrototypeJoin,
@@ -28,17 +29,32 @@ const { inspect } = require('util');
 const { setTimeout, clearTimeout } = require('timers');
 const { resolve } = require('path');
 const { once } = require('events');
+const { createMatcher } = require('internal/fs/glob');
+const { globSync } = require('fs');
 
 prepareMainThreadExecution(false, false);
 markBootstrapComplete();
 
+function hasGlobPattern(path) {
+  return createMatcher(path).hasMagic();
+}
+
+function handleWatchedPath(path) {
+  if (hasGlobPattern(path)) {
+    const matchedFilesFromGlob = globSync(path);
+    const resolvedMatchedFiles = ArrayPrototypeMap(matchedFilesFromGlob, (path) => resolve(path));
+    return resolvedMatchedFiles;
+  }
+  return resolve(path);
+}
+
 const kKillSignal = convertToValidSignal(getOptionValue('--watch-kill-signal'));
 const kShouldFilterModules = getOptionValue('--watch-path').length === 0;
 const kEnvFiles = [
   ...getOptionValue('--env-file'),
   ...getOptionValue('--env-file-if-exists'),
 ];
-const kWatchedPaths = ArrayPrototypeMap(getOptionValue('--watch-path'), (path) => resolve(path));
+const kWatchedPaths = ArrayPrototypeFlatMap(getOptionValue('--watch-path'), (path) => handleWatchedPath(path));
 const kPreserveOutput = getOptionValue('--watch-preserve-output');
 const kCommand = ArrayPrototypeSlice(process.argv, 1);
 const kCommandStr = inspect(ArrayPrototypeJoin(kCommand, ' '));

test/sequential/test-watch-mode.mjs

@@ -108,10 +108,21 @@ async function runWriteSucceed({
   let stderr = '';
   const stdout = [];
 
+  let watchedFiles = [];
+  let currentWatchedFileIndex = 0;
+  const isWatchingMultpileFiles = Array.isArray(watchedFile) && watchedFile.length > 1;
+  const isWatchingSingleFile = !isWatchingMultpileFiles;
+
+  if (isWatchingMultpileFiles) {
+    watchedFiles = watchedFile;
+    restarts = watchedFiles.length + 1;
+  }
+
   child.stderr.on('data', (data) => {
     stderr += data;
   });
 
+
   try {
     // Break the chunks into lines
     for await (const data of createInterface({ input: child.stdout })) {
@@ -120,14 +131,16 @@ async function runWriteSucceed({
       }
       if (data.startsWith(completed)) {
         completes++;
-        if (completes === restarts) {
+        if (completes === restarts)
           break;
-        }
-        if (completes === 1) {
+        if (isWatchingSingleFile && completes === 1)
           cancelRestarts = restart(watchedFile);
+        if (isWatchingMultpileFiles && completes < restarts) {
+          cancelRestarts();
+          const currentlyWatchedFile = watchedFiles[currentWatchedFileIndex++];
+          cancelRestarts = restart(currentlyWatchedFile);
         }
       }
-
       if (!shouldFail && data.startsWith('Failed running')) {
         break;
       }
@@ -884,4 +897,50 @@ process.on('message', (message) => {
       await done();
     }
   });
+
+  it('should watch files from a given glob pattern --watch-path=./**/*.js', async () => {
+
+    const tmpDirForGlobTest = tmpdir.resolve('glob-test-dir');
+    mkdirSync(tmpDirForGlobTest);
+
+    const globPattern = path.resolve(tmpDirForGlobTest, '**/*.js');
+
+    const directory1 = path.join(tmpDirForGlobTest, 'directory1');
+    const directory2 = path.join(tmpDirForGlobTest, 'directory2');
+
+    mkdirSync(directory1);
+    mkdirSync(directory2);
+
+    const tmpJsFile1 = createTmpFile('', '.js', directory1);
+    const tmpJsFile2 = createTmpFile('', '.js', directory1);
+    const tmpJsFile3 = createTmpFile('', '.js', directory2);
+    const tmpJsFile4 = createTmpFile('', '.js', directory2);
+    const tmpJsFile5 = createTmpFile('', '.js', directory2);
+
+    const mainJsFile = createTmpFile('console.log(\'running\')', '.js', tmpDirForGlobTest);
+
+    const args = ['--watch-path', globPattern, mainJsFile];
+    const watchedFiles = [tmpJsFile1, tmpJsFile2, tmpJsFile3, tmpJsFile4, tmpJsFile5];
+
+    const { stderr, stdout } = await runWriteSucceed({
+      args,
+      watchedFile: watchedFiles,
+    });
+
+    function expectRepeatedCompletes(n) {
+      const expectedStdout = [];
+      for (let i = 0; i < n; i++) {
+        if (i !== 0) {
+          expectedStdout.push(`Restarting ${inspect((mainJsFile))}`);
+        }
+        expectedStdout.push('running');
+        expectedStdout.push(`Completed running ${inspect(mainJsFile)}. Waiting for file changes before restarting...`);
+      }
+      return expectedStdout;
+    }
+
+    assert.strictEqual(stderr, '');
+    assert.deepStrictEqual(stdout, expectRepeatedCompletes(6));
+
+  });
 });