@felloh-org/lambda-wrapper 1.0.0 → 1.0.1

package/dist/service/logger.js

@@ -0,0 +1,236 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _epsagon = _interopRequireDefault(require("epsagon"));
+
+var _winston = _interopRequireDefault(require("winston"));
+
+var _dependencyAware = _interopRequireDefault(require("../dependency-injection/dependency-aware"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * LoggerService class
+ */
+class Logger extends _dependencyAware.default {
+  constructor(di) {
+    super(di);
+    this.winston = null;
+  }
+  /**
+   * Returns a Winston logger object
+   * configured for our lambdas.
+   *
+   * Note:
+   *
+   * If the lambda is executed
+   * in a `serverless-offline` context
+   * the log output to console will be pretty printed.
+   */
+
+
+  getLogger() {
+    const loggerFormats = [_winston.default.format.json({
+      replacer: (key, value) => {
+        if (value instanceof Buffer) {
+          return value.toString('base64');
+        }
+
+        if (value instanceof Error) {
+          const error = {};
+          Object.getOwnPropertyNames(value).forEach(objectKey => {
+            error[objectKey] = value[objectKey];
+          });
+          return error;
+        }
+
+        return value;
+      }
+    })];
+
+    if (this.getContainer().isOffline) {
+      loggerFormats.push(_winston.default.format.prettyPrint());
+    }
+
+    return _winston.default.createLogger({
+      level: 'info',
+      format: _winston.default.format.combine(...loggerFormats),
+      transports: [new _winston.default.transports.Console()]
+    });
+  }
+  /**
+   * Returns the logger.
+   *
+   * Uses a cached `Winston` object
+   * if it has been already generated,
+   * otherwise it generates one.
+   */
+
+
+  get logger() {
+    if (!this.winston) {
+      this.winston = this.getLogger();
+    }
+
+    return this.winston;
+  }
+  /**
+   * While handling an error, lambda wrapper should
+   * recognise axios errors and trim down the information.
+   *
+   * Keep the following keys:
+   * - message.config
+   * - message.message
+   * - message.response?.status
+   * - message.response?.data
+   *
+   * @param {object} error
+   */
+
+
+  static processAxiosError(error) {
+    const processed = {
+      config: error.config,
+      message: error.message
+    }; // It's pretty common for axios errors
+    // to not have.response e.g.when there's
+    // a network error or timeout.
+    // These errors will have .request but not .response.
+
+    if (error.response) {
+      processed.response = {
+        status: error.response.status,
+        data: error.response.data
+      };
+    }
+
+    return processed;
+  }
+  /**
+   * Transform the original message
+   * before it is passed to the winston logger
+   *
+   * @param {string|object} message
+   */
+
+
+  processMessage(message = '') {
+    let processed = message;
+
+    if (processed && processed.isAxiosError) {
+      processed = this.constructor.processAxiosError(processed);
+    }
+
+    return processed;
+  }
+  /**
+   * Log Error Message
+   *
+   * @param error object
+   * @param message string
+   */
+
+
+  error(error, message = '') {
+    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' && error instanceof Error) {
+      _epsagon.default.setError(error);
+    }
+
+    this.logger.log('error', message, {
+      error: this.processMessage(error)
+    });
+    this.label('error', true);
+    this.metric('error', 'error', true);
+  }
+  /**
+   * Log Information Message
+   *
+   * @param message string
+   */
+
+
+  info(message) {
+    this.logger.log('info', this.processMessage(message));
+  }
+  /**
+   * Logs an error, using `LoggerService.error`
+   * or `LoggerService.info` based on
+   * `process.env.LOGGER_SOFT_WARNING`.
+   *
+   * Please note that `LoggerService.error` and `LoggerService.info`
+   * have different signatures. The function uses the shared argument
+   * instead of introducing ambiguity.
+   *
+   * @param error
+   */
+
+
+  warning(error) {
+    const softWarningValues = ['true', '1'];
+
+    if (softWarningValues.includes(process.env.LOGGER_SOFT_WARNING)) {
+      return this.info(error);
+    }
+
+    return this.error(error);
+  }
+  /**
+   * Add a label
+   *
+   * @param descriptor string
+   * @param silent     boolean
+   */
+
+
+  label(descriptor, silent = false) {
+    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.label(descriptor);
+    }
+
+    if (silent === false) {
+      this.logger.log('info', `label - ${descriptor}`);
+    }
+  }
+  /**
+   * Add a metric
+   *
+   * @param descriptor string
+   * @param stat       integer | string
+   * @param silent     boolean
+   */
+
+
+  metric(descriptor, stat, silent = false) {
+    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.label(descriptor, stat);
+    }
+
+    if (silent === false) {
+      this.logger.log('info', `metric - ${descriptor} - ${stat}`);
+    }
+  }
+  /**
+   * Logs an object so that it can be inspected
+   *
+   * @param action - What are we doing with the object, i.e. 'Processing'
+   * @param object - The object to be stored in logs
+   * @param level - 'error', 'warning' or 'info'
+   */
+
+
+  object(action, object, level = 'info') {
+    if (!['error', 'warning', 'info'].includes(level)) {
+      throw new Error('Unrecognised log level');
+    }
+
+    const payload = JSON.stringify(object, null, 4);
+    return this[level](`${action}: '${payload}'`);
+  }
+
+}
+
+exports.default = Logger;

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/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;