serverless-offline 8.5.0 → 8.6.0

package/README.md

@@ -244,7 +244,7 @@ to calling it via `aws-sdk`.
 
 ## The `process.env.IS_OFFLINE` variable
 
-Will be `"true"` in your handlers and thorough the plugin.
+Will be `"true"` in your handlers and throughout the plugin.
 
 ## Docker and Layers
 
@@ -531,8 +531,6 @@ Where the `event` is received in the lambda handler function.
 
 There's support for [websocketsApiRouteSelectionExpression](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-selection-expressions.html) in it's basic form: `$request.body.x.y.z`, where the default value is `$request.body.action`.
 
-Authorizers and wss:// are currently not supported.
-
 ## Usage with Webpack
 
 Use [serverless-webpack](https://github.com/serverless-heaven/serverless-webpack) to compile and bundle your ES-next code
@@ -596,7 +594,54 @@ For each debug run:
 
 The system will start in wait status. This will also automatically start the chrome browser and wait for you to set breakpoints for inspection. Set the breakpoints as needed and, then, click the play button for the debugging to continue.
 
-Depending on the breakpoint, you may need to call the URL path for your function in seperate browser window for your serverless function to be run and made available for debugging.
+Depending on the breakpoint, you may need to call the URL path for your function in separate browser window for your serverless function to be run and made available for debugging.
+
+### Interactive Debugging with Visual Studio Code (VSC)
+
+With newer versions of node (6.3+) the node inspector is already part of your node environment and you can take advantage of debugging inside your IDE with source-map support. Here is the example configuration to debug interactively with VSC. It has two steps. 
+
+#### Step 1 : Adding a launch configuration in IDE
+
+Add a new [launch configuration](https://code.visualstudio.com/docs/editor/debugging) to VSC like this:
+
+```json
+    {
+
+      "type": "node",
+      "request": "launch",
+      "name": "Debug Serverless Offline",
+      "cwd": "${workspaceFolder}",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": [
+          "run",
+          "debug"
+      ],      
+      "sourceMaps": true
+    }  
+
+```
+
+#### Step2 : Adding a debug script
+
+You will also need to add a `debug` script reference in your `package.json file`
+
+Add this to the `scripts` section:
+
+> Unix/Mac: `"debug" : "export SLS_DEBUG=* && node --inspect /usr/local/bin/serverless offline"`
+
+> Windows: `"debug": "SET SLS_DEBUG=* && node --inspect node_modules\\serverless\\bin\\serverless offline"`
+
+Example:
+
+```json
+....
+"scripts": {
+  "debug" : "SET SLS_DEBUG=* && node --inspect node_modules\\serverless\\bin\\serverless offline"
+}
+```
+
+In VSC, you can, then, add breakpoints to your code. To start a debug sessions you can either start your script in `package.json` by clicking the hovering debug intellisense icon or  by going to your debug pane and selecting the Debug Serverless Offline configuration. 
+
 
 ## Resource permissions and AWS profile
 

package/dist/ServerlessOffline.js

@@ -96,6 +96,10 @@ class ServerlessOffline {
             lifecycleEvents: ['init', 'ready', 'end'],
             options: _index2.commandOptions,
             usage: 'Simulates API Gateway to call your lambda functions offline using backward compatible initialization.'
+          },
+          functionsUpdated: {
+            type: 'entrypoint',
+            lifecycleEvents: ['cleanup']
           }
         },
         lifecycleEvents: ['start'],
@@ -106,6 +110,7 @@ class ServerlessOffline {
     this.hooks = {
       'offline:start:init': this.start.bind(this),
       'offline:start:ready': this.ready.bind(this),
+      'offline:functionsUpdated:cleanup': this.cleanupFunctions.bind(this),
       'offline:start': this._startWithExplicitEnd.bind(this),
       'offline:start:end': this.end.bind(this)
     };
@@ -203,6 +208,13 @@ class ServerlessOffline {
       process.exit(0);
     }
   }
+
+  async cleanupFunctions() {
+    if (_classPrivateFieldLooseBase(this, _lambda)[_lambda]) {
+      (0, _serverlessLog.default)('Forcing cleanup of Lambda functions');
+      await _classPrivateFieldLooseBase(this, _lambda)[_lambda].cleanup();
+    }
+  }
   /**
    * Entry point for the plugin (sls offline) when running 'sls offline'
    * The call to this.end() would terminate the process before 'offline:start:end' could be consumed

package/dist/events/{http/authFunctionNameExtractor.js → authFunctionNameExtractor.js}

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = authFunctionNameExtractor;
 
-var _serverlessLog2 = _interopRequireDefault(require("../../serverlessLog.js"));
+var _serverlessLog2 = _interopRequireDefault(require("../serverlessLog.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 

package/dist/events/http/HttpServer.js

@@ -17,7 +17,7 @@ var _hapi = require("@hapi/hapi");
 
 var _module = require("module");
 
-var _authFunctionNameExtractor = _interopRequireDefault(require("./authFunctionNameExtractor.js"));
+var _authFunctionNameExtractor = _interopRequireDefault(require("../authFunctionNameExtractor.js"));
 
 var _authJWTSettingsExtractor = _interopRequireDefault(require("./authJWTSettingsExtractor.js"));
 

package/dist/events/http/createAuthScheme.js

@@ -7,7 +7,7 @@ exports.default = createAuthScheme;
 
 var _boom = _interopRequireDefault(require("@hapi/boom"));
 
-var _authCanExecuteResource = _interopRequireDefault(require("./authCanExecuteResource.js"));
+var _authCanExecuteResource = _interopRequireDefault(require("../authCanExecuteResource.js"));
 
 var _debugLog = _interopRequireDefault(require("../../debugLog.js"));
 

package/dist/events/http/lambda-events/LambdaProxyIntegrationEventV2.js

@@ -169,7 +169,13 @@ class LambdaProxyIntegrationEventV2 {
     const httpMethod = method.toUpperCase();
     const requestTime = (0, _index.formatToClfTime)(received);
     const requestTimeEpoch = received;
-    const cookies = Object.entries(_classPrivateFieldLooseBase(this, _request)[_request].state).map(([key, value]) => `${key}=${value}`);
+    const cookies = Object.entries(_classPrivateFieldLooseBase(this, _request)[_request].state).flatMap(([key, value]) => {
+      if (Array.isArray(value)) {
+        return value.map(v => `${key}=${v}`);
+      }
+
+      return `${key}=${value}`;
+    });
     return {
       version: '2.0',
       routeKey: _classPrivateFieldLooseBase(this, _routeKey)[_routeKey],

package/dist/events/websocket/WebSocketClients.js

@@ -17,6 +17,10 @@ var _index2 = require("../../config/index.js");
 
 var _index3 = require("../../utils/index.js");
 
+var _authFunctionNameExtractor = _interopRequireDefault(require("../authFunctionNameExtractor.js"));
+
+var _authCanExecuteResource = _interopRequireDefault(require("../authCanExecuteResource.js"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
@@ -36,8 +40,14 @@ var _lambda = /*#__PURE__*/_classPrivateFieldLooseKey("lambda");
 
 var _options = /*#__PURE__*/_classPrivateFieldLooseKey("options");
 
+var _serverless = /*#__PURE__*/_classPrivateFieldLooseKey("serverless");
+
 var _webSocketRoutes = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketRoutes");
 
+var _webSocketAuthorizers = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketAuthorizers");
+
+var _webSocketAuthorizersCache = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketAuthorizersCache");
+
 var _websocketsApiRouteSelectionExpression = /*#__PURE__*/_classPrivateFieldLooseKey("websocketsApiRouteSelectionExpression");
 
 var _idleTimeouts = /*#__PURE__*/_classPrivateFieldLooseKey("idleTimeouts");
@@ -58,10 +68,22 @@ class WebSocketClients {
       writable: true,
       value: null
     });
+    Object.defineProperty(this, _serverless, {
+      writable: true,
+      value: null
+    });
     Object.defineProperty(this, _webSocketRoutes, {
       writable: true,
       value: new Map()
     });
+    Object.defineProperty(this, _webSocketAuthorizers, {
+      writable: true,
+      value: new Map()
+    });
+    Object.defineProperty(this, _webSocketAuthorizersCache, {
+      writable: true,
+      value: new Map()
+    });
     Object.defineProperty(this, _websocketsApiRouteSelectionExpression, {
       writable: true,
       value: null
@@ -76,6 +98,7 @@ class WebSocketClients {
     });
     _classPrivateFieldLooseBase(this, _lambda)[_lambda] = lambda;
     _classPrivateFieldLooseBase(this, _options)[_options] = options;
+    _classPrivateFieldLooseBase(this, _serverless)[_serverless] = serverless;
     _classPrivateFieldLooseBase(this, _websocketsApiRouteSelectionExpression)[_websocketsApiRouteSelectionExpression] = serverless.service.provider.websocketsApiRouteSelectionExpression || _index2.DEFAULT_WEBSOCKETS_API_ROUTE_SELECTION_EXPRESSION;
 
     if (v3Utils) {
@@ -161,7 +184,9 @@ class WebSocketClients {
   }
 
   async verifyClient(connectionId, request) {
-    const route = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get('$connect');
+    const routeName = '$connect';
+
+    const route = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get(routeName);
 
     if (!route) {
       return {
@@ -172,6 +197,96 @@ class WebSocketClients {
 
     const connectEvent = new _index.WebSocketConnectEvent(connectionId, request, _classPrivateFieldLooseBase(this, _options)[_options]).create();
 
+    const authFunName = _classPrivateFieldLooseBase(this, _webSocketAuthorizers)[_webSocketAuthorizers].get(routeName);
+
+    if (authFunName) {
+      const authorizerFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(authFunName);
+
+      const authorizeEvent = new _index.WebSocketAuthorizerEvent(connectionId, request, _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider, _classPrivateFieldLooseBase(this, _options)[_options]).create();
+      authorizerFunction.setEvent(authorizeEvent);
+
+      if (this.log) {
+        this.log.notice();
+        this.log.notice(`Running Authorization function for ${routeName} (λ: ${authFunName})`);
+      } else {
+        console.log(''); // Just to make things a little pretty
+
+        (0, _serverlessLog.default)(`Running Authorization function for ${routeName} (λ: ${authFunName})`);
+      }
+
+      try {
+        const result = await authorizerFunction.runHandler();
+        if (result === 'Unauthorized') return {
+          verified: false,
+          statusCode: 401
+        };
+        const policy = result; // Validate that the policy document has the principalId set
+
+        if (!policy.principalId) {
+          if (this.log) {
+            this.log.notice(`Authorization response did not include a principalId: (λ: ${authFunName})`);
+          } else {
+            (0, _serverlessLog.default)(`Authorization response did not include a principalId: (λ: ${authFunName})`);
+          }
+
+          return {
+            verified: false,
+            statusCode: 403
+          };
+        }
+
+        if (!(0, _authCanExecuteResource.default)(policy.policyDocument, authorizeEvent.methodArn)) {
+          if (this.log) {
+            this.log.notice(`Authorization response didn't authorize user to access resource: (λ: ${authFunName})`);
+          } else {
+            (0, _serverlessLog.default)(`Authorization response didn't authorize user to access resource: (λ: ${authFunName})`);
+          }
+
+          return {
+            verified: false,
+            statusCode: 403
+          };
+        }
+
+        if (this.log) {
+          this.log.notice(`Authorization function returned a successful response: (λ: ${authFunName})`);
+        } else {
+          (0, _serverlessLog.default)(`Authorization function returned a successful response: (λ: ${authFunName})`);
+        }
+
+        _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].set(connectionId, {
+          identity: {
+            apiKey: policy.usageIdentifierKey,
+            sourceIp: authorizeEvent.requestContext.sourceIp,
+            userAgent: authorizeEvent.headers['user-agent'] || ''
+          },
+          authorizer: {
+            integrationLatency: '42',
+            principalId: policy.principalId,
+            ...policy.context
+          }
+        });
+      } catch (err) {
+        if (this.log) {
+          this.log.debug(`Error in route handler '${routeName}' authorizer`, err);
+        } else {
+          (0, _debugLog.default)(`Error in route handler '${routeName}' authorizer`, err);
+        }
+
+        return {
+          verified: false,
+          statusCode: 500
+        };
+      }
+    }
+
+    const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+    if (authorizerData) {
+      connectEvent.identity = authorizerData.identity;
+      connectEvent.authorizer = authorizerData.authorizer;
+    }
+
     const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(route.functionKey);
 
     lambdaFunction.setEvent(connectEvent);
@@ -186,6 +301,8 @@ class WebSocketClients {
         statusCode
       };
     } catch (err) {
+      _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].delete(connectionId);
+
       if (this.log) {
         this.log.debug(`Error in route handler '${route.functionKey}'`, err);
       } else {
@@ -290,7 +407,14 @@ class WebSocketClients {
 
       this._clearIdleTimeout(webSocketClient);
 
-      this._processEvent(webSocketClient, connectionId, '$disconnect', disconnectEvent);
+      const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+      if (authorizerData) {
+        disconnectEvent.identity = authorizerData.identity;
+        disconnectEvent.authorizer = authorizerData.authorizer;
+      }
+
+      this._processEvent(webSocketClient, connectionId, '$disconnect', disconnectEvent).finally(() => _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].delete(connectionId));
     });
     webSocketClient.on('message', message => {
       if (this.log) {
@@ -309,12 +433,76 @@ class WebSocketClients {
 
       const event = new _index.WebSocketEvent(connectionId, route, message).create();
 
+      const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+      if (authorizerData) {
+        event.identity = authorizerData.identity;
+        event.authorizer = authorizerData.authorizer;
+      }
+
       this._onWebSocketUsed(connectionId);
 
       this._processEvent(webSocketClient, connectionId, route, event);
     });
   }
 
+  _extractAuthFunctionName(endpoint) {
+    if (typeof endpoint.authorizer === 'object' && endpoint.authorizer.type && endpoint.authorizer.type.toUpperCase() === 'TOKEN') {
+      if (this.log) {
+        this.log.debug(`Websockets does not support the TOKEN authorization type`);
+      } else {
+        (0, _debugLog.default)(`WARNING: Websockets does not support the TOKEN authorization type`);
+      }
+
+      return null;
+    }
+
+    const result = (0, _authFunctionNameExtractor.default)(endpoint, null, this);
+    return result.unsupportedAuth ? null : result.authorizerName;
+  }
+
+  _configureAuthorization(endpoint, functionKey) {
+    if (!endpoint.authorizer) {
+      return;
+    }
+
+    if (endpoint.route === '$connect') {
+      const authFunctionName = this._extractAuthFunctionName(endpoint);
+
+      if (!authFunctionName) {
+        return;
+      }
+
+      if (this.log) {
+        this.log.notice(`Configuring Authorization: ${functionKey} ${authFunctionName}`);
+      } else {
+        (0, _serverlessLog.default)(`Configuring Authorization: ${functionKey} ${authFunctionName}`);
+      }
+
+      const authFunction = _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.getFunction(authFunctionName);
+
+      if (!authFunction) {
+        if (this.log) {
+          this.log.error(`Authorization function ${authFunctionName} does not exist`);
+        } else {
+          (0, _serverlessLog.default)(`WARNING: Authorization function ${authFunctionName} does not exist`);
+        }
+
+        return;
+      }
+
+      _classPrivateFieldLooseBase(this, _webSocketAuthorizers)[_webSocketAuthorizers].set(endpoint.route, authFunctionName);
+
+      return;
+    }
+
+    if (this.log) {
+      this.log.notice(`Configuring Authorization is supported only on $connect route`);
+    } else {
+      (0, _serverlessLog.default)(`Configuring Authorization is supported only on $connect route`);
+    }
+  }
+
   addRoute(functionKey, definition) {
     // set the route name
     _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].set(definition.route, {
@@ -322,6 +510,10 @@ class WebSocketClients {
       definition
     });
 
+    if (!_classPrivateFieldLooseBase(this, _options)[_options].noAuth) {
+      this._configureAuthorization(definition, functionKey);
+    }
+
     if (this.log) {
       this.log.notice(`route '${definition}'`);
     } else {

package/dist/events/websocket/lambda-events/WebSocketAuthorizerEvent.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _WebSocketRequestContext = _interopRequireDefault(require("./WebSocketRequestContext.js"));
+
+var _index = require("../../../utils/index.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
+
+var id = 0;
+
+function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
+
+var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
+
+var _httpsProtocol = /*#__PURE__*/_classPrivateFieldLooseKey("httpsProtocol");
+
+var _rawHeaders = /*#__PURE__*/_classPrivateFieldLooseKey("rawHeaders");
+
+var _url = /*#__PURE__*/_classPrivateFieldLooseKey("url");
+
+var _websocketPort = /*#__PURE__*/_classPrivateFieldLooseKey("websocketPort");
+
+var _provider = /*#__PURE__*/_classPrivateFieldLooseKey("provider");
+
+class WebSocketAuthorizerEvent {
+  constructor(connectionId, request, provider, options) {
+    Object.defineProperty(this, _connectionId, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _httpsProtocol, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _rawHeaders, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _url, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _websocketPort, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _provider, {
+      writable: true,
+      value: null
+    });
+    const {
+      httpsProtocol,
+      websocketPort
+    } = options;
+    const {
+      rawHeaders,
+      url
+    } = request;
+    _classPrivateFieldLooseBase(this, _connectionId)[_connectionId] = connectionId;
+    _classPrivateFieldLooseBase(this, _httpsProtocol)[_httpsProtocol] = httpsProtocol;
+    _classPrivateFieldLooseBase(this, _rawHeaders)[_rawHeaders] = rawHeaders;
+    _classPrivateFieldLooseBase(this, _url)[_url] = url;
+    _classPrivateFieldLooseBase(this, _websocketPort)[_websocketPort] = websocketPort;
+    _classPrivateFieldLooseBase(this, _provider)[_provider] = provider;
+  }
+
+  create() {
+    const headers = (0, _index.parseHeaders)(_classPrivateFieldLooseBase(this, _rawHeaders)[_rawHeaders]);
+    const multiValueHeaders = (0, _index.parseMultiValueHeaders)(_classPrivateFieldLooseBase(this, _rawHeaders)[_rawHeaders]);
+    const multiValueQueryStringParameters = (0, _index.parseMultiValueQueryStringParameters)(_classPrivateFieldLooseBase(this, _url)[_url]);
+    const queryStringParameters = (0, _index.parseQueryStringParameters)(_classPrivateFieldLooseBase(this, _url)[_url]);
+    const requestContext = new _WebSocketRequestContext.default('CONNECT', '$connect', _classPrivateFieldLooseBase(this, _connectionId)[_connectionId]).create();
+    return {
+      type: 'REQUEST',
+      methodArn: `arn:aws:execute-api:${_classPrivateFieldLooseBase(this, _provider)[_provider].region}:${requestContext.accountId}:${requestContext.apiId}/${requestContext.stage}/${requestContext.routeKey}`,
+      headers,
+      multiValueHeaders,
+      // NOTE: multiValueQueryStringParameters and queryStringParameters
+      // properties are only defined if they have values
+      ...(multiValueQueryStringParameters && {
+        multiValueQueryStringParameters
+      }),
+      ...(queryStringParameters && {
+        queryStringParameters
+      }),
+      requestContext
+    };
+  }
+
+}
+
+exports.default = WebSocketAuthorizerEvent;

package/dist/events/websocket/lambda-events/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "WebSocketAuthorizerEvent", {
+  enumerable: true,
+  get: function () {
+    return _WebSocketAuthorizerEvent.default;
+  }
+});
 Object.defineProperty(exports, "WebSocketConnectEvent", {
   enumerable: true,
   get: function () {
@@ -28,4 +34,6 @@ var _WebSocketDisconnectEvent = _interopRequireDefault(require("./WebSocketDisco
 
 var _WebSocketEvent = _interopRequireDefault(require("./WebSocketEvent.js"));
 
+var _WebSocketAuthorizerEvent = _interopRequireDefault(require("./WebSocketAuthorizerEvent.js"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/lambda/LambdaFunction.js

@@ -177,7 +177,7 @@ class LambdaFunction {
       name,
       package: functionPackage = {}
     } = functionDefinition;
-    const [handlerPath, handlerName] = (0, _index3.splitHandlerPathAndName)(handler);
+    const [handlerPath, handlerName, handlerModuleNesting] = (0, _index3.splitHandlerPathAndName)(handler);
     const memorySize = functionDefinition.memorySize || provider.memorySize || _index2.DEFAULT_LAMBDA_MEMORY_SIZE;
     const runtime = functionDefinition.runtime || provider.runtime || _index2.DEFAULT_LAMBDA_RUNTIME;
     const timeout = (functionDefinition.timeout || provider.timeout || _index2.DEFAULT_LAMBDA_TIMEOUT) * 1000; // this._executionTimeout = null
@@ -212,6 +212,7 @@ class LambdaFunction {
       functionKey,
       handler,
       handlerName,
+      handlerModuleNesting,
       codeDir: _classPrivateFieldLooseBase(this, _codeDir)[_codeDir],
       handlerPath: (0, _path.resolve)(_classPrivateFieldLooseBase(this, _codeDir)[_codeDir], handlerPath),
       runtime,
@@ -269,7 +270,7 @@ class LambdaFunction {
       LAMBDA_RUNTIME_DIR: '/var/runtime',
       LAMBDA_TASK_ROOT: '/var/task',
       LANG: 'en_US.UTF-8',
-      LD_LIBRARY_PATH: '/usr/local/lib64/node-v4.3.x/lib:/lib64:/usr/lib64:/var/runtime:/var/runtime/lib:/var/task:/var/task/lib',
+      LD_LIBRARY_PATH: '/usr/local/lib64/node-v4.3.x/lib:/lib64:/usr/lib64:/var/runtime:/var/runtime/lib:/var/task:/var/task/lib:/opt/lib',
       NODE_PATH: '/var/runtime:/var/task:/var/runtime/node_modules'
     };
   }

package/dist/lambda/handler-runner/HandlerRunner.js

@@ -75,6 +75,7 @@ class HandlerRunner {
       functionKey,
       handlerName,
       handlerPath,
+      handlerModuleNesting,
       runtime,
       timeout
     } = _classPrivateFieldLooseBase(this, _funOptions)[_funOptions];
@@ -141,7 +142,7 @@ class HandlerRunner {
       const {
         default: InProcessRunner
       } = await Promise.resolve().then(() => _interopRequireWildcard(require('./in-process-runner/index.js')));
-      return new InProcessRunner(functionKey, handlerPath, handlerName, _classPrivateFieldLooseBase(this, _env)[_env], timeout, allowCache);
+      return new InProcessRunner(functionKey, handlerPath, handlerName, handlerModuleNesting, _classPrivateFieldLooseBase(this, _env)[_env], timeout, allowCache);
     }
 
     if (_index.supportedGo.has(runtime)) {

package/dist/lambda/handler-runner/child-process-runner/ChildProcessRunner.js

@@ -27,6 +27,8 @@ var _handlerName = /*#__PURE__*/_classPrivateFieldLooseKey("handlerName");
 
 var _handlerPath = /*#__PURE__*/_classPrivateFieldLooseKey("handlerPath");
 
+var _handlerModuleNesting = /*#__PURE__*/_classPrivateFieldLooseKey("handlerModuleNesting");
+
 var _timeout = /*#__PURE__*/_classPrivateFieldLooseKey("timeout");
 
 var _allowCache = /*#__PURE__*/_classPrivateFieldLooseKey("allowCache");
@@ -49,6 +51,10 @@ class ChildProcessRunner {
       writable: true,
       value: null
     });
+    Object.defineProperty(this, _handlerModuleNesting, {
+      writable: true,
+      value: null
+    });
     Object.defineProperty(this, _timeout, {
       writable: true,
       value: null
@@ -61,6 +67,7 @@ class ChildProcessRunner {
       functionKey,
       handlerName,
       handlerPath,
+      handlerModuleNesting,
       timeout
     } = funOptions;
 
@@ -75,6 +82,7 @@ class ChildProcessRunner {
     _classPrivateFieldLooseBase(this, _functionKey)[_functionKey] = functionKey;
     _classPrivateFieldLooseBase(this, _handlerName)[_handlerName] = handlerName;
     _classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath] = handlerPath;
+    _classPrivateFieldLooseBase(this, _handlerModuleNesting)[_handlerModuleNesting] = handlerModuleNesting;
     _classPrivateFieldLooseBase(this, _timeout)[_timeout] = timeout;
     _classPrivateFieldLooseBase(this, _allowCache)[_allowCache] = allowCache;
   } // no-op
@@ -84,7 +92,7 @@ class ChildProcessRunner {
   cleanup() {}
 
   async run(event, context) {
-    const childProcess = (0, _execa.node)(childProcessHelperPath, [_classPrivateFieldLooseBase(this, _functionKey)[_functionKey], _classPrivateFieldLooseBase(this, _handlerName)[_handlerName], _classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath]], {
+    const childProcess = (0, _execa.node)(childProcessHelperPath, [_classPrivateFieldLooseBase(this, _functionKey)[_functionKey], _classPrivateFieldLooseBase(this, _handlerName)[_handlerName], _classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath], _classPrivateFieldLooseBase(this, _handlerModuleNesting)[_handlerModuleNesting]], {
       env: _classPrivateFieldLooseBase(this, _env)[_env],
       stdio: 'inherit'
     });

package/dist/lambda/handler-runner/docker-runner/DockerContainer.js

@@ -244,7 +244,10 @@ class DockerContainer {
       // Add `host.docker.internal` DNS name to access host from inside the container
       // https://github.com/docker/for-linux/issues/264
       const gatewayIp = await this._getBridgeGatewayIp();
-      dockerArgs.push('--add-host', `host.docker.internal:${gatewayIp}`);
+
+      if (gatewayIp) {
+        dockerArgs.push('--add-host', `host.docker.internal:${gatewayIp}`);
+      }
     }
 
     if (_classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions].network) {

package/dist/lambda/handler-runner/in-process-runner/InProcessRunner.js

@@ -58,8 +58,8 @@ const clearModule = (fP, opts) => {
     delete require.cache[filePath];
 
     for (const c of cld) {
-      // Unload any non node_modules children
-      if (!c.filename.match(/node_modules/)) {
+      // Unload any non node_modules and non-binary children
+      if (!c.filename.match(/\/node_modules\//i) && !c.filename.match(/\.node$/i)) {
         clearModule(c.id, { ...options,
           cleanup: false
         });
@@ -74,7 +74,7 @@ const clearModule = (fP, opts) => {
         cleanup = false;
 
         for (const fn of Object.keys(require.cache)) {
-          if (require.cache[fn] && require.cache[fn].id !== '.' && require.cache[fn].parent && require.cache[fn].parent.id !== '.' && !require.cache[require.cache[fn].parent.id]) {
+          if (require.cache[fn] && require.cache[fn].id !== '.' && require.cache[fn].parent && require.cache[fn].parent.id !== '.' && !require.cache[require.cache[fn].parent.id] && !fn.match(/\/node_modules\//i) && !fn.match(/\.node$/i)) {
             delete require.cache[fn];
             cleanup = true;
           }
@@ -92,12 +92,14 @@ var _handlerName = /*#__PURE__*/_classPrivateFieldLooseKey("handlerName");
 
 var _handlerPath = /*#__PURE__*/_classPrivateFieldLooseKey("handlerPath");
 
+var _handlerModuleNesting = /*#__PURE__*/_classPrivateFieldLooseKey("handlerModuleNesting");
+
 var _timeout = /*#__PURE__*/_classPrivateFieldLooseKey("timeout");
 
 var _allowCache = /*#__PURE__*/_classPrivateFieldLooseKey("allowCache");
 
 class InProcessRunner {
-  constructor(functionKey, handlerPath, handlerName, env, timeout, allowCache) {
+  constructor(functionKey, handlerPath, handlerName, handlerModuleNesting, env, timeout, allowCache) {
     Object.defineProperty(this, _env, {
       writable: true,
       value: null
@@ -114,6 +116,10 @@ class InProcessRunner {
       writable: true,
       value: null
     });
+    Object.defineProperty(this, _handlerModuleNesting, {
+      writable: true,
+      value: null
+    });
     Object.defineProperty(this, _timeout, {
       writable: true,
       value: null
@@ -126,6 +132,7 @@ class InProcessRunner {
     _classPrivateFieldLooseBase(this, _functionKey)[_functionKey] = functionKey;
     _classPrivateFieldLooseBase(this, _handlerName)[_handlerName] = handlerName;
     _classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath] = handlerPath;
+    _classPrivateFieldLooseBase(this, _handlerModuleNesting)[_handlerModuleNesting] = handlerModuleNesting;
     _classPrivateFieldLooseBase(this, _timeout)[_timeout] = timeout;
     _classPrivateFieldLooseBase(this, _allowCache)[_allowCache] = allowCache;
   } // no-op
@@ -152,9 +159,17 @@ class InProcessRunner {
       });
     }
 
-    const {
-      [_classPrivateFieldLooseBase(this, _handlerName)[_handlerName]]: handler
-    } = await Promise.resolve(`${_classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath]}`).then(s => _interopRequireWildcard(require(s)));
+    let handler;
+
+    try {
+      const handlerPathExport = await Promise.resolve(`${_classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath]}`).then(s => _interopRequireWildcard(require(s))); // this supports handling of nested handler paths like <pathToFile>/<fileName>.object1.object2.object3.handler
+      // a use case for this, is when the handler is further down the export tree or in nested objects
+      // NOTE: this feature is supported in AWS Lambda
+
+      handler = _classPrivateFieldLooseBase(this, _handlerModuleNesting)[_handlerModuleNesting].reduce((obj, key) => obj[key], handlerPathExport);
+    } catch (error) {
+      throw new Error(`offline: one of the module nesting ${_classPrivateFieldLooseBase(this, _handlerModuleNesting)[_handlerModuleNesting]} for handler ${_classPrivateFieldLooseBase(this, _handlerName)[_handlerName]} is undefined or not exported`);
+    }
 
     if (typeof handler !== 'function') {
       throw new Error(`offline: handler '${_classPrivateFieldLooseBase(this, _handlerName)[_handlerName]}' in ${_classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath]} is not a function`);

package/dist/lambda/handler-runner/java-runner/JavaRunner.js

@@ -116,8 +116,7 @@ class JavaRunner {
         data: input,
         function: _classPrivateFieldLooseBase(this, _functionName)[_functionName],
         jsonOutput: true,
-        serverlessOffline: true,
-        allowCache: _classPrivateFieldLooseBase(this, _allowCache)[_allowCache]
+        serverlessOffline: true
       });
       const httpOptions = {
         method: 'POST',

package/dist/lambda/handler-runner/ruby-runner/RubyRunner.js

@@ -138,8 +138,6 @@ class RubyRunner {
       } else {
         console.log(stderr);
       }
-
-      return stderr;
     }
 
     return this._parsePayload(stdout);

package/dist/lambda/handler-runner/worker-thread-runner/WorkerThreadRunner.js

@@ -39,6 +39,7 @@ class WorkerThreadRunner {
       functionKey,
       handlerName,
       handlerPath,
+      handlerModuleNesting,
       timeout
     } = funOptions;
     _classPrivateFieldLooseBase(this, _allowCache)[_allowCache] = allowCache;
@@ -49,6 +50,7 @@ class WorkerThreadRunner {
         functionKey,
         handlerName,
         handlerPath,
+        handlerModuleNesting,
         timeout
       }
     });

package/dist/lambda/handler-runner/worker-thread-runner/workerThreadHelper.js

@@ -10,7 +10,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const {
   functionKey,
   handlerName,
-  handlerPath
+  handlerPath,
+  handlerModuleNesting
 } = _worker_threads.workerData;
 
 _worker_threads.parentPort.on('message', async messageData => {
@@ -22,7 +23,7 @@ _worker_threads.parentPort.on('message', async messageData => {
     allowCache
   } = messageData; // TODO we could probably cache this in the module scope?
 
-  const inProcessRunner = new _index.default(functionKey, handlerPath, handlerName, process.env, timeout, allowCache);
+  const inProcessRunner = new _index.default(functionKey, handlerPath, handlerName, handlerModuleNesting, process.env, timeout, allowCache);
   const result = await inProcessRunner.run(event, context); // TODO check serializeability (contains function, symbol etc)
 
   port.postMessage(result);

package/dist/utils/splitHandlerPathAndName.js

@@ -8,18 +8,18 @@ exports.default = splitHandlerPathAndName;
 // some-folder/src.index => some-folder/src
 function splitHandlerPathAndName(handler) {
   // Split handler into method name and path i.e. handler.run
-  // Support Ruby paths with namespace resolution operators e.g.
+  const prepathDelimiter = handler.lastIndexOf('/');
+  const prepath = handler.substr(0, prepathDelimiter + 1); // include '/' for path
+
+  const postpath = handler.substr(prepathDelimiter + 1); // Support Ruby paths with namespace resolution operators e.g.
   //  ./src/somefolder/source.LambdaFunctions::Handler.process
   //  prepath: ./src/somefolder/
   //  postpath: source.LambdaFunctions::Handler.process
   //  filename: source
   //  path: ./src/somefolder/source
   //  name: LambdaFunctions::Handler.process
-  if (handler.match(/::/)) {
-    const prepathDelimiter = handler.lastIndexOf('/');
-    const prepath = handler.substr(0, prepathDelimiter + 1); // include '/' for path
 
-    const postpath = handler.substr(prepathDelimiter + 1);
+  if (handler.match(/::/)) {
     const nameDelimiter = postpath.indexOf('.');
     const filename = postpath.substr(0, nameDelimiter);
     const path = prepath + filename;
@@ -30,8 +30,12 @@ function splitHandlerPathAndName(handler) {
   //  name: run
 
 
-  const delimiter = handler.lastIndexOf('.');
-  const path = handler.substr(0, delimiter);
-  const name = handler.substr(delimiter + 1);
-  return [path, name];
+  const [filename, ...moduleNesting] = postpath.split('.');
+  const [name] = moduleNesting.slice(-1);
+  const path = prepath + filename; // module nesting has been added to support when the
+  // handler function is buried deep inside of a module
+  // e.g /src/somefoler/handlers/index.layer1.layer2.handler
+  // AWS supports this feature
+
+  return [path, name, moduleNesting];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "main": "dist/main.js",
@@ -117,6 +117,7 @@
     "Kiryl Yermakou (https://github.com/rma4ok)",
     "kobanyan (https://github.com/kobanyan)",
     "Leonardo Alifraco (https://github.com/lalifraco-devspark)",
+    "Leonardo Medici (https://github.com/doclm)",
     "Luke Chavers (https://github.com/vmadman)",
     "Manuel Böhm (https://github.com/boehmers)",
     "Marc Campbell (https://github.com/marccampbell)",
@@ -204,7 +205,7 @@
     "@hapi/boom": "^9.1.4",
     "@hapi/h2o2": "^9.1.0",
     "@hapi/hapi": "^20.2.1",
-    "aws-sdk": "^2.1076.0",
+    "aws-sdk": "^2.1097.0",
     "boxen": "^5.1.2",
     "chalk": "^4.1.2",
     "cuid": "^2.1.8",
@@ -225,21 +226,20 @@
     "p-queue": "^6.6.2",
     "p-retry": "^4.6.1",
     "please-upgrade-node": "^3.2.0",
-    "portfinder": "^1.0.28",
     "semver": "^7.3.5",
     "update-notifier": "^5.1.0",
     "velocityjs": "^2.0.6",
     "ws": "^7.5.7"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.3",
-    "@babel/core": "^7.17.5",
+    "@babel/cli": "^7.17.6",
+    "@babel/core": "^7.17.8",
     "@babel/plugin-proposal-class-properties": "^7.16.7",
     "@babel/plugin-proposal-dynamic-import": "^7.16.7",
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.7",
     "@babel/plugin-proposal-optional-chaining": "^7.16.7",
-    "@babel/plugin-transform-modules-commonjs": "^7.16.8",
-    "@babel/register": "^7.17.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.17.7",
+    "@babel/register": "^7.17.7",
     "archiver": "^5.3.0",
     "babel-eslint": "^10.1.0",
     "copyfiles": "^2.4.1",
@@ -253,9 +253,9 @@
     "jest": "^26.6.3",
     "lint-staged": "^11.2.6",
     "p-map": "^4.0.0",
-    "prettier": "^2.5.1",
+    "prettier": "^2.6.0",
     "rimraf": "^3.0.2",
-    "serverless": "^2.72.2",
+    "serverless": "^2.72.3",
     "standard-version": "^9.3.2"
   },
   "peerDependencies": {