serverless-offline 8.4.0 → 8.7.0

package/README.md

@@ -49,6 +49,7 @@ This plugin is updated by its users, I just do maintenance and ensure that PRs a
 - [Custom authorizers](#custom-authorizers)
 - [Remote authorizers](#remote-authorizers)
 - [JWT authorizers](#jwt-authorizers)
+- [Serverless plugin authorizers](#serverless-plugin-authorizers)
 - [Custom headers](#custom-headers)
 - [Environment variables](#environment-variables)
 - [AWS API Gateway Features](#aws-api-gateway-features)
@@ -243,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
 
@@ -360,14 +361,36 @@ defined in the `serverless.yml` can be used to validate the token and scopes in
 the signature of the JWT is not validated with the defined issuer. Since this is a security risk, this feature is
 only enabled with the `--ignoreJWTSignature` flag. Make sure to only set this flag for local development work.
 
+## Serverless plugin authorizers
+
+If your authentication needs are custom and not satisfied by the existing capabilities of the Serverless offline project, you can inject your own authentication strategy. To inject a custom strategy for Lambda invocation, you define a custom variable under `serverless-offline` called `authenticationProvider` in the serverless.yml file. The value of the custom variable will be used to `require(your authenticationProvider value)` where the location is expected to return a function with the following signature.
+
+```js
+module.exports = function (endpoint, functionKey, method, path) {
+  return {
+    name: 'your strategy name',
+    scheme: 'your scheme name',
+
+    getAuthenticateFunction: () => ({
+      async authenticate(request, h) {
+        // your implementation
+      },
+    }),
+  }
+}
+```
+
+A working example of injecting a custom authorization provider can be found in the projects integration tests under the folder `custom-authentication`.
+
 ## Custom headers
 
 You are able to use some custom headers in your request to gain more control over the requestContext object.
 
-| Header                          | Event key                                                   |
-| ------------------------------- | ----------------------------------------------------------- |
-| cognito-identity-id             | event.requestContext.identity.cognitoIdentityId             |
-| cognito-authentication-provider | event.requestContext.identity.cognitoAuthenticationProvider |
+| Header                          | Event key                                                   | Example                                                                           |
+| ------------------------------- | ----------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| cognito-identity-id             | event.requestContext.identity.cognitoIdentityId             |                                                                                   |
+| cognito-authentication-provider | event.requestContext.identity.cognitoAuthenticationProvider |                                                                                   |
+| sls-offline-authorizer-override | event.requestContext.authorizer                             | { "iam": {"cognitoUser": { "amr": ["unauthenticated"], "identityId": "abc123" }}} |
 
 By doing this you are now able to change those values using a custom header. This can help you with easier authentication or retrieving the userId from a `cognitoAuthenticationProvider` value.
 
@@ -508,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
@@ -573,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
 
@@ -744,6 +812,10 @@ We try to follow [Airbnb's JavaScript Style Guide](https://github.com/airbnb/jav
 | :------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------: |
 |                                             [lteacher](https://github.com/lteacher)                                              |                                             [martinmicunda](https://github.com/martinmicunda)                                              |                                             [nori3tsu](https://github.com/nori3tsu)                                             |                                             [ppasmanik](https://github.com/ppasmanik)                                              |                                             [ryanzyy](https://github.com/ryanzyy)                                              |
 
-| [<img alt="m0ppers" src="https://avatars3.githubusercontent.com/u/819421?v=4&s=117" width="117">](https://github.com/m0ppers) | [<img alt="footballencarta" src="https://avatars0.githubusercontent.com/u/1312258?v=4&s=117" width="117">](https://github.com/footballencarta) | [<img alt="bryanvaz" src="https://avatars0.githubusercontent.com/u/9157498?v=4&s=117" width="117">](https://github.com/bryanvaz) | [<img alt="njyjn" src="https://avatars.githubusercontent.com/u/10694375?v=4&s=117" width="117">](https://github.com/njyjn) |
+| [<img alt="m0ppers" src="https://avatars3.githubusercontent.com/u/819421?v=4&s=117" width="117">](https://github.com/m0ppers) | [<img alt="footballencarta" src="https://avatars0.githubusercontent.com/u/1312258?v=4&s=117" width="117">](https://github.com/footballencarta) | [<img alt="bryanvaz" src="https://avatars0.githubusercontent.com/u/9157498?v=4&s=117" width="117">](https://github.com/bryanvaz) | [<img alt="njyjn" src="https://avatars.githubusercontent.com/u/10694375?v=4&s=117" width="117">](https://github.com/njyjn) |                                       |
 | :---------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------: | ------------------------------------- |
 |                                             [m0ppers](https://github.com/m0ppers)                                             |                                             [footballencarta](https://github.com/footballencarta)                                              |                                             [bryanvaz](https://github.com/bryanvaz)                                              |                                             [njyjn](https://github.com/njyjn)                                              | [kdybicz](https://github.com/kdybicz) |
+
+| [<img alt="ericctsf" src="https://avatars.githubusercontent.com/u/42775388?s=400&v=4" width="117">](https://github.com/ericctsf) |     |     |     |     |
+| :------------------------------------------------------------------------------------------------------------------------------: | :-: | :-: | :-: | :-: |
+|                                              [ericctsf](https://github.com/erictsf)                                              |     |     |     |     |

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

@@ -9,13 +9,15 @@ var _buffer = require("buffer");
 
 var _fs = require("fs");
 
-var _path = require("path");
+var pathUtils = _interopRequireWildcard(require("path"));
 
 var _h2o = _interopRequireDefault(require("@hapi/h2o2"));
 
 var _hapi = require("@hapi/hapi");
 
-var _authFunctionNameExtractor = _interopRequireDefault(require("./authFunctionNameExtractor.js"));
+var _module = require("module");
+
+var _authFunctionNameExtractor = _interopRequireDefault(require("../authFunctionNameExtractor.js"));
 
 var _authJWTSettingsExtractor = _interopRequireDefault(require("./authJWTSettingsExtractor.js"));
 
@@ -39,12 +41,12 @@ var _index2 = require("../../utils/index.js");
 
 var _LambdaProxyIntegrationEventV = _interopRequireDefault(require("./lambda-events/LambdaProxyIntegrationEventV2.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; }
 
-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;
@@ -134,8 +136,8 @@ class HttpServer {
 
     if (typeof httpsProtocol === 'string' && httpsProtocol.length > 0) {
       serverOptions.tls = {
-        cert: (0, _fs.readFileSync)((0, _path.resolve)(httpsProtocol, 'cert.pem'), 'ascii'),
-        key: (0, _fs.readFileSync)((0, _path.resolve)(httpsProtocol, 'key.pem'), 'ascii')
+        cert: (0, _fs.readFileSync)((0, pathUtils.resolve)(httpsProtocol, 'cert.pem'), 'ascii'),
+        key: (0, _fs.readFileSync)((0, pathUtils.resolve)(httpsProtocol, 'key.pem'), 'ascii')
       };
     } // Hapijs server creation
 
@@ -428,6 +430,36 @@ class HttpServer {
     return authStrategyName;
   }
 
+  _setAuthorizationStrategy(endpoint, functionKey, method, path) {
+    var _customizations$offli;
+
+    /*
+     *  The authentication strategy can be provided outside of this project
+     *  by injecting the provider through a custom variable in the serverless.yml.
+     *
+     *  see the example in the tests for more details
+     *    /tests/integration/custom-authentication
+     */
+    const customizations = _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.custom;
+
+    if (customizations && (_customizations$offli = customizations.offline) !== null && _customizations$offli !== void 0 && _customizations$offli.customAuthenticationProvider) {
+      const root = pathUtils.resolve(_classPrivateFieldLooseBase(this, _serverless)[_serverless].serviceDir, 'require-resolver');
+      const customRequire = (0, _module.createRequire)(root);
+      const provider = customRequire(customizations.offline.customAuthenticationProvider);
+      const strategy = provider(endpoint, functionKey, method, path);
+
+      _classPrivateFieldLooseBase(this, _server)[_server].auth.scheme(strategy.scheme, strategy.getAuthenticateFunction);
+
+      _classPrivateFieldLooseBase(this, _server)[_server].auth.strategy(strategy.name, strategy.scheme);
+
+      return strategy.name;
+    } // If the endpoint has an authorization function, create an authStrategy for the route
+
+
+    const authStrategyName = _classPrivateFieldLooseBase(this, _options)[_options].noAuth ? null : this._configureJWTAuthorization(endpoint, functionKey, method, path) || this._configureAuthorization(endpoint, functionKey, method, path);
+    return authStrategyName;
+  }
+
   createRoutes(functionKey, httpEvent, handler) {
     const [handlerPath] = (0, _index2.splitHandlerPathAndName)(handler);
     let method;
@@ -455,7 +487,7 @@ class HttpServer {
       hapiPath = (0, _index2.generateHapiPath)(path, _classPrivateFieldLooseBase(this, _options)[_options], _classPrivateFieldLooseBase(this, _serverless)[_serverless]);
     }
 
-    const endpoint = new _Endpoint.default((0, _path.join)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].config.servicePath, handlerPath), httpEvent, this.v3Utils);
+    const endpoint = new _Endpoint.default((0, pathUtils.join)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].config.servicePath, handlerPath), httpEvent, this.v3Utils);
     const stage = endpoint.isHttpApi ? '$default' : _classPrivateFieldLooseBase(this, _options)[_options].stage || _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.stage;
     const protectedRoutes = [];
 
@@ -477,10 +509,10 @@ class HttpServer {
       server,
       stage: endpoint.isHttpApi || _classPrivateFieldLooseBase(this, _options)[_options].noPrependStageInUrl ? null : stage,
       invokePath: `/2015-03-31/functions/${functionKey}/invocations`
-    }); // If the endpoint has an authorization function, create an authStrategy for the route
+    });
 
+    const authStrategyName = this._setAuthorizationStrategy(endpoint, functionKey, method, path);
 
-    const authStrategyName = _classPrivateFieldLooseBase(this, _options)[_options].noAuth ? null : this._configureJWTAuthorization(endpoint, functionKey, method, path) || this._configureAuthorization(endpoint, functionKey, method, path);
     let cors = null;
 
     if (endpoint.cors) {
@@ -538,6 +570,12 @@ class HttpServer {
       };
     }
 
+    const additionalRequestContext = {};
+
+    if (httpEvent.operationId) {
+      additionalRequestContext.operationName = httpEvent.operationId;
+    }
+
     hapiOptions.tags = ['api'];
 
     const hapiHandler = async (request, h) => {
@@ -682,7 +720,7 @@ class HttpServer {
         }
       } else if (integration === 'AWS_PROXY') {
         const stageVariables = _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.custom ? _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.custom.stageVariables : null;
-        const lambdaProxyIntegrationEvent = endpoint.isHttpApi && endpoint.payload === '2.0' ? new _LambdaProxyIntegrationEventV.default(request, stage, endpoint.routeKey, stageVariables, this.v3Utils) : new _index.LambdaProxyIntegrationEvent(request, stage, requestPath, stageVariables, endpoint.isHttpApi ? endpoint.routeKey : null, this.v3Utils);
+        const lambdaProxyIntegrationEvent = endpoint.isHttpApi && endpoint.payload === '2.0' ? new _LambdaProxyIntegrationEventV.default(request, stage, endpoint.routeKey, stageVariables, additionalRequestContext, this.v3Utils) : new _index.LambdaProxyIntegrationEvent(request, stage, requestPath, stageVariables, endpoint.isHttpApi ? endpoint.routeKey : null, additionalRequestContext, this.v3Utils);
         event = lambdaProxyIntegrationEvent.create();
       }
 

package/dist/events/http/authValidateContext.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = authValidateContext;
+
+var _boom = _interopRequireDefault(require("@hapi/boom"));
+
+var _serverlessLog = _interopRequireDefault(require("../../serverlessLog.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function internalServerError(message) {
+  const errorType = 'AuthorizerConfigurationException';
+
+  const error = _boom.default.internal();
+
+  error.output.payload.message = message;
+  error.output.payload.error = errorType;
+  error.output.headers['x-amzn-ErrorType'] = errorType;
+  return error;
+}
+
+function isValidContext(context) {
+  return Object.values(context).every(i => typeof i === 'string' || typeof i === 'boolean' || typeof i === 'number');
+}
+
+function transform(context) {
+  Object.keys(context).forEach(i => {
+    context[i] = context[i].toString();
+  });
+  return context;
+}
+
+function authValidateContext(context, authFunName) {
+  if (typeof context !== 'object') {
+    return internalServerError('Authorizer response context must be an object');
+  }
+
+  if (!isValidContext(context)) {
+    const error = 'Authorizer response context values must be of type string, number, or boolean';
+    (0, _serverlessLog.default)(`Detected invalid value types returned in authorizer context: (λ: ${authFunName}). ${error}. ` + 'More info: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-lambda-authorizer-output.html');
+    return internalServerError(error);
+  }
+
+  return transform(context);
+}

package/dist/events/http/createAuthScheme.js

@@ -7,7 +7,9 @@ exports.default = createAuthScheme;
 
 var _boom = _interopRequireDefault(require("@hapi/boom"));
 
-var _authCanExecuteResource = _interopRequireDefault(require("./authCanExecuteResource.js"));
+var _authCanExecuteResource = _interopRequireDefault(require("../authCanExecuteResource.js"));
+
+var _authValidateContext = _interopRequireDefault(require("./authValidateContext.js"));
 
 var _debugLog = _interopRequireDefault(require("../../debugLog.js"));
 
@@ -113,11 +115,9 @@ function createAuthScheme(authorizerOptions, provider, lambda, {
 
       try {
         const result = await lambdaFunction.runHandler();
-        if (result === 'Unauthorized') return _boom.default.unauthorized('Unauthorized'); // return processResponse(null, result)
-
-        const policy = result; // Validate that the policy document has the principalId set
+        if (result === 'Unauthorized') return _boom.default.unauthorized('Unauthorized'); // Validate that the policy document has the principalId set
 
-        if (!policy.principalId) {
+        if (!result.principalId) {
           if (log) {
             log.notice(`Authorization response did not include a principalId: (λ: ${authFunName})`);
           } else {
@@ -127,7 +127,7 @@ function createAuthScheme(authorizerOptions, provider, lambda, {
           return _boom.default.forbidden('No principalId set on the Response');
         }
 
-        if (!(0, _authCanExecuteResource.default)(policy.policyDocument, event.methodArn)) {
+        if (!(0, _authCanExecuteResource.default)(result.policyDocument, event.methodArn)) {
           if (log) {
             log.notice(`Authorization response didn't authorize user to access resource: (λ: ${authFunName})`);
           } else {
@@ -135,6 +135,18 @@ function createAuthScheme(authorizerOptions, provider, lambda, {
           }
 
           return _boom.default.forbidden('User is not authorized to access this resource');
+        } // validate the resulting context, ensuring that all
+        // values are either string, number, or boolean types
+
+
+        if (result.context) {
+          const validationResult = (0, _authValidateContext.default)(result.context, authFunName);
+
+          if (validationResult instanceof Error) {
+            return validationResult;
+          }
+
+          result.context = validationResult;
         }
 
         if (log) {
@@ -145,17 +157,16 @@ function createAuthScheme(authorizerOptions, provider, lambda, {
 
         const authorizer = {
           integrationLatency: '42',
-          principalId: policy.principalId,
-          ...policy.context
+          principalId: result.principalId,
+          ...result.context
         }; // Set the credentials for the rest of the pipeline
-        // return resolve(
 
         return h.authenticated({
           credentials: {
             authorizer,
-            context: policy.context,
-            principalId: policy.principalId,
-            usageIdentifierKey: policy.usageIdentifierKey
+            context: result.context,
+            principalId: result.principalId,
+            usageIdentifierKey: result.usageIdentifierKey
           }
         });
       } catch (err) {

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

@@ -17,6 +17,10 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
+const {
+  parse
+} = JSON;
+
 var _path = /*#__PURE__*/_classPrivateFieldLooseKey("path");
 
 var _request = /*#__PURE__*/_classPrivateFieldLooseKey("request");
@@ -51,6 +55,26 @@ class LambdaIntegrationEvent {
   }
 
   create() {
+    if (process.env.AUTHORIZER) {
+      try {
+        const authorizerContext = parse(process.env.AUTHORIZER);
+
+        if (authorizerContext) {
+          _classPrivateFieldLooseBase(this, _request)[_request].auth = { ..._classPrivateFieldLooseBase(this, _request)[_request].auth,
+            credentials: {
+              authorizer: authorizerContext
+            }
+          };
+        }
+      } catch (error) {
+        if (this.log) {
+          this.log.error('Could not parse process.env.AUTHORIZER, make sure it is correct JSON');
+        } else {
+          console.error('Serverless-offline: Could not parse process.env.AUTHORIZER, make sure it is correct JSON.');
+        }
+      }
+    }
+
     const velocityContext = new _VelocityContext.default(_classPrivateFieldLooseBase(this, _request)[_request], _classPrivateFieldLooseBase(this, _stage)[_stage], _classPrivateFieldLooseBase(this, _request)[_request].payload || {}, _classPrivateFieldLooseBase(this, _path)[_path]).getContext();
     const event = (0, _renderVelocityTemplateObject.default)(_classPrivateFieldLooseBase(this, _requestTemplate)[_requestTemplate], velocityContext, this.v3Utils);
     return event;

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

@@ -39,8 +39,10 @@ var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
 
 var _stageVariables = /*#__PURE__*/_classPrivateFieldLooseKey("stageVariables");
 
+var _additionalRequestContext = /*#__PURE__*/_classPrivateFieldLooseKey("additionalRequestContext");
+
 class LambdaProxyIntegrationEvent {
-  constructor(request, stage, path, stageVariables, routeKey = null, v3Utils) {
+  constructor(request, stage, path, stageVariables, routeKey = null, additionalRequestContext = null, v3Utils) {
     Object.defineProperty(this, _path, {
       writable: true,
       value: null
@@ -61,11 +63,16 @@ class LambdaProxyIntegrationEvent {
       writable: true,
       value: null
     });
+    Object.defineProperty(this, _additionalRequestContext, {
+      writable: true,
+      value: null
+    });
     _classPrivateFieldLooseBase(this, _path)[_path] = path;
     _classPrivateFieldLooseBase(this, _routeKey)[_routeKey] = routeKey;
     _classPrivateFieldLooseBase(this, _request)[_request] = request;
     _classPrivateFieldLooseBase(this, _stage)[_stage] = stage;
     _classPrivateFieldLooseBase(this, _stageVariables)[_stageVariables] = stageVariables;
+    _classPrivateFieldLooseBase(this, _additionalRequestContext)[_additionalRequestContext] = additionalRequestContext || {};
 
     if (v3Utils) {
       this.log = v3Utils.log;
@@ -103,6 +110,18 @@ class LambdaProxyIntegrationEvent {
 
     const headers = (0, _index.parseHeaders)(rawHeaders || []) || {};
 
+    if (headers['sls-offline-authorizer-override']) {
+      try {
+        authAuthorizer = parse(headers['sls-offline-authorizer-override']);
+      } catch (error) {
+        if (this.log) {
+          this.log.error('Could not parse header sls-offline-authorizer-override, make sure it is correct JSON');
+        } else {
+          console.error('Serverless-offline: Could not parse header sls-offline-authorizer-override make sure it is correct JSON.');
+        }
+      }
+    }
+
     if (body) {
       if (typeof body !== 'string') {
         // this.#request.payload is NOT the same as the rawPayload
@@ -205,6 +224,7 @@ class LambdaProxyIntegrationEvent {
           userAgent: _headers['user-agent'] || '',
           userArn: 'offlineContext_userArn'
         },
+        operationName: _classPrivateFieldLooseBase(this, _additionalRequestContext)[_additionalRequestContext].operationName,
         path: _classPrivateFieldLooseBase(this, _path)[_path],
         protocol: 'HTTP/1.1',
         requestId: (0, _index.createUniqueId)(),

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

@@ -36,8 +36,10 @@ var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
 
 var _stageVariables = /*#__PURE__*/_classPrivateFieldLooseKey("stageVariables");
 
+var _additionalRequestContext = /*#__PURE__*/_classPrivateFieldLooseKey("additionalRequestContext");
+
 class LambdaProxyIntegrationEventV2 {
-  constructor(request, stage, routeKey, stageVariables, v3Utils) {
+  constructor(request, stage, routeKey, stageVariables, additionalRequestContext, v3Utils) {
     Object.defineProperty(this, _routeKey, {
       writable: true,
       value: null
@@ -54,10 +56,15 @@ class LambdaProxyIntegrationEventV2 {
       writable: true,
       value: null
     });
+    Object.defineProperty(this, _additionalRequestContext, {
+      writable: true,
+      value: null
+    });
     _classPrivateFieldLooseBase(this, _routeKey)[_routeKey] = routeKey;
     _classPrivateFieldLooseBase(this, _request)[_request] = request;
     _classPrivateFieldLooseBase(this, _stage)[_stage] = stage;
     _classPrivateFieldLooseBase(this, _stageVariables)[_stageVariables] = stageVariables;
+    _classPrivateFieldLooseBase(this, _additionalRequestContext)[_additionalRequestContext] = additionalRequestContext || {};
 
     if (v3Utils) {
       this.log = v3Utils.log;
@@ -92,6 +99,18 @@ class LambdaProxyIntegrationEventV2 {
 
     const headers = (0, _index.parseHeaders)(rawHeaders || []) || {};
 
+    if (headers['sls-offline-authorizer-override']) {
+      try {
+        authAuthorizer = parse(headers['sls-offline-authorizer-override']);
+      } catch (error) {
+        if (this.log) {
+          this.log.error('Could not parse header sls-offline-authorizer-override, make sure it is correct JSON');
+        } else {
+          console.error('Serverless-offline: Could not parse header sls-offline-authorizer-override make sure it is correct JSON.');
+        }
+      }
+    }
+
     if (body) {
       if (typeof body !== 'string') {
         // this.#request.payload is NOT the same as the rawPayload
@@ -150,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],
@@ -177,6 +202,7 @@ class LambdaProxyIntegrationEventV2 {
           sourceIp: remoteAddress,
           userAgent: _headers['user-agent'] || ''
         },
+        operationName: _classPrivateFieldLooseBase(this, _additionalRequestContext)[_additionalRequestContext].operationName,
         requestId: 'offlineContext_resourceId',
         routeKey: _classPrivateFieldLooseBase(this, _routeKey)[_routeKey],
         stage: _classPrivateFieldLooseBase(this, _stage)[_stage],