@felloh-org/lambda-wrapper 1.0.0 → 1.0.1

package/.github/workflows/release.yml

@@ -27,6 +27,8 @@ jobs:
         env:
           CI: true
 
+      - run: yarn build
+
       - name: Publish via Semantic Release
         run: yarn semantic-release
         env:

package/dist/config/dependencies.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Dependencies = exports.DEFINITIONS = void 0;
+
+var _http = _interopRequireDefault(require("../service/http"));
+
+var _logger = _interopRequireDefault(require("../service/logger"));
+
+var _request = _interopRequireDefault(require("../service/request"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const DEFINITIONS = {
+  HTTP: 'HTTP',
+  LOGGER: 'LOGGER',
+  REQUEST: 'REQUEST'
+};
+exports.DEFINITIONS = DEFINITIONS;
+const Dependencies = {
+  [DEFINITIONS.HTTP]: _http.default,
+  [DEFINITIONS.LOGGER]: _logger.default,
+  [DEFINITIONS.REQUEST]: _request.default
+};
+exports.Dependencies = Dependencies;
+var _default = {
+  DEFINITIONS,
+  DEPENDENCIES: Dependencies
+};
+exports.default = _default;

package/dist/dependency-injection/dependency-aware.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * DependencyAwareClass Class
+ */
+class DependencyAware {
+  /**
+   * DependencyAwareClass constructor
+   *
+   * @param {DependencyInjection} di
+   */
+  constructor(di) {
+    this.di = di;
+  }
+  /**
+   * Get Dependency Injection Container
+   *
+   * @returns {DependencyInjection}
+   */
+
+
+  getContainer() {
+    return this.di;
+  }
+  /**
+   * Shortcut for `this.getContainer().definitions`
+   *
+   * @returns {object}
+   */
+
+
+  get definitions() {
+    return this.getContainer().definitions;
+  }
+
+}
+
+exports.default = DependencyAware;

package/dist/dependency-injection/dependency-injection.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _dependencies = require("../config/dependencies");
+
+/**
+ * DependencyInjection class
+ */
+class DependencyInjection {
+  /**
+   * DependencyInjection constructor
+   *
+   * @param configuration
+   * @param event
+   * @param context
+   */
+  constructor(configuration, event, context) {
+    this.event = event;
+    this.context = context;
+    this.dependencies = {};
+    this.configuration = configuration;
+
+    for (let x = 0; x <= 1; x += 1) {
+      // Iterate over dependencies and add to container
+      Object.keys(_dependencies.DEFINITIONS).forEach(dependencyKey => {
+        this.dependencies[dependencyKey] = new _dependencies.Dependencies[dependencyKey](this);
+      }); // Iterate over child dependencies and add to container
+
+      if (typeof configuration.DEPENDENCIES !== 'undefined') {
+        Object.keys(configuration.DEPENDENCIES).forEach(dependencyKey => {
+          this.dependencies[dependencyKey] = new configuration.DEPENDENCIES[dependencyKey](this);
+        });
+      }
+    }
+  }
+  /**
+   * Get Dependency
+   *
+   * @param definition
+   * @returns {*}
+   */
+
+
+  get(definition) {
+    if (typeof this.dependencies[definition] === 'undefined') {
+      throw new TypeError(`${definition} does not exist in di container`);
+    }
+
+    return this.dependencies[definition];
+  }
+  /**
+   * Get Event
+   *
+   * @returns {*}
+   */
+
+
+  getEvent() {
+    return this.event;
+  }
+  /**
+   * Get Context
+   *
+   * @returns {*}
+   */
+
+
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Get Configuration
+   *
+   * @param definition string
+   * @returns {*}
+   */
+
+
+  getConfiguration(definition = null) {
+    if (definition !== null && typeof this.configuration[definition] === 'undefined') {
+      return null;
+    }
+
+    if (typeof this.configuration[definition] !== 'undefined') {
+      return this.configuration[definition];
+    }
+
+    return this.configuration;
+  }
+  /**
+   * Check whether the function
+   * is being executed in a serverless-offline context
+   *
+   * @returns {boolean}
+   */
+
+
+  get isOffline() {
+    const context = this.getContext() || {};
+
+    if (!Object.prototype.hasOwnProperty.call(context, 'invokedFunctionArn')) {
+      return true;
+    }
+
+    if (context.invokedFunctionArn.includes('offline')) {
+      return true;
+    }
+
+    if (process.env.USE_SERVERLESS_OFFLINE) {
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * Returns the definitions
+   * associated to this DependencyInjection
+   * so that services can refer to them
+   * without causing circular imports.
+   *
+   * @returns {object}
+   */
+
+
+  get definitions() {
+    return this.configuration.DEFINITIONS;
+  }
+
+}
+
+exports.default = DependencyInjection;

package/dist/index.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DEFINITIONS", {
+  enumerable: true,
+  get: function () {
+    return _dependencies.DEFINITIONS;
+  }
+});
+Object.defineProperty(exports, "DependencyAwareClass", {
+  enumerable: true,
+  get: function () {
+    return _dependencyAware.default;
+  }
+});
+Object.defineProperty(exports, "DependencyInjection", {
+  enumerable: true,
+  get: function () {
+    return _dependencyInjection.default;
+  }
+});
+Object.defineProperty(exports, "HTTPService", {
+  enumerable: true,
+  get: function () {
+    return _http.default;
+  }
+});
+Object.defineProperty(exports, "LambdaTermination", {
+  enumerable: true,
+  get: function () {
+    return _lambdaTermination.default;
+  }
+});
+Object.defineProperty(exports, "LambdaWrapper", {
+  enumerable: true,
+  get: function () {
+    return _wrapper.default;
+  }
+});
+Object.defineProperty(exports, "LoggerService", {
+  enumerable: true,
+  get: function () {
+    return _logger.default;
+  }
+});
+Object.defineProperty(exports, "Model", {
+  enumerable: true,
+  get: function () {
+    return _model.default;
+  }
+});
+Object.defineProperty(exports, "PromisifiedDelay", {
+  enumerable: true,
+  get: function () {
+    return _promisifiedDelay.default;
+  }
+});
+Object.defineProperty(exports, "RequestService", {
+  enumerable: true,
+  get: function () {
+    return _request.default;
+  }
+});
+Object.defineProperty(exports, "ResponseModel", {
+  enumerable: true,
+  get: function () {
+    return _response.default;
+  }
+});
+Object.defineProperty(exports, "STATUS_TYPES", {
+  enumerable: true,
+  get: function () {
+    return _status.STATUS_TYPES;
+  }
+});
+Object.defineProperty(exports, "StatusModel", {
+  enumerable: true,
+  get: function () {
+    return _status.default;
+  }
+});
+
+var _dependencies = require("./config/dependencies");
+
+var _dependencyAware = _interopRequireDefault(require("./dependency-injection/dependency-aware"));
+
+var _dependencyInjection = _interopRequireDefault(require("./dependency-injection/dependency-injection"));
+
+var _model = _interopRequireDefault(require("./model"));
+
+var _response = _interopRequireDefault(require("./model/response"));
+
+var _status = _interopRequireWildcard(require("./model/status"));
+
+var _http = _interopRequireDefault(require("./service/http"));
+
+var _logger = _interopRequireDefault(require("./service/logger"));
+
+var _request = _interopRequireDefault(require("./service/request"));
+
+var _lambdaTermination = _interopRequireDefault(require("./util/lambda-termination"));
+
+var _promisifiedDelay = _interopRequireDefault(require("./util/promisified-delay"));
+
+var _wrapper = _interopRequireDefault(require("./wrapper"));
+
+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 }; }

package/dist/model/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validate = _interopRequireDefault(require("validate.js/validate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable class-methods-use-this */
+
+/**
+ * Model base class
+ */
+class Model {
+  /**
+   * Instantiate a function with a value if defined
+   *
+   * @param classFunctionName string
+   * @param value             mixed
+   */
+  instantiateFunctionWithDefinedValue(classFunctionName, value) {
+    if (typeof value !== 'undefined') {
+      this[classFunctionName](value);
+    }
+  }
+  /**
+   * Validate values against constraints
+   *
+   * @param values      object
+   * @param constraints object
+   * @returns {boolean}
+   */
+
+
+  validateAgainstConstraints(values, constraints) {
+    const validation = (0, _validate.default)(values, constraints);
+    return typeof validation === 'undefined';
+  }
+
+}
+
+exports.default = Model;

package/dist/model/response/index.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.RESPONSE_HEADERS = exports.DEFAULT_MESSAGE = void 0;
+
+var _ = _interopRequireDefault(require(".."));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ *
+ * @type {object}
+ */
+const RESPONSE_HEADERS = {
+  'Content-Type': 'application/json',
+  'Access-Control-Allow-Origin': '*',
+  // Required for CORS support to work
+  'Access-Control-Allow-Credentials': true // Required for cookies, authorization headers with HTTPS
+
+};
+/**
+ * Default message provided as part of response
+ *
+ * @type {string}
+ */
+
+exports.RESPONSE_HEADERS = RESPONSE_HEADERS;
+const DEFAULT_MESSAGE = 'success';
+/**
+ * class ResponseModel
+ */
+
+exports.DEFAULT_MESSAGE = DEFAULT_MESSAGE;
+
+class Index extends _.default {
+  /**
+   * ResponseModel Constructor
+   *
+   * @param data
+   * @param code
+   * @param message
+   */
+  constructor(data = null, code = null, message = null) {
+    super();
+    this.body = {
+      data: data !== null ? data : {},
+      message: message !== null ? message : DEFAULT_MESSAGE
+    };
+    this.code = code !== null ? code : {};
+  }
+  /**
+   * Add or update a body variable
+   *
+   * @param variable
+   * @param value
+   */
+
+
+  setBodyVariable(variable, value) {
+    this.body[variable] = value;
+  }
+  /**
+   * Set Data
+   *
+   * @param data
+   */
+
+
+  setData(data) {
+    this.body.data = data;
+  }
+  /**
+   * Set Status Code
+   *
+   * @param code
+   */
+
+
+  setCode(code) {
+    this.code = code;
+  }
+  /**
+   * Get Status Code
+   *
+   * @returns {*}
+   */
+
+
+  getCode() {
+    return this.code;
+  }
+  /**
+   * Set message
+   *
+   * @param message
+   */
+
+
+  setMessage(message) {
+    this.body.message = message;
+  }
+  /**
+   * Get Message
+   *
+   * @returns {string|*}
+   */
+
+
+  getMessage() {
+    return this.body.message;
+  }
+  /**
+   * Geneate a response
+   *
+   * @returns {object}
+   */
+
+
+  generate() {
+    return {
+      statusCode: this.code,
+      headers: RESPONSE_HEADERS,
+      body: JSON.stringify(this.body)
+    };
+  }
+  /**
+   * Shorthand static method
+   * that generates the response immediately
+   * if no additional processing is required.
+   *
+   * Saves only 1 line of code
+   * but keeps code terse in a lot of places.
+   *
+   * @param {*} data
+   * @param {*} code
+   * @param {*} message
+   * @returns {object}
+   */
+
+
+  static generate(data = null, code = null, message = null) {
+    const response = new this(data, code, message);
+    return response.generate();
+  }
+
+}
+
+exports.default = Index;

package/dist/model/status/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.STATUS_TYPES = void 0;
+
+var _index = _interopRequireDefault(require("../index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const STATUS_TYPES = {
+  OK: 'OK',
+  ACCEPTABLE_FAILURE: 'ACCEPTABLE_FAILURE',
+  APPLICATION_FAILURE: 'APPLICATION_FAILURE'
+};
+/**
+ * StatusModel Class
+ */
+
+exports.STATUS_TYPES = STATUS_TYPES;
+
+class Index extends _index.default {
+  /**
+   * StatusModel constructor
+   *
+   * @param service
+   * @param status
+   */
+  constructor(service, status) {
+    super();
+    this.setService(service);
+    this.setStatus(status);
+  }
+  /**
+   * Get Service
+   *
+   * @returns {*}
+   */
+
+
+  getService() {
+    return this.service;
+  }
+  /**
+   * Set Service
+   *
+   * @param service
+   */
+
+
+  setService(service) {
+    this.service = service;
+  }
+  /**
+   * Set the status
+   *
+   * @param status
+   */
+
+
+  setStatus(status) {
+    if (typeof STATUS_TYPES[status] === 'undefined') {
+      throw new TypeError(`${Index.name} - ${status} is not a valid status type`);
+    }
+
+    this.status = status;
+  }
+  /**
+   * Get status
+   *
+   * @returns {string|*}
+   */
+
+
+  getStatus() {
+    return this.status;
+  }
+
+}
+
+exports.default = Index;

package/dist/service/http.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.DEFAULT_HTTP_TIMEOUT = void 0;
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _dependencyAware = _interopRequireDefault(require("../dependency-injection/dependency-aware"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const DEFAULT_HTTP_TIMEOUT = 10 * 1000;
+/**
+ * HTTPService class
+ */
+
+exports.DEFAULT_HTTP_TIMEOUT = DEFAULT_HTTP_TIMEOUT;
+
+class Http extends _dependencyAware.default {
+  constructor(di) {
+    super(di);
+    this.config = {
+      timeout: DEFAULT_HTTP_TIMEOUT
+    };
+  }
+  /**
+   * Sets the default timeout
+   *
+   * @param {number} ms
+   */
+
+
+  setDefaultTimeout(ms) {
+    this.config.timeout = ms;
+  }
+  /**
+   * Performs and HTTP Request
+   *
+   * @param config
+   */
+
+
+  async request(config) {
+    return _axios.default.request({
+      timeout: this.config.timeout,
+      headers: {},
+      ...config
+    });
+  }
+
+}
+
+exports.default = Http;