@felloh-org/lambda-wrapper 1.0.0 → 1.0.4

package/dist/service/request.js

@@ -0,0 +1,342 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.REQUEST_TYPES = exports.HTTP_METHODS_WITH_PAYLOADS = exports.HTTP_METHODS_WITHOUT_PAYLOADS = exports.ERROR_TYPES = void 0;
+
+var _querystring = _interopRequireDefault(require("querystring"));
+
+var _useragent = _interopRequireDefault(require("useragent"));
+
+var _validate = _interopRequireDefault(require("validate.js/validate"));
+
+var _xml2js = _interopRequireDefault(require("xml2js"));
+
+var _dependencies = require("../config/dependencies");
+
+var _dependencyAware = _interopRequireDefault(require("../dependency-injection/dependency-aware"));
+
+var _response = _interopRequireDefault(require("../model/response"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable class-methods-use-this */
+
+/* eslint-disable sonarjs/no-duplicate-string */
+const REQUEST_TYPES = {
+  DELETE: 'DELETE',
+  GET: 'GET',
+  HEAD: 'HEAD',
+  OPTIONS: 'OPTIONS',
+  PATCH: 'PATCH',
+  POST: 'POST',
+  PUT: 'PUT'
+};
+exports.REQUEST_TYPES = REQUEST_TYPES;
+const HTTP_METHODS_WITHOUT_PAYLOADS = [REQUEST_TYPES.DELETE, REQUEST_TYPES.GET, REQUEST_TYPES.HEAD, REQUEST_TYPES.OPTIONS];
+exports.HTTP_METHODS_WITHOUT_PAYLOADS = HTTP_METHODS_WITHOUT_PAYLOADS;
+const HTTP_METHODS_WITH_PAYLOADS = [REQUEST_TYPES.PATCH, REQUEST_TYPES.POST, REQUEST_TYPES.PUT]; // Define action specific error types
+
+exports.HTTP_METHODS_WITH_PAYLOADS = HTTP_METHODS_WITH_PAYLOADS;
+const ERROR_TYPES = {
+  VALIDATION_ERROR: new _response.default({}, 400, 'required fields are missing')
+};
+/**
+ * RequestService class
+ */
+
+exports.ERROR_TYPES = ERROR_TYPES;
+
+class Request extends _dependencyAware.default {
+  /**
+   * Get a parameter from the request.
+   *
+   * @param parameter
+   * @param ifNull
+   * @param requestType
+   */
+  get(parameter, ifNull = null, requestType = null) {
+    const queryParameters = this.getAll(requestType);
+
+    if (queryParameters === null) {
+      return ifNull;
+    }
+
+    return typeof queryParameters[parameter] !== 'undefined' ? queryParameters[parameter] : ifNull;
+  }
+  /**
+   * Get all HTTP headers included in the request.
+   *
+   * @returns {object} An object with a key for each header.
+   */
+
+
+  getAllHeaders() {
+    return { ...this.getContainer().getEvent().headers
+    };
+  }
+  /**
+   * Get an HTTP header from the request.
+   *
+   * The header name is case-insensitive.
+   *
+   * @param {string} name The name of the header.
+   * @param {string} [whenMissing] Value to return if the header is missing.
+   *   (default: empty string)
+   *
+   * @returns {string}
+   */
+
+
+  getHeader(name, whenMissing = '') {
+    const headers = this.getAllHeaders();
+
+    if (!headers) {
+      return whenMissing;
+    }
+
+    const lowerName = name.toLowerCase();
+    const key = Object.keys(headers).find(k => k.toLowerCase() === lowerName);
+    return key && headers[key] || whenMissing;
+  }
+  /**
+   * Get authorization token
+   *
+   * @returns {*}
+   */
+
+
+  getAuthorizationToken() {
+    const authorization = this.getHeader('Authorization');
+
+    if (!authorization) {
+      return null;
+    }
+
+    const tokenParts = authorization.split(' ');
+    const tokenValue = tokenParts[1];
+
+    if (!(tokenParts[0].toLowerCase() === 'bearer' && tokenValue)) {
+      return null;
+    }
+
+    return tokenValue;
+  }
+  /**
+   * Get a path parameter
+   *
+   * @param parameter
+   * @param ifNull mixed
+   */
+
+
+  getPathParameter(parameter = null, ifNull = {}) {
+    const event = this.getContainer().getEvent(); // If no parameter has been requested, return all path parameters
+
+    if (parameter === null && typeof event.pathParameters === 'object') {
+      return event.pathParameters;
+    } // If a specifc parameter has been requested, return the parameter if it exists
+
+
+    if (typeof parameter === 'string' && typeof event.pathParameters === 'object' && event.pathParameters !== null && typeof event.pathParameters[parameter] !== 'undefined') {
+      return event.pathParameters[parameter];
+    }
+
+    return ifNull;
+  }
+  /**
+   * Get all request parameters
+   *
+   * @param requestType
+   * @returns {{}}
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+
+
+  getAll(requestType = null) {
+    const event = this.getContainer().getEvent();
+
+    if (HTTP_METHODS_WITHOUT_PAYLOADS.includes(event.httpMethod) || HTTP_METHODS_WITHOUT_PAYLOADS.includes(requestType)) {
+      // get simple parameters
+      const params = { ...event.queryStringParameters
+      }; // add array parameters as arrays
+
+      Object.keys(params).filter(key => key.endsWith('[]')).forEach(key => {
+        params[key] = event.multiValueQueryStringParameters[key];
+      });
+      return params;
+    }
+
+    if (HTTP_METHODS_WITH_PAYLOADS.includes(event.httpMethod) || HTTP_METHODS_WITH_PAYLOADS.includes(requestType)) {
+      const contentType = this.getHeader('Content-Type');
+      let queryParameters = {};
+
+      if (contentType.includes('application/x-www-form-urlencoded')) {
+        queryParameters = _querystring.default.parse(event.body);
+      }
+
+      if (contentType.includes('application/json')) {
+        try {
+          queryParameters = JSON.parse(event.body);
+        } catch (error) {
+          queryParameters = {};
+        }
+      }
+
+      if (contentType.includes('text/xml')) {
+        _xml2js.default.parseString(event.body, (error, result) => {
+          queryParameters = error ? {} : result;
+        });
+      }
+
+      if (contentType.includes('multipart/form-data')) {
+        queryParameters = this.parseForm(true);
+      }
+
+      return typeof queryParameters !== 'undefined' ? queryParameters : {};
+    }
+
+    return null;
+  }
+  /**
+   * Fetch the request IP address
+   *
+   * @returns {*}
+   */
+
+
+  getIp() {
+    const event = this.getContainer().getEvent();
+
+    if (typeof event.requestContext !== 'undefined' && typeof event.requestContext.identity !== 'undefined' && typeof event.requestContext.identity.sourceIp !== 'undefined') {
+      return event.requestContext.identity.sourceIp;
+    }
+
+    return null;
+  }
+  /**
+   * Get user agent
+   *
+   * @returns {*}
+   */
+
+
+  getUserBrowserAndDevice() {
+    const userAgent = this.getHeader('user-agent', null);
+
+    if (userAgent === null) {
+      return null;
+    }
+
+    try {
+      const agent = _useragent.default.parse(userAgent);
+
+      const os = agent.os.toJSON();
+      return {
+        'browser-type': agent.family,
+        'browser-version': agent.toVersion(),
+        'device-type': agent.device.family,
+        'operating-system': os.family,
+        'operating-system-version': agent.os.toVersion()
+      };
+    } catch (error) {
+      this.getContainer().get(_dependencies.DEFINITIONS.LOGGER).label('user-agent-parsing-failed');
+      return null;
+    }
+  }
+  /**
+   * Test a request against validation constraints
+   *
+   * @param constraints
+   * @returns {Promise<any>}
+   */
+
+
+  validateAgainstConstraints(constraints) {
+    const Logger = this.getContainer().get(_dependencies.DEFINITIONS.LOGGER);
+    return new Promise((resolve, reject) => {
+      const validation = (0, _validate.default)(this.getAll(), constraints);
+
+      if (typeof validation === 'undefined') {
+        resolve();
+      } else {
+        Logger.label('request-validation-failed');
+        const validationErrorResponse = ERROR_TYPES.VALIDATION_ERROR;
+        validationErrorResponse.setBodyVariable('validation_errors', validation);
+        reject(validationErrorResponse);
+      }
+    });
+  }
+  /**
+   * Fetch the request multipart form
+   *
+   * @param useBuffer
+   * @returns {*}
+   */
+
+
+  parseForm(useBuffer) {
+    const event = this.getContainer().getEvent();
+    const boundary = this.getBoundary(event);
+    const body = event.isBase64Encoded ? Buffer.from(event.body, 'base64').toString('binary').trim() : event.body;
+    const result = {};
+    body.split(boundary).forEach(item => {
+      if (/filename=".+"/g.test(item)) {
+        result[item.match(/name=".+";/g)[0].slice(6, -2)] = {
+          type: 'file',
+          filename: item.match(/filename=".+"/g)[0].slice(10, -1),
+          contentType: item.match(/Content-Type:\s.+/g)[0].slice(14),
+          content: useBuffer ? Buffer.from(item.slice(item.search(/Content-Type:\s.+/g) + item.match(/Content-Type:\s.+/g)[0].length + 4, -4), 'binary') : item.slice(item.search(/Content-Type:\s.+/g) + item.match(/Content-Type:\s.+/g)[0].length + 4, -4)
+        };
+      } else if (/name=".+"/g.test(item)) {
+        result[item.match(/name=".+"/g)[0].slice(6, -1)] = item.slice(item.search(/name=".+"/g) + item.match(/name=".+"/g)[0].length + 4, -4);
+      }
+    });
+    return result;
+  }
+  /**
+   * Fetch the request AWS event Records
+   *
+   * @returns {*}
+   */
+
+
+  getAWSRecords() {
+    const event = this.getContainer().getEvent();
+    const eventRecord = event.Records && event.Records[0];
+
+    if (typeof event.Records !== 'undefined' && typeof event.Records[0] !== 'undefined' && typeof eventRecord.eventSource !== 'undefined') {
+      return eventRecord;
+    }
+
+    return null;
+  }
+  /**
+   * Gets a value independently from
+   * the case of the key
+   *
+   * @param object
+   * @param key
+   */
+
+
+  getValueIgnoringKeyCase(object, key) {
+    const foundKey = Object.keys(object).find(currentKey => currentKey.toLocaleLowerCase() === key.toLowerCase());
+    return object[foundKey];
+  }
+  /**
+   * Returns the content type
+   * assoiated with the request
+   *
+   * @param event
+   */
+
+
+  getBoundary(event) {
+    return this.getValueIgnoringKeyCase(event.headers, 'Content-Type').split('=')[1];
+  }
+
+}
+
+exports.default = Request;

package/dist/service/warehouse.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _typeorm = require("typeorm");
+
+var _typeormAuroraDataApiDriver = _interopRequireDefault(require("typeorm-aurora-data-api-driver"));
+
+var _dependencyAware = _interopRequireDefault(require("../dependency-injection/dependency-aware"));
+
+var _entity = _interopRequireDefault(require("../entity"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-line no-unused-vars
+
+/**
+ * Warehouse Serv8ce
+ */
+class Warehouse extends _dependencyAware.default {
+  constructor() {
+    super();
+    this.connection = null;
+  }
+  /**
+   *
+   * @returns {Promise<Connection>}
+   */
+
+
+  async connect() {
+    if (this.connection) {
+      return this.connection;
+    }
+
+    try {
+      this.connection = await (0, _typeorm.getConnection)();
+    } catch (error) {
+      this.connection = await (0, _typeorm.createConnection)({
+        type: 'aurora-data-api-pg',
+        database: process.env.WAREHOUSE_DATABASE,
+        schema: process.env.WAREHOUSE_SCHEMA,
+        secretArn: process.env.WAREHOUSE_SECRET_ARN,
+        resourceArn: process.env.WAREHOUSE_ARN,
+        region: process.env.REGION,
+        entities: _entity.default,
+        logging: true
+      });
+    }
+
+    return this.connection;
+  }
+
+}
+
+exports.default = Warehouse;

package/dist/util/lambda-termination.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ *
+ */
+class LambdaTermination extends Error {
+  /**
+   * Triggers a Lambda Termination.
+   * Offers developer details (that are logged)
+   * an code for the Lambda and a front facing
+   * consumer message.
+   *
+   * @param {object|string} internal
+   * @param {number?} code
+   * @param {object|string?} body
+   * @param details
+   */
+  constructor(internal, code = 500, body = null, details = 'unknown error') {
+    let stringified = internal;
+
+    if (typeof internal !== 'string') {
+      stringified = JSON.stringify(internal);
+    }
+
+    super(stringified);
+    this.internal = internal;
+    this.code = code;
+    this.body = body || 'unknown error';
+    this.details = details;
+  }
+
+}
+
+exports.default = LambdaTermination;

package/dist/util/promisified-delay.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const STANDARD_LATENCY_DELAYS = {
+  2000: 70,
+  3500: 15,
+  4000: 10,
+  5000: 5
+};
+const HIGH_LATENCY_DELAYS = {
+  2000: 65,
+  3500: 15,
+  4000: 9,
+  5000: 5,
+  10000: 5,
+  20000: 1
+};
+/**
+ * PromisifiedDelay class
+ */
+
+class PromisifiedDelay {
+  /**
+   * PromisifiedDelay constructor
+   *
+   * @param highLatency
+   */
+  constructor(highLatency = true) {
+    this.delays = [];
+    const delayArray = highLatency === true ? HIGH_LATENCY_DELAYS : STANDARD_LATENCY_DELAYS;
+    Object.keys(delayArray).forEach(delayDuration => {
+      const delayIterations = delayArray[delayDuration];
+
+      for (let i = 0; i < delayIterations; i += 1) {
+        this.delays.push(delayDuration);
+      }
+    });
+  }
+  /**
+   * Create a promisified delay
+   *
+   * @returns {Promise<any>}
+   */
+
+
+  get() {
+    return new Promise(resolve => {
+      setTimeout(() => {
+        resolve();
+      }, this.delays[Math.floor(Math.random() * this.delays.length)]);
+    });
+  }
+
+}
+
+exports.default = PromisifiedDelay;

package/dist/wrapper/index.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleSuccess = exports.handleError = exports.default = void 0;
+
+var _epsagon = _interopRequireDefault(require("epsagon"));
+
+var _dependencies = require("../config/dependencies");
+
+var _dependencyInjection = _interopRequireDefault(require("../dependency-injection/dependency-injection"));
+
+var _response = _interopRequireDefault(require("../model/response"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable sonarjs/cognitive-complexity */
+
+/**
+ * Processes the outcome once we have one
+ *
+ * @param di
+ * @param outcome
+ */
+const handleSuccess = (di, outcome) => {
+  const logger = di.get(_dependencies.DEFINITIONS.LOGGER); // Outcome may be undefined as not all lambdas have a return value.
+
+  logger.metric('lambda.statusCode', outcome && outcome.statusCode || 200);
+  return outcome;
+};
+/**
+ * Gracefully handles an error
+ * logging in Epsagon and generating
+ * a response reflecting the `code`
+ * of the error, if defined.
+ *
+ * Note about Epsagon:
+ * Epsagon generates alerts for logs on level ERROR.
+ * This means that logger.error will produce an alert.
+ * To avoid not meaningful notifications, most likely
+ * coming from tests, we log INFO unless either:
+ *
+ * 1. `error.raiseOnEpsagon` is defined & truthy
+ * 2. `error.code` is defined and `error.code >= 500`.
+ *
+ * @param {DependencyInjection} di
+ * @param {Error} error
+ * @param {boolean} [throwError=false]
+ */
+
+
+exports.handleSuccess = handleSuccess;
+
+const handleError = (di, error, throwError = false) => {
+  const logger = di.get(_dependencies.DEFINITIONS.LOGGER);
+  logger.metric('lambda.statusCode', error.code || 500);
+
+  if (error.raiseOnEpsagon || !error.code || error.code >= 500) {
+    logger.error(error);
+  } else {
+    logger.info(error);
+  }
+
+  if (throwError) {
+    if (error instanceof Error) {
+      return error;
+    } // We want to be absolutely sure
+    // that we are returning an error
+    // as Lambda sync handlers will only fail
+    // if the object is instanceof Error
+
+
+    return new Error(error);
+  }
+
+  const responseDetails = {
+    body: error.body || {},
+    code: error.code || 500,
+    details: error.details || 'unknown error'
+  };
+  return _response.default.generate(responseDetails.body, responseDetails.code, responseDetails.details);
+};
+/**
+ * Lambda Wrapper.
+ *
+ * Wraps a lambda handler, generating a new function
+ * that has access to the dependency injection
+ * for the service and handles logging and exceptions.
+ *
+ * @param configuration
+ * @param handler
+ * @param throwError
+ */
+
+
+exports.handleError = handleError;
+
+const wrapper = (configuration, handler, throwError = false) => {
+  let instance = (event, context, callback) => {
+    const di = new _dependencyInjection.default(configuration, event, context);
+    const request = di.get(_dependencies.DEFINITIONS.REQUEST);
+    const logger = di.get(_dependencies.DEFINITIONS.LOGGER);
+    context.callbackWaitsForEmptyEventLoop = false; // If the event is to trigger a warm up, then don't bother returning the function.
+
+    if (di.getEvent().source === 'serverless-plugin-warmup') {
+      return callback(null, 'Lambda is warm!');
+    } // Log the users ip address silently for use in error tracing
+
+
+    if (request.getIp() !== null) {
+      logger.metric('ipAddress', request.getIp(), true);
+    } // Add metrics with user browser information for rapid debugging
+
+
+    const userBrowserAndDevice = request.getUserBrowserAndDevice();
+
+    if (userBrowserAndDevice !== null && typeof userBrowserAndDevice === 'object') {
+      Object.keys(userBrowserAndDevice).forEach(metricKey => {
+        logger.metric(metricKey, userBrowserAndDevice[metricKey], true);
+      });
+    }
+
+    let outcome;
+
+    try {
+      outcome = handler.call(instance, di, request, callback);
+
+      if (outcome instanceof Promise) {
+        outcome = outcome.then(value => handleSuccess(di, value)).catch(error => {
+          const handled = handleError(di, error, throwError);
+
+          if (throwError) {
+            // AWS Lambda with async handler is looking for a rejection
+            // and not an error object directly
+            // and will treat resolved errors as successful
+            // as it will cast the error to JSON, i.e. `{}`
+            return Promise.reject(handled);
+          }
+
+          return handled;
+        });
+      }
+    } catch (error) {
+      outcome = handleError(di, error, throwError);
+    }
+
+    return outcome;
+  }; // If the Epsagon token is enabled, then wrap the instance in the Epsagon wrapper
+
+
+  if (typeof process.env.EPSAGON_TOKEN === 'string' && process.env.EPSAGON_TOKEN !== 'undefined' && typeof process.env.EPSAGON_SERVICE_NAME === 'string' && process.env.EPSAGON_SERVICE_NAME !== 'undefined') {
+    _epsagon.default.init({
+      token: process.env.EPSAGON_TOKEN,
+      appName: process.env.EPSAGON_SERVICE_NAME
+    });
+
+    instance = _epsagon.default.lambdaWrapper(instance);
+  }
+
+  return instance;
+};
+
+var _default = wrapper;
+exports.default = _default;

package/ormconfig.js

@@ -0,0 +1,25 @@
+const DotEnv = require('dotenv');
+
+DotEnv.config();
+
+module.exports = {
+  "type": "aurora-data-api-pg",
+  "database": process.env.WAREHOUSE_DATABASE,
+  "secretArn": process.env.WAREHOUSE_SECRET_ARN,
+  "resourceArn": process.env.WAREHOUSE_ARN,
+  "region": process.env.REGION,
+  "synchronize": true,
+  "logging": false,
+  "schema": 'user',
+  "entities": [
+    __dirname + '/dist/entity/**/*.ts',
+    __dirname + '/dist/entity/**/*.js',
+  ],
+  "migrations": [
+    __dirname + '/dist/migration/**/*.ts',
+    __dirname + '/dist/migration/**/*.js'
+  ],
+  "cli": {
+    "migrationsDir":  __dirname + '/src/migration'
+  },
+};