Merge pull request #351 from serverless-heaven/fix-local-invoke-watch

Purge handler module from require cache on watch

Author: HyperBrain

lib/prepareLocalInvoke.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const BbPromise = require('bluebird');
 const path = require('path');
 const _ = require('lodash');
+const Utils = require('./utils');
 
 module.exports = {
   prepareLocalInvoke() {
@@ -23,6 +23,13 @@ module.exports = {
     // Set service path as CWD to allow accessing bundled files correctly
     process.chdir(this.serverless.config.servicePath);
 
-    return BbPromise.resolve();
+    // Remove handler from module cache to allow load of changed code.
+    const func = this.serverless.service.getFunction(this.options.function);
+    const handlerFile = path.join(
+      this.serverless.config.servicePath,
+      this.options.extraServicePath || '',
+      _.join(_.initial(_.split(func.handler, '.')), '.')
+    );
+    return Utils.purgeCache(handlerFile);
   }
 };

lib/prepareLocalInvoke.test.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const _ = require('lodash');
+const BbPromise = require('bluebird');
+const chai = require('chai');
+const sinon = require('sinon');
+const Serverless = require('serverless');
+const path = require('path');
+const Utils = require('./utils');
+
+chai.use(require('chai-as-promised'));
+chai.use(require('sinon-chai'));
+
+const expect = chai.expect;
+
+describe('prepareLocalInvoke', () => {
+  let serverless;
+  let baseModule;
+  let module;
+  let sandbox;
+
+  before(() => {
+    sandbox = sinon.createSandbox();
+    sandbox.usingPromise(BbPromise.Promise);
+
+    baseModule = require('./prepareLocalInvoke');
+    Object.freeze(baseModule);
+  });
+
+  beforeEach(() => {
+    serverless = new Serverless();
+    serverless.cli = {
+      log: sandbox.stub()
+    };
+    _.set(serverless, 'config.serverless.processedInput.options', {
+      path: './event.json'
+    });
+
+    sandbox.stub(Utils, 'purgeCache');
+    sandbox.stub(process, 'chdir');
+    sandbox.stub(serverless.service, 'getFunction');
+
+    module = _.assign({
+      serverless,
+      options: {},
+    }, baseModule);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should store original service path', () => {
+    module.serverless.service.package = {};
+    module.serverless.service.getFunction.returns({ handler: 'myFuncHandler' });
+    module.webpackOutputPath = '.';
+    module.serverless.config.servicePath = './servicePath';
+    module.prepareLocalInvoke();
+    
+    expect(module.originalServicePath).to.equal('./servicePath');
+  });
+
+  it('should use the function folder as cwd', () => {
+    module.serverless.service.package = {
+      individually: true
+    };
+    module.options.function = 'myFunc';
+    module.serverless.service.getFunction.returns({ handler: 'myFuncHandler' });
+    module.webpackOutputPath = '.webpack';
+    module.serverless.config.servicePath = './servicePath';
+    module.prepareLocalInvoke();
+    
+    expect(process.chdir).to.have.been.calledWithExactly(path.join('.webpack', 'myFunc'));
+  });
+
+  it('should use the service folder as cwd', () => {
+    module.serverless.service.package = {};
+    module.options.function = 'myFunc';
+    module.serverless.service.getFunction.returns({ handler: 'myFuncHandler' });
+    module.webpackOutputPath = '.webpack';
+    module.serverless.config.servicePath = './servicePath';
+    module.prepareLocalInvoke();
+    
+    expect(process.chdir).to.have.been.calledWithExactly(path.join('.webpack', 'service'));
+  });
+
+  it('should work without path option', () => {
+    module.serverless.service.package = {};
+    module.serverless.service.getFunction.returns({ handler: 'myFuncHandler' });
+    module.webpackOutputPath = '.';
+    module.serverless.config.servicePath = './servicePath';
+    _.unset(module, 'serverless.config.serverless.processedInput.options.path');
+    module.prepareLocalInvoke();
+    
+    expect(module.originalServicePath).to.equal('./servicePath');
+  });
+});

lib/utils.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const _ = require('lodash');
+const BbPromise = require('bluebird');
 
 function guid() {
   function s4() {
@@ -11,31 +12,44 @@ function guid() {
   return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
 }
 
+/**
+ * Remove the specified module from the require cache.
+ * @param {string} moduleName 
+ */
 function purgeCache(moduleName) {
-  searchCache(moduleName, function (mod) {
+  return searchAndProcessCache(moduleName, function (mod) {
     delete require.cache[mod.id];
-  });
-  _.forEach(_.keys(module.constructor._pathCache), function(cacheKey) {
-    if (cacheKey.indexOf(moduleName)>0) {
-      delete module.constructor._pathCache[cacheKey];
-    }
+  })
+  .then(() => {
+    _.forEach(_.keys(module.constructor._pathCache), function(cacheKey) {
+      if (cacheKey.indexOf(moduleName)>0) {
+        delete module.constructor._pathCache[cacheKey];
+      }
+    });
+    return BbPromise.resolve();
   });
 }
 
-function searchCache(moduleName, callback) {
-  let mod = require.resolve(moduleName);
-  if (mod && ((mod = require.cache[mod]) !== undefined)) {
-    (function traverse(mod) {
-      _.forEach(mod.children, function (child) {
-        traverse(child);
-      });
-      callback(mod);
-    }(mod));
+function searchAndProcessCache(moduleName, processor) {
+  let mod_src = require.resolve(moduleName);
+  const visitedModules = [];
+  if (mod_src && ((mod_src = require.cache[mod_src]) !== undefined)) {
+    const modStack = [mod_src];
+
+    while (!_.isEmpty(modStack)) {
+      const mod = modStack.pop();
+      if (!_.includes(visitedModules, mod)) {
+        visitedModules.push(mod);
+        Array.prototype.push.apply(modStack, mod.children);
+        processor(mod);
+      }
+    }
   }
+  return BbPromise.resolve();
 }
 
 module.exports = {
   guid,
   purgeCache,
-  searchCache,
+  searchAndProcessCache,
 };