add hook *before:step-functions-offline:start*

.editorconfig

@@ -1,10 +1,12 @@
-root = true
-
-[*]
-indent_style = space
-end_of_line = lf
-
-[*.{js,jsx}]
-indent_style = space
-end_of_line = lf
-charset = utf-8
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+
+[*.{js,jsx}]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8

README.md

@@ -453,6 +453,14 @@ Plugin commands are supported by the following providers. ⁇ indicates that com
 | invoke local          |      ✔︎     |         ✔︎        |        ⁇        |            ⁇           |
 | invoke local --watch  |      ✔︎     |         ✔︎        |        ⁇        |            ⁇           |
 
+## Plugin support
+
+The following serverless plugins are explicitly supported with `serverless-webpack`
+
+| Plugin                            | NPM |
+|-----------------------------------|-----|
+| serverless-step-functions-offline | [![NPM][ico-step-functions-offline]][link-step-functions-offline] |
+
 ## For developers
 
 The plugin exposes a complete lifecycle model that can be hooked by other plugins to extend
@@ -602,6 +610,8 @@ plugin when running a command or invoked by a hook.
 [link-examples]: ./examples
 [link-serverless-offline]: https://www.npmjs.com/package/serverless-offline
 [link-serverless-dynamodb-local]: https://www.npmjs.com/package/serverless-dynamodb-local
+[link-step-functions-offline]: https://www.npmjs.com/package/serverless-step-functions-offline
+[ico-step-functions-offline]: https://img.shields.io/npm/v/serverless-step-functions-offline.svg
 
 [comment]: # (Referenced issues)
 

index.js

@@ -12,6 +12,7 @@ const run = require('./lib/run');
 const prepareLocalInvoke = require('./lib/prepareLocalInvoke');
 const runPluginSupport = require('./lib/runPluginSupport');
 const prepareOfflineInvoke = require('./lib/prepareOfflineInvoke');
+const prepareStepOfflineInvoke = require('./lib/prepareStepOfflineInvoke');
 const packExternalModules = require('./lib/packExternalModules');
 const packageModules = require('./lib/packageModules');
 const lib = require('./lib');
@@ -44,7 +45,8 @@ class ServerlessWebpack {
       packageModules,
       prepareLocalInvoke,
       runPluginSupport,
-      prepareOfflineInvoke
+      prepareOfflineInvoke,
+      prepareStepOfflineInvoke
     );
 
     this.commands = {
@@ -153,6 +155,9 @@ class ServerlessWebpack {
         .then(this.prepareOfflineInvoke)
         .then(this.wpwatch),
 
+      'before:step-functions-offline:start': () => BbPromise.bind(this)
+         .then(this.prepareStepOfflineInvoke)
+         .then(this.compile)
     };
   }
 }

lib/prepareStepOfflineInvoke.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const _ = require('lodash');
+const path = require('path');
+
+/**
+ * Special settings for use with serverless-step-functions-offline.
+ */
+
+module.exports = {
+  prepareStepOfflineInvoke() {
+    _.set(this.serverless, 'service.package.individually', false);
+
+    return this.serverless.pluginManager.spawn('webpack:validate')
+      .then(() => {
+        if (!this.options.location && !_.get(this.serverless, 'service.custom.stepFunctionsOffline.location')) {
+          _.set(this.serverless, 'service.custom.stepFunctionsOffline.location',
+            path.relative(this.serverless.config.servicePath, path.join(this.webpackOutputPath, 'service'))
+          );
+        }
+        return null;
+      });
+  }
+};

tests/all.js

@@ -9,4 +9,5 @@ describe('serverless-webpack', () => {
   require('./cleanup.test');
   require('./wpwatch.test');
   require('./runPluginSupport.test');
+  require('./prepareStepOfflineInvoke.test');
 });

tests/prepareStepOfflineInvoke.test.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const _ = require('lodash');
+const BbPromise = require('bluebird');
+const chai = require('chai');
+const sinon = require('sinon');
+const Serverless = require('serverless');
+
+chai.use(require('chai-as-promised'));
+chai.use(require('sinon-chai'));
+
+const expect = chai.expect;
+
+describe('prepareStepOfflineInvoke', () => {
+  let serverless;
+  let baseModule;
+  let module;
+  let sandbox;
+
+  before(() => {
+    sandbox = sinon.createSandbox();
+    sandbox.usingPromise(BbPromise.Promise);
+
+    baseModule = require('../lib/prepareStepOfflineInvoke');
+    Object.freeze(baseModule);
+  });
+
+  beforeEach(() => {
+    serverless = new Serverless();
+    serverless.cli = {
+      log: sandbox.stub()
+    };
+    sandbox.stub(serverless.pluginManager, 'spawn');
+    module = _.assign({
+      serverless,
+      options: {},
+    }, baseModule);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should set service packaging explicitly', () => {
+    serverless.pluginManager.spawn.resolves();
+    serverless.config.servicePath = 'myPath';
+    module.webpackOutputPath = '.';
+    module.serverless.service.package = {};
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.fulfilled
+    .then(() => {
+      expect(module.serverless.service.package).to.have.a.property('individually').that.is.false;
+      return null;
+    });
+  });
+
+  it('should switch to service packaging', () => {
+    serverless.pluginManager.spawn.resolves();
+    serverless.config.servicePath = 'myPath';
+    module.webpackOutputPath = '.';
+    module.serverless.service.package = {
+      individually: true
+    };
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.fulfilled
+    .then(() => {
+      expect(module.serverless.service.package).to.have.a.property('individually').that.is.false;
+      return null;
+    });
+  });
+
+  it('should spawn webpack:validate', () => {
+    serverless.pluginManager.spawn.resolves();
+    serverless.config.servicePath = 'myPath';
+    module.webpackOutputPath = '.';
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.fulfilled
+    .then(() => {
+      expect(serverless.pluginManager.spawn).to.have.been.calledOnce;
+      expect(serverless.pluginManager.spawn).to.have.been.calledWithExactly('webpack:validate');
+      return null;
+    });
+  });
+
+  it('should reject if spawn rejects', () => {
+    serverless.pluginManager.spawn.returns(BbPromise.reject(new Error('spawn failed')));
+    serverless.config.servicePath = 'myPath';
+    module.webpackOutputPath = '.';
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.rejectedWith('spawn failed');
+  });
+
+  it('should set location if not given by user', () => {
+    serverless.pluginManager.spawn.resolves();
+    serverless.config.servicePath = '.';
+    module.webpackOutputPath = '.';
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.fulfilled
+    .then(() => {
+      expect(serverless.service).to.have.a.nested.property('custom.stepFunctionsOffline.location', 'service');
+      return null;
+    });
+  });
+
+  it('should keep location if set in service config', () => {
+    serverless.pluginManager.spawn.resolves();
+    serverless.config.servicePath = '.';
+    module.webpackOutputPath = '.';
+    _.set(module.serverless, 'service.custom.stepFunctionsOffline.location', 'myLocation');
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.fulfilled
+    .then(() => {
+      expect(serverless.service).to.have.a.nested.property('custom.stepFunctionsOffline.location', 'myLocation');
+      return null;
+    });
+  });
+
+  it('should keep location if set in options', () => {
+    serverless.pluginManager.spawn.resolves();
+    serverless.config.servicePath = '.';
+    module.webpackOutputPath = '.';
+    module.options = {
+      location: 'myLocation'
+    };
+
+    return expect(module.prepareStepOfflineInvoke()).to.be.fulfilled
+    .then(() => {
+      expect(serverless.service).to.not.have.a.nested.property('custom.stepFunctionsOffline.location');
+      return null;
+    });
+  });
+});