Merge pull request #319 from dwelch2344/watch-compile-hook

#315 - Add watch-compile event

Author: HyperBrain

README.md

@@ -473,6 +473,7 @@ All events (H) can be hooked by a plugin.
    -> webpack:validate:validate (H)
 -> webpack:compile
    -> webpack:compile:compile (H)
+   -> webpack:compile:watch:compile (H)
 -> webpack:package
    -> webpack:package:packExternalModules (H)
    -> webpack:package:packageModules (H)

index.js

@@ -71,6 +71,14 @@ class ServerlessWebpack {
             lifecycleEvents: [
               'compile',
             ],
+            commands: {
+              watch: {
+                type: 'entrypoint',
+                lifecycleEvents: [
+                  'compile'
+                ]
+              }
+            }
           },
           package: {
             type: 'entrypoint',
@@ -139,6 +147,8 @@ class ServerlessWebpack {
       'webpack:compile:compile': () => BbPromise.bind(this)
         .then(this.compile),
 
+      'webpack:compile:watch:compile': () => BbPromise.resolve(),
+
       'webpack:package:packExternalModules': () => BbPromise.bind(this)
         .then(this.packExternalModules),
 

lib/wpwatch.js

@@ -31,9 +31,10 @@ module.exports = {
     };
 
     // This starts the watch and waits for the immediate compile that follows to end or fail.
+    let lastHash = null;
     const startWatch = (callback) => {
       let firstRun = true;
-      compiler.watch(watchOptions, (err, stats) => {
+      const watcher = compiler.watch(watchOptions, (err, stats) => {
         if (err) {
           if (firstRun) {
             firstRun = false;
@@ -42,15 +43,40 @@ module.exports = {
           throw err;
         }
 
+        process.env.SLS_DEBUG && this.serverless.cli.log(`Webpack watch invoke: HASH NEW=${stats.hash} CUR=${lastHash}`);
+
+        // If the file hash did not change there were no effective code changes detected
+        // (comment changes do not change the compile hash and do not account for a rebuild!)
+        // See here: https://webpack.js.org/api/node/#watching (note below watching)
+        if (stats && stats.hash === lastHash) {
+          if (firstRun) {
+            firstRun = false;
+            callback();
+          }
+          return;
+        }
+
         if (stats) {
+          lastHash = stats.hash;
           this.serverless.cli.consoleLog(stats.toString(consoleStats));
         }
 
-        this.serverless.cli.log('Watching for changes...');
-
         if (firstRun) {
           firstRun = false;
+          this.serverless.cli.log('Watching for changes...');
           callback();
+        } else {
+          // We will close the watcher while the compile event is triggered and resume afterwards to prevent race conditions.
+          watcher.close(() => {
+            return this.serverless.pluginManager.spawn('webpack:compile:watch')
+            .then(() => {
+              // Resume watching after we triggered the compile:watch event
+              return BbPromise.fromCallback(cb => {
+                startWatch(cb);
+              })
+              .then(() => this.serverless.cli.log('Watching for changes...'));
+            });
+          });
         }
       });
     };

tests/run.test.js

@@ -87,6 +87,29 @@ describe('run', () => {
       expect(module.isWatching).to.be.true;
     });
 
+    it('should not spawn on watch first run', () => {
+      module.isWatching = false;
+      const watch = module.watch.bind(module);
+      webpackMock.compilerMock.watch = sandbox.stub().yields(null, {});
+      _.set(module, 'options.function', 'myFunction');
+
+      watch('compile:watch:compile');
+      expect(spawnStub).to.not.have.been.called;
+      expect(module.isWatching).to.be.true;
+    });
+
+    it('should spawn on watch second run', () => {
+      module.isWatching = false;
+      const watch = module.watch.bind(module);
+      webpackMock.compilerMock.watch = sandbox.stub().yields(null, {});
+      _.set(module, 'options.function', 'myFunction');
+
+      watch('compile:watch:compile');
+      watch('compile:watch:compile');
+      expect(spawnStub).to.have.been.calledOnce;
+      expect(module.isWatching).to.be.true;
+    });
+
     it('should spawn invoke local on subsequent runs', () => {
       module.isWatching = true;
       const watch = module.watch.bind(module);

tests/webpack.mock.js

@@ -12,17 +12,23 @@ const StatsMock = () => ({
   toString: sinon.stub().returns('testStats'),
 });
 
-const CompilerMock = (sandbox, statsMock) => ({
+const WatchMock = sandbox => ({
+  close: sandbox.stub().callsFake(cb => cb())
+});
+
+const CompilerMock = (sandbox, statsMock, watchMock) => ({
   run: sandbox.stub().yields(null, statsMock),
-  watch: sandbox.stub().yields(null, statsMock)
+  watch: sandbox.stub().returns(watchMock).yields(null, statsMock)
 });
 
 const webpackMock = sandbox => {
   const statsMock = StatsMock(sandbox);
-  const compilerMock = CompilerMock(sandbox, statsMock);
+  const watchMock = WatchMock(sandbox);
+  const compilerMock = CompilerMock(sandbox, statsMock, watchMock);
   const mock = sinon.stub().returns(compilerMock);
   mock.compilerMock = compilerMock;
   mock.statsMock = statsMock;
+  mock.watchMock = watchMock;
   return mock;
 };
 

tests/wpwatch.test.js

@@ -145,23 +145,26 @@ describe('wpwatch', function() {
   it('should call callback on subsequent runs', () => {
     const wpwatch = module.wpwatch.bind(module);
     let watchCallbackSpy;
-    webpackMock.compilerMock.watch.callsFake((options, cb) => {
+    webpackMock.compilerMock.watch.onFirstCall().callsFake((options, cb) => {
       // We'll spy the callback registered for watch
       watchCallbackSpy = sandbox.spy(cb);
 
       // Schedule second call after 2 seconds
       setTimeout(() => {
-        watchCallbackSpy(null, { call: 2 });
+        process.nextTick(() => watchCallbackSpy(null, { call: 2, hash: '2' }));
       }, 2000);
-      process.nextTick(() => watchCallbackSpy(null, { call: 1 }));
+      process.nextTick(() => watchCallbackSpy(null, { call: 1, hash: '1' }));
+      return webpackMock.watchMock;
     });
     spawnStub.resolves();
 
     return expect(wpwatch()).to.be.fulfilled
     .then(() => BbPromise.delay(3000))
     .then(() => BbPromise.join(
-      expect(spawnStub).to.not.have.been.called,
-      expect(webpackMock.compilerMock.watch).to.have.been.calledOnce,
+      expect(spawnStub).to.have.been.calledOnce,
+      expect(spawnStub).to.have.been.calledWithExactly('webpack:compile:watch'),
+      expect(webpackMock.compilerMock.watch).to.have.been.calledTwice,
+      expect(webpackMock.watchMock.close).to.have.been.calledOnce,
       expect(watchCallbackSpy).to.have.been.calledTwice
     ));
   });
@@ -181,7 +184,7 @@ describe('wpwatch', function() {
           // Ignore the exception. The spy will record it.
         }
       }, 2000);
-      process.nextTick(() => watchCallbackSpy(null, { call: 1 }));
+      process.nextTick(() => watchCallbackSpy(null, { call: 3, hash: '3' }));
     });
     spawnStub.resolves();