feat: function level entry overrides

README.md

@@ -187,6 +187,23 @@ module.exports = {
 };
 ```
 
+##### Optional entry overrides
+
+`serverless-webpack` generates Webpack entries from the `handler` value by default.
+
+If your handler is different from the webpack entry, e.g. provided by a layer, 
+you may override the generated entry at function level via the `entrypoint` 
+option in `serverless.yml`.
+
+```yaml
+functions:
+  my-function:
+    layers:
+      - LAYER-ARN
+    handler: layer.handler
+    entrypoint: src/index.handler
+```
+
 #### Full customization (for experts)
 
 The lib export also provides the `serverless` and `options` properties, through

index.js

@@ -15,6 +15,7 @@ const prepareStepOfflineInvoke = require('./lib/prepareStepOfflineInvoke');
 const packExternalModules = require('./lib/packExternalModules');
 const packageModules = require('./lib/packageModules');
 const { isNodeRuntime } = require('./lib/utils');
+const { extendFunctionProperties } = require('./lib/extendServerless');
 const lib = require('./lib');
 
 class ServerlessWebpack {
@@ -24,6 +25,8 @@ class ServerlessWebpack {
 
   constructor(serverless, options, v3Utils) {
     this.serverless = serverless;
+    extendFunctionProperties(this.serverless);
+
     this.options = options;
 
     if (v3Utils) {

lib/extendServerless.js

@@ -0,0 +1,15 @@
+const _ = require('lodash');
+
+const extendFunctionProperties = serverless => {
+  if (_.isFunction(serverless.configSchemaHandler.defineFunctionProperties)) {
+    serverless.configSchemaHandler.defineFunctionProperties('aws', {
+      properties: {
+        entrypoint: { type: 'string' }
+      }
+    });
+  }
+};
+
+module.exports = {
+  extendFunctionProperties
+};

lib/validate.js

@@ -19,7 +19,11 @@ const preferredExtensions = ['.js', '.ts', '.jsx', '.tsx'];
 module.exports = {
   validate() {
     const getHandlerFileAndFunctionName = functionDefinition => {
-      const { handler: handlerProp, image: imageProp } = functionDefinition;
+      const { handler: handlerProp, image: imageProp, entrypoint: entryPoint } = functionDefinition;
+
+      // CASE: The lambda handler is inside lambda layer. Use functionDefinition `entrypoint`
+      //       to define the original handler.
+      if (entryPoint) return entryPoint;
 
       if (handlerProp) {
         return handlerProp;

tests/index.test.js

@@ -23,13 +23,23 @@ describe('ServerlessWebpack', () => {
     };
     serverless.pluginManager.spawn = jest.fn().mockReturnValue(BbPromise.resolve());
     serverless.service.getFunction = jest.fn().mockReturnValue({ runtime: 'nodejs12.x' });
+    serverless.configSchemaHandler.defineFunctionProperties = jest.fn();
   });
 
   it('should expose a lib object', () => {
     const lib = ServerlessWebpack.lib;
     expect(lib).toEqual({ entries: {}, webpack: { isLocal: false } });
   });
 
+  it('should extend serverless', () => {
+    new ServerlessWebpack(serverless, {});
+    expect(serverless.configSchemaHandler.defineFunctionProperties).toHaveBeenCalledWith('aws', {
+      properties: {
+        entrypoint: { type: 'string' }
+      }
+    });
+  });
+
   describe('with a TS webpack configuration', () => {
     it('should support old config and register ts-node', () => {
       jest.setMock('ts-node/register', null, { virtual: true });

tests/validate.test.js

@@ -500,6 +500,10 @@ describe('validate', () => {
               }
             }
           ]
+        },
+        layerFunc: {
+          handler: 'layer.handler',
+          entrypoint: 'module1.func1handler'
         }
       };
 
@@ -547,7 +551,7 @@ describe('validate', () => {
             };
 
             expect(lib.entries).toEqual(expectedLibEntries);
-            expect(globMock.sync).toHaveBeenCalledTimes(5);
+            expect(globMock.sync).toHaveBeenCalledTimes(6);
             expect(serverless.cli.log).toHaveBeenCalledTimes(0);
             return null;
           });
@@ -804,6 +808,7 @@ describe('validate', () => {
         _.set(module.serverless.service, 'custom.webpack.config', testConfig);
         module.serverless.service.functions = testFunctionsConfig;
         globMock.sync.mockImplementation(filename => [_.replace(filename, '*', 'js')]);
+
         return expect(module.validate())
           .resolves.toBeUndefined()
           .then(() => {
@@ -915,6 +920,12 @@ describe('validate', () => {
                   func: testFunctionsConfig.func1,
                   entry: { key: 'module1', value: './module1.js' }
                 },
+                {
+                  handlerFile: 'module1',
+                  funcName: 'layerFunc',
+                  func: { handler: 'layer.handler', entrypoint: 'module1.func1handler' },
+                  entry: { key: 'module1', value: './module1.js' }
+                },
                 {
                   handlerFile: 'module2',
                   funcName: 'func2',
@@ -960,12 +971,13 @@ describe('validate', () => {
           return expect(module.validate())
             .resolves.toBeUndefined()
             .then(() => {
-              expect(module.webpackConfig).toHaveLength(5);
+              expect(module.webpackConfig).toHaveLength(6);
               expect(module.webpackConfig[0].output.path).toEqual(path.join('output', 'func1'));
-              expect(module.webpackConfig[1].output.path).toEqual(path.join('output', 'func2'));
-              expect(module.webpackConfig[2].output.path).toEqual(path.join('output', 'func3'));
-              expect(module.webpackConfig[3].output.path).toEqual(path.join('output', 'func4'));
-              expect(module.webpackConfig[4].output.path).toEqual(path.join('output', 'dockerfunc'));
+              expect(module.webpackConfig[1].output.path).toEqual(path.join('output', 'layerFunc'));
+              expect(module.webpackConfig[2].output.path).toEqual(path.join('output', 'func2'));
+              expect(module.webpackConfig[3].output.path).toEqual(path.join('output', 'func3'));
+              expect(module.webpackConfig[4].output.path).toEqual(path.join('output', 'func4'));
+              expect(module.webpackConfig[5].output.path).toEqual(path.join('output', 'dockerfunc'));
 
               return null;
             });
@@ -988,22 +1000,28 @@ describe('validate', () => {
           return expect(module.validate())
             .resolves.toBeUndefined()
             .then(() => {
-              expect(module.webpackConfig).toHaveLength(5);
+              expect(module.webpackConfig).toHaveLength(6);
               expect(module.webpackConfig[0].devtool).toEqual('source-map');
               expect(module.webpackConfig[1].devtool).toEqual('source-map');
               expect(module.webpackConfig[2].devtool).toEqual('source-map');
               expect(module.webpackConfig[3].devtool).toEqual('source-map');
               expect(module.webpackConfig[4].devtool).toEqual('source-map');
+              expect(module.webpackConfig[5].devtool).toEqual('source-map');
+
               expect(module.webpackConfig[0].context).toEqual('some context');
               expect(module.webpackConfig[1].context).toEqual('some context');
               expect(module.webpackConfig[2].context).toEqual('some context');
               expect(module.webpackConfig[3].context).toEqual('some context');
               expect(module.webpackConfig[4].context).toEqual('some context');
+              expect(module.webpackConfig[5].context).toEqual('some context');
+
               expect(module.webpackConfig[0].output.libraryTarget).toEqual('commonjs');
               expect(module.webpackConfig[1].output.libraryTarget).toEqual('commonjs');
               expect(module.webpackConfig[2].output.libraryTarget).toEqual('commonjs');
               expect(module.webpackConfig[3].output.libraryTarget).toEqual('commonjs');
               expect(module.webpackConfig[4].output.libraryTarget).toEqual('commonjs');
+              expect(module.webpackConfig[5].output.libraryTarget).toEqual('commonjs');
+
               return null;
             });
         });