serverless-offline 8.8.1 → 9.0.0

package/dist/events/http/OfflineEndpoint.js

@@ -1,38 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-class OfflineEndpoint {
-  constructor() {
-    this.apiKeyRequired = false;
-    this.authorizationType = 'none';
-    this.authorizerFunction = false;
-    this.path = '';
-    this.requestParameters = {};
-    this.requestTemplates = {
-      'application/json': ''
-    };
-    this.responses = {
-      default: {
-        400: {
-          statusCode: '400'
-        },
-        responseModels: {
-          'application/json;charset=UTF-8': 'Empty'
-        },
-        responseParameters: {},
-        responseTemplates: {
-          'application/json;charset=UTF-8': ''
-        },
-        statusCode: 200
-      }
-    };
-    this.type = 'AWS';
-  }
-
-}
-
-exports.default = OfflineEndpoint;

package/dist/events/http/authJWTSettingsExtractor.js

@@ -1,76 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = authJWTSettingsExtractor;
-
-var _serverlessLog = _interopRequireDefault(require("../../serverlessLog.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function authJWTSettingsExtractor(endpoint, provider, ignoreJWTSignature, {
-  log
-}) {
-  const buildFailureResult = warningMessage => {
-    if (log) {
-      log.warning(warningMessage);
-    } else {
-      (0, _serverlessLog.default)(`WARNING: ${warningMessage}`);
-    }
-
-    return {
-      unsupportedAuth: true
-    };
-  };
-
-  const buildSuccessResult = authorizerName => ({
-    authorizerName
-  });
-
-  const {
-    authorizer
-  } = endpoint;
-
-  if (!authorizer) {
-    return buildSuccessResult(null);
-  }
-
-  if (!provider.httpApi || !provider.httpApi.authorizers) {
-    return buildSuccessResult(null);
-  } // TODO: add code that will actually validate a JWT.
-
-
-  if (!ignoreJWTSignature) {
-    return buildSuccessResult(null);
-  }
-
-  if (!authorizer.name) {
-    return buildFailureResult('Serverless Offline supports only JWT authorizers referenced by name');
-  }
-
-  const httpApiAuthorizer = provider.httpApi.authorizers[authorizer.name];
-
-  if (!httpApiAuthorizer) {
-    return buildFailureResult(`JWT authorizer ${authorizer.name} not found`);
-  }
-
-  if (!httpApiAuthorizer.identitySource) {
-    return buildFailureResult(`JWT authorizer ${authorizer.name} missing identity source`);
-  }
-
-  if (!httpApiAuthorizer.issuerUrl) {
-    return buildFailureResult(`JWT authorizer ${authorizer.name} missing issuer url`);
-  }
-
-  if (!httpApiAuthorizer.audience || httpApiAuthorizer.audience.length === 0) {
-    return buildFailureResult(`JWT authorizer ${authorizer.name} missing audience`);
-  }
-
-  const result = {
-    authorizerName: authorizer.name,
-    ...authorizer,
-    ...httpApiAuthorizer
-  };
-  return result;
-}

package/dist/events/http/createAuthScheme.js

@@ -1,184 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createAuthScheme;
-
-var _boom = _interopRequireDefault(require("@hapi/boom"));
-
-var _authCanExecuteResource = _interopRequireDefault(require("../authCanExecuteResource.js"));
-
-var _authValidateContext = _interopRequireDefault(require("../authValidateContext.js"));
-
-var _debugLog = _interopRequireDefault(require("../../debugLog.js"));
-
-var _serverlessLog = _interopRequireDefault(require("../../serverlessLog.js"));
-
-var _index = require("../../utils/index.js");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function createAuthScheme(authorizerOptions, provider, lambda, {
-  log
-}) {
-  const authFunName = authorizerOptions.name;
-  let identityHeader = 'authorization';
-
-  if (authorizerOptions.type !== 'request') {
-    const identitySourceMatch = /^method.request.header.((?:\w+-?)+\w+)$/.exec(authorizerOptions.identitySource);
-
-    if (!identitySourceMatch || identitySourceMatch.length !== 2) {
-      throw new Error(`Serverless Offline only supports retrieving tokens from the headers (λ: ${authFunName})`);
-    }
-
-    identityHeader = identitySourceMatch[1].toLowerCase();
-  } // Create Auth Scheme
-
-
-  return () => ({
-    async authenticate(request, h) {
-      if (log) {
-        log.notice();
-        log.notice(`Running Authorization function for ${request.method} ${request.path} (λ: ${authFunName})`);
-      } else {
-        console.log(''); // Just to make things a little pretty
-
-        (0, _serverlessLog.default)(`Running Authorization function for ${request.method} ${request.path} (λ: ${authFunName})`);
-      } // Get Authorization header
-
-
-      const {
-        req
-      } = request.raw; // Get path params
-      // aws doesn't auto decode path params - hapi does
-
-      const pathParams = { ...request.params
-      };
-      const accountId = 'random-account-id';
-      const apiId = 'random-api-id';
-      const httpMethod = request.method.toUpperCase();
-      const resourcePath = request.route.path.replace(new RegExp(`^/${provider.stage}`), '');
-      let event = {
-        enhancedAuthContext: {},
-        methodArn: `arn:aws:execute-api:${provider.region}:${accountId}:${apiId}/${provider.stage}/${httpMethod}${resourcePath}`,
-        requestContext: {
-          accountId,
-          apiId,
-          httpMethod,
-          requestId: 'random-request-id',
-          resourceId: 'random-resource-id',
-          resourcePath,
-          path: request.path,
-          stage: provider.stage
-        },
-        resource: resourcePath
-      }; // Create event Object for authFunction
-      //   methodArn is the ARN of the function we are running we are authorizing access to (or not)
-      //   Account ID and API ID are not simulated
-
-      if (authorizerOptions.type === 'request') {
-        const {
-          rawHeaders,
-          url
-        } = req;
-        event = { ...event,
-          headers: (0, _index.parseHeaders)(rawHeaders),
-          httpMethod: request.method.toUpperCase(),
-          multiValueHeaders: (0, _index.parseMultiValueHeaders)(rawHeaders),
-          multiValueQueryStringParameters: (0, _index.parseMultiValueQueryStringParameters)(url),
-          path: request.path,
-          pathParameters: (0, _index.nullIfEmpty)(pathParams),
-          queryStringParameters: (0, _index.parseQueryStringParameters)(url),
-          type: 'REQUEST'
-        };
-      } else {
-        const authorization = req.headers[identityHeader];
-        const identityValidationExpression = new RegExp(authorizerOptions.identityValidationExpression);
-        const matchedAuthorization = identityValidationExpression.test(authorization);
-        const finalAuthorization = matchedAuthorization ? authorization : '';
-
-        if (log) {
-          log.debug(`Retrieved ${identityHeader} header "${finalAuthorization}"`);
-        } else {
-          (0, _debugLog.default)(`Retrieved ${identityHeader} header "${finalAuthorization}"`);
-        }
-
-        event = { ...event,
-          authorizationToken: finalAuthorization,
-          type: 'TOKEN'
-        };
-      }
-
-      const lambdaFunction = lambda.get(authFunName);
-      lambdaFunction.setEvent(event);
-
-      try {
-        const result = await lambdaFunction.runHandler();
-        if (result === 'Unauthorized') return _boom.default.unauthorized('Unauthorized'); // Validate that the policy document has the principalId set
-
-        if (!result.principalId) {
-          if (log) {
-            log.notice(`Authorization response did not include a principalId: (λ: ${authFunName})`);
-          } else {
-            (0, _serverlessLog.default)(`Authorization response did not include a principalId: (λ: ${authFunName})`);
-          }
-
-          return _boom.default.forbidden('No principalId set on the Response');
-        }
-
-        if (!(0, _authCanExecuteResource.default)(result.policyDocument, event.methodArn)) {
-          if (log) {
-            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 _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) {
-          log.notice(`Authorization function returned a successful response: (λ: ${authFunName})`);
-        } else {
-          (0, _serverlessLog.default)(`Authorization function returned a successful response: (λ: ${authFunName})`);
-        }
-
-        const authorizer = {
-          integrationLatency: '42',
-          principalId: result.principalId,
-          ...result.context
-        }; // Set the credentials for the rest of the pipeline
-
-        return h.authenticated({
-          credentials: {
-            authorizer,
-            context: result.context,
-            principalId: result.principalId,
-            usageIdentifierKey: result.usageIdentifierKey
-          }
-        });
-      } catch (err) {
-        if (log) {
-          log.notice(`Authorization function returned an error response: (λ: ${authFunName})`);
-        } else {
-          (0, _serverlessLog.default)(`Authorization function returned an error response: (λ: ${authFunName})`);
-        }
-
-        return _boom.default.unauthorized('Unauthorized');
-      }
-    }
-
-  });
-}

package/dist/events/http/createJWTAuthScheme.js

@@ -1,159 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createAuthScheme;
-
-var _boom = _interopRequireDefault(require("@hapi/boom"));
-
-var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
-
-var _serverlessLog = _interopRequireDefault(require("../../serverlessLog.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const {
-  isArray
-} = Array;
-
-function createAuthScheme(jwtOptions, {
-  log
-}) {
-  const authorizerName = jwtOptions.name;
-  const identitySourceMatch = /^\$request.header.((?:\w+-?)+\w+)$/.exec(jwtOptions.identitySource);
-
-  if (!identitySourceMatch || identitySourceMatch.length !== 2) {
-    throw new Error(`Serverless Offline only supports retrieving JWT from the headers (${authorizerName})`);
-  }
-
-  const identityHeader = identitySourceMatch[1].toLowerCase(); // Create Auth Scheme
-
-  return () => ({
-    async authenticate(request, h) {
-      if (log) {
-        log.notice();
-        log.notice(`Running JWT Authorization function for ${request.method} ${request.path} (${authorizerName})`);
-      } else {
-        console.log(''); // Just to make things a little pretty
-        // TODO: this only validates specific properties of the JWT
-        // it does not verify the JWT is correctly signed. That would
-        // be a great feature to add under an optional flag :)
-
-        (0, _serverlessLog.default)(`Running JWT Authorization function for ${request.method} ${request.path} (${authorizerName})`);
-      } // Get Authorization header
-
-
-      const {
-        req
-      } = request.raw;
-      let jwtToken = req.headers[identityHeader];
-
-      if (jwtToken && jwtToken.split(' ')[0] === 'Bearer') {
-        ;
-        [, jwtToken] = jwtToken.split(' ');
-      }
-
-      try {
-        const decoded = _jsonwebtoken.default.decode(jwtToken, {
-          complete: true
-        });
-
-        if (!decoded) {
-          return _boom.default.unauthorized('JWT not decoded');
-        }
-
-        const expirationDate = new Date(decoded.payload.exp * 1000);
-
-        if (expirationDate.valueOf() < Date.now()) {
-          return _boom.default.unauthorized('JWT Token expired');
-        }
-
-        const {
-          iss,
-          aud,
-          scope
-        } = decoded.payload;
-        const clientId = decoded.payload.client_id;
-
-        if (iss !== jwtOptions.issuerUrl) {
-          if (log) {
-            log.notice(`JWT Token not from correct issuer url`);
-          } else {
-            (0, _serverlessLog.default)(`JWT Token not from correct issuer url`);
-          }
-
-          return _boom.default.unauthorized('JWT Token not from correct issuer url');
-        }
-
-        const validAudiences = isArray(jwtOptions.audience) ? jwtOptions.audience : [jwtOptions.audience];
-        const providedAudiences = isArray(aud) ? aud : [aud];
-        const validAudienceProvided = providedAudiences.some(a => validAudiences.includes(a));
-
-        if (!validAudienceProvided && !validAudiences.includes(clientId)) {
-          if (log) {
-            log.notice(`JWT Token does not contain correct audience`);
-          } else {
-            (0, _serverlessLog.default)(`JWT Token does not contain correct audience`);
-          }
-
-          return _boom.default.unauthorized('JWT Token does not contain correct audience');
-        }
-
-        let scopes = null;
-
-        if (jwtOptions.scopes && jwtOptions.scopes.length) {
-          if (!scope) {
-            if (log) {
-              log.notice(`JWT Token missing valid scope`);
-            } else {
-              (0, _serverlessLog.default)(`JWT Token missing valid scope`);
-            }
-
-            return _boom.default.forbidden('JWT Token missing valid scope');
-          }
-
-          scopes = scope.split(' ');
-
-          if (scopes.every(s => {
-            return !jwtOptions.scopes.includes(s);
-          })) {
-            if (log) {
-              log.notice(`JWT Token missing valid scope`);
-            } else {
-              (0, _serverlessLog.default)(`JWT Token missing valid scope`);
-            }
-
-            return _boom.default.forbidden('JWT Token missing valid scope');
-          }
-        }
-
-        if (log) {
-          log.notice(`JWT Token validated`);
-        } else {
-          (0, _serverlessLog.default)(`JWT Token validated`);
-        } // Set the credentials for the rest of the pipeline
-        // return resolve(
-
-
-        return h.authenticated({
-          credentials: {
-            claims: decoded.payload,
-            scopes
-          }
-        });
-      } catch (err) {
-        if (log) {
-          log.notice(`JWT could not be decoded`);
-          log.error(err);
-        } else {
-          (0, _serverlessLog.default)(`JWT could not be decoded`);
-          (0, _serverlessLog.default)(err);
-        }
-
-        return _boom.default.unauthorized('Unauthorized');
-      }
-    }
-
-  });
-}

package/dist/events/http/index.js

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function () {
-    return _Http.default;
-  }
-});
-
-var _Http = _interopRequireDefault(require("./Http.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/events/http/javaHelpers.js

@@ -1,99 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = runInPollutedScope;
-
-// String functions
-// For velocity templates to access java functions, to mimick AWS
-function javaContains(value) {
-  return this.includes(value);
-}
-
-function javaEquals(anObject) {
-  return this.toString() === anObject.toString();
-}
-
-function javaEqualsIgnoreCase(anotherString) {
-  return anotherString === null ? false : this === anotherString || this.toLowerCase() === anotherString.toLowerCase();
-}
-
-function javaMatches(value) {
-  return this.match(new RegExp(value, 'm'));
-}
-
-function javaReplaceAll(oldValue, newValue) {
-  return this.replace(new RegExp(oldValue, 'gm'), newValue);
-}
-
-function javaReplaceFirst(oldValue, newValue) {
-  return this.replace(new RegExp(oldValue, 'm'), newValue);
-} // method has 2 function signatures:
-// regionMatches(toffset: number, other: string, ooffset: number, len: number): boolean
-// regionMatches(ignoreCase: boolean, toffset: number, other: string, ooffset: number, len: number): boolean
-
-
-function javaRegionMatches(...args) {
-  let ignoreCase;
-  let toffset;
-  let other;
-  let ooffset;
-  let len;
-
-  if (args.length === 4) {
-    ;
-    [toffset, other, ooffset, len] = args;
-    ignoreCase = false;
-  } else {
-    ;
-    [ignoreCase, toffset, other, ooffset, len] = args;
-  } // Note: toffset, ooffset, or len might be near -1>>>1.
-
-
-  if (ooffset < 0 || toffset < 0 || toffset > this.length - len || ooffset > other.length - len) {
-    return false;
-  }
-
-  let s1 = this.substring(toffset, toffset + len);
-  let s2 = other.substring(ooffset, ooffset + len);
-
-  if (ignoreCase) {
-    s1 = s1.toLowerCase();
-    s2 = s2.toLowerCase();
-  }
-
-  return s1 === s2;
-}
-
-const {
-  prototype,
-  prototype: {
-    contains,
-    equals,
-    equalsIgnoreCase,
-    matches,
-    regionMatches,
-    replaceAll,
-    replaceFirst
-  }
-} = String;
-
-function runInPollutedScope(runScope) {
-  prototype.contains = javaContains;
-  prototype.equals = javaEquals;
-  prototype.equalsIgnoreCase = javaEqualsIgnoreCase;
-  prototype.matches = javaMatches;
-  prototype.regionMatches = javaRegionMatches;
-  prototype.replaceAll = javaReplaceAll;
-  prototype.replaceFirst = javaReplaceFirst;
-  const result = runScope();
-  prototype.contains = contains;
-  prototype.equals = equals;
-  prototype.equalsIgnoreCase = equalsIgnoreCase;
-  prototype.matches = matches;
-  prototype.regionMatches = regionMatches;
-  prototype.replaceAll = replaceAll;
-  prototype.replaceFirst = replaceFirst;
-  return result;
-}

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

@@ -1,87 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _process = require("process");
-
-var _renderVelocityTemplateObject = _interopRequireDefault(require("./renderVelocityTemplateObject.js"));
-
-var _VelocityContext = _interopRequireDefault(require("./VelocityContext.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; }
-
-const {
-  parse
-} = JSON;
-
-var _path = /*#__PURE__*/_classPrivateFieldLooseKey("path");
-
-var _request = /*#__PURE__*/_classPrivateFieldLooseKey("request");
-
-var _requestTemplate = /*#__PURE__*/_classPrivateFieldLooseKey("requestTemplate");
-
-var _stage = /*#__PURE__*/_classPrivateFieldLooseKey("stage");
-
-class LambdaIntegrationEvent {
-  constructor(request, stage, requestTemplate, path, v3Utils) {
-    Object.defineProperty(this, _path, {
-      writable: true,
-      value: null
-    });
-    Object.defineProperty(this, _request, {
-      writable: true,
-      value: null
-    });
-    Object.defineProperty(this, _requestTemplate, {
-      writable: true,
-      value: null
-    });
-    Object.defineProperty(this, _stage, {
-      writable: true,
-      value: null
-    });
-    _classPrivateFieldLooseBase(this, _path)[_path] = path;
-    _classPrivateFieldLooseBase(this, _request)[_request] = request;
-    _classPrivateFieldLooseBase(this, _requestTemplate)[_requestTemplate] = requestTemplate;
-    _classPrivateFieldLooseBase(this, _stage)[_stage] = stage;
-    this.v3Utils = v3Utils;
-  }
-
-  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;
-  }
-
-}
-
-exports.default = LambdaIntegrationEvent;