serverless-offline 8.5.0 → 8.8.0

package/dist/events/websocket/WebSocketClients.js

@@ -7,6 +7,8 @@ exports.default = void 0;
 
 var _ws = require("ws");
 
+var _boom = require("@hapi/boom");
+
 var _index = require("./lambda-events/index.js");
 
 var _debugLog = _interopRequireDefault(require("../../debugLog.js"));
@@ -17,6 +19,12 @@ var _index2 = require("../../config/index.js");
 
 var _index3 = require("../../utils/index.js");
 
+var _authFunctionNameExtractor = _interopRequireDefault(require("../authFunctionNameExtractor.js"));
+
+var _authCanExecuteResource = _interopRequireDefault(require("../authCanExecuteResource.js"));
+
+var _authValidateContext = _interopRequireDefault(require("../authValidateContext.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 +44,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 +72,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 +102,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 +188,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 +201,109 @@ 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})`);
+        }
+
+        const validatedContext = (0, _authValidateContext.default)(policy.context, authorizerFunction);
+        if (validatedContext instanceof Error) throw validatedContext;
+
+        _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,
+            ...validatedContext
+          }
+        });
+      } 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);
+        }
+
+        let headers = [];
+        let message;
+
+        if ((0, _boom.isBoom)(err)) {
+          headers = err.output.headers;
+          message = err.output.payload.message;
+        }
+
+        return {
+          verified: false,
+          statusCode: 500,
+          headers,
+          message
+        };
+      }
+    }
+
+    const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+    if (authorizerData) {
+      connectEvent.requestContext.identity = authorizerData.identity;
+      connectEvent.requestContext.authorizer = authorizerData.authorizer;
+    }
+
     const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(route.functionKey);
 
     lambdaFunction.setEvent(connectEvent);
@@ -186,6 +318,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 {
@@ -226,9 +360,19 @@ class WebSocketClients {
       }
     };
 
+    const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+    let authorizedEvent;
+
+    if (authorizerData) {
+      authorizedEvent = event;
+      authorizedEvent.requestContext.identity = authorizerData.identity;
+      authorizedEvent.requestContext.authorizer = authorizerData.authorizer;
+    }
+
     const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(route.functionKey);
 
-    lambdaFunction.setEvent(event);
+    lambdaFunction.setEvent(authorizedEvent || event);
 
     try {
       const {
@@ -290,7 +434,14 @@ class WebSocketClients {
 
       this._clearIdleTimeout(webSocketClient);
 
-      this._processEvent(webSocketClient, connectionId, '$disconnect', disconnectEvent);
+      const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+      if (authorizerData) {
+        disconnectEvent.requestContext.identity = authorizerData.identity;
+        disconnectEvent.requestContext.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 +460,76 @@ class WebSocketClients {
 
       const event = new _index.WebSocketEvent(connectionId, route, message).create();
 
+      const authorizerData = _classPrivateFieldLooseBase(this, _webSocketAuthorizersCache)[_webSocketAuthorizersCache].get(connectionId);
+
+      if (authorizerData) {
+        event.requestContext.identity = authorizerData.identity;
+        event.requestContext.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,10 +537,14 @@ class WebSocketClients {
       definition
     });
 
+    if (!_classPrivateFieldLooseBase(this, _options)[_options].noAuth) {
+      this._configureAuthorization(definition, functionKey);
+    }
+
     if (this.log) {
-      this.log.notice(`route '${definition}'`);
+      this.log.notice(`route '${definition.route} (λ: ${functionKey})'`);
     } else {
-      (0, _serverlessLog.default)(`route '${definition}'`);
+      (0, _serverlessLog.default)(`route '${definition.route} (λ: ${functionKey})'`);
     }
   }
 

package/dist/events/websocket/WebSocketServer.js

@@ -57,10 +57,7 @@ class WebSocketServer {
         req
       }, cb) => {
         const connectionId = (0, _index.createUniqueId)();
-        const {
-          headers
-        } = req;
-        const key = headers['sec-websocket-key'];
+        const key = req.headers['sec-websocket-key'];
 
         if (this.log) {
           this.log.debug(`verifyClient:${key} ${connectionId}`);
@@ -73,11 +70,13 @@ class WebSocketServer {
 
         _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].verifyClient(connectionId, req).then(({
           verified,
-          statusCode
+          statusCode,
+          message,
+          headers
         }) => {
           try {
             if (!verified) {
-              cb(false, statusCode);
+              cb(false, statusCode, message, headers);
               return;
             }
 

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/index.js

@@ -10,10 +10,6 @@ Object.defineProperty(exports, "default", {
   }
 });
 
-require("./checkEngine.js");
-
-require("object.fromentries/auto.js");
-
 var _ServerlessOffline = _interopRequireDefault(require("./ServerlessOffline.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/lambda/HttpServer.js

@@ -7,6 +7,8 @@ exports.default = void 0;
 
 var _hapi = require("@hapi/hapi");
 
+var _process = require("process");
+
 var _index = require("./routes/index.js");
 
 var _serverlessLog = _interopRequireDefault(require("../serverlessLog.js"));
@@ -85,7 +87,7 @@ class HttpServer {
         console.error(`Unexpected error while starting serverless-offline lambda server on port ${lambdaPort}:`, err);
       }
 
-      process.exit(1);
+      (0, _process.exit)(1);
     }
 
     if (this.log) {

package/dist/lambda/Lambda.js

@@ -17,6 +17,10 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
+const {
+  assign
+} = Object;
+
 var _httpServer = /*#__PURE__*/_classPrivateFieldLooseKey("httpServer");
 
 var _lambdas = /*#__PURE__*/_classPrivateFieldLooseKey("lambdas");
@@ -88,7 +92,7 @@ class Lambda {
   }
 
   listFunctionNamePairs() {
-    const funcNamePairs = Array.from(_classPrivateFieldLooseBase(this, _lambdaFunctionNamesKeys)[_lambdaFunctionNamesKeys]).reduce((obj, [key, value]) => Object.assign(obj, {
+    const funcNamePairs = Array.from(_classPrivateFieldLooseBase(this, _lambdaFunctionNamesKeys)[_lambdaFunctionNamesKeys]).reduce((obj, [key, value]) => assign(obj, {
       [key]: value
     }), // Be careful! Maps can have non-String keys; object literals can't.
     {});

package/dist/lambda/LambdaFunction.js

@@ -269,7 +269,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

@@ -11,8 +11,6 @@ var _serverlessLog = require("../../serverlessLog.js");
 
 var _index = require("../../config/index.js");
 
-var _index2 = require("../../utils/index.js");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -129,9 +127,6 @@ class HandlerRunner {
       }
 
       if (useWorkerThreads) {
-        // worker threads
-        this._verifyWorkerThreadCompatibility();
-
         const {
           default: WorkerThreadRunner
         } = await Promise.resolve().then(() => _interopRequireWildcard(require('./worker-thread-runner/index.js')));
@@ -174,28 +169,6 @@ class HandlerRunner {
 
 
     throw new Error('Unsupported runtime');
-  }
-
-  _verifyWorkerThreadCompatibility() {
-    const {
-      node: currentVersion
-    } = process.versions;
-    const requiredVersionRange = '>=11.7.0';
-    const versionIsSatisfied = (0, _index2.satisfiesVersionRange)(currentVersion, requiredVersionRange); // we're happy
-
-    if (!versionIsSatisfied) {
-      if (this.log) {
-        this.log.warning(`"worker threads" require node.js version ${requiredVersionRange}, but found version ${currentVersion}.
-         To use this feature you have to update node.js to a later version.
-        `);
-      } else {
-        (0, _serverlessLog.logWarning)(`"worker threads" require node.js version ${requiredVersionRange}, but found version ${currentVersion}.
-         To use this feature you have to update node.js to a later version.
-        `);
-      }
-
-      throw new Error('"worker threads" are not supported with this node.js version');
-    }
   } // TEMP TODO FIXME
 
 

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

@@ -1,11 +1,17 @@
 "use strict";
 
+var _process = _interopRequireWildcard(require("process"));
+
 var _index = _interopRequireDefault(require("../in-process-runner/index.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 // TODO handle this:
-process.on('uncaughtException', err => {
+_process.default.on('uncaughtException', err => {
   const {
     constructor: {
       name
@@ -13,7 +19,8 @@ process.on('uncaughtException', err => {
     message,
     stack
   } = err;
-  process.send({
+
+  _process.default.send({
     // process.send() can't serialize an Error object, so we help it out a bit
     error: {
       constructor: {
@@ -24,8 +31,10 @@ process.on('uncaughtException', err => {
     }
   });
 });
-const [,, functionKey, handlerName, handlerPath] = process.argv;
-process.on('message', async messageData => {
+
+const [,, functionKey, handlerName, handlerPath] = _process.argv;
+
+_process.default.on('message', async messageData => {
   const {
     context,
     event,
@@ -33,8 +42,8 @@ process.on('message', async messageData => {
     timeout
   } = 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, _process.default.env, timeout, allowCache);
   const result = await inProcessRunner.run(event, context); // TODO check serializeability (contains function, symbol etc)
 
-  process.send(result);
+  _process.default.send(result);
 });

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

@@ -43,9 +43,7 @@ const {
   stringify
 } = JSON;
 const {
-  entries
-} = Object;
-const {
+  entries,
   keys
 } = Object;
 
@@ -244,7 +242,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) {
@@ -502,7 +503,7 @@ class DockerContainer {
   }
 
   _getLayersSha256() {
-    return _crypto.default.createHash('sha256').update(JSON.stringify(_classPrivateFieldLooseBase(this, _layers)[_layers])).digest('hex');
+    return _crypto.default.createHash('sha256').update(stringify(_classPrivateFieldLooseBase(this, _layers)[_layers])).digest('hex');
   }
 
   get isRunning() {