@felloh-org/lambda-wrapper 1.0.0 → 1.0.4

package/dist/migration/user/1641901624008-add_roles.js

@@ -0,0 +1,21 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class addRoles1641901624008 {
+    name = 'addRoles1641901624008'
+
+    async up(queryRunner) {
+        await queryRunner.query(`CREATE TABLE "user"."role" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "machine_name" character varying(50) NOT NULL, "name" character varying(150) NOT NULL, "description" character varying(250) NOT NULL, "parent_only" boolean NOT NULL, "group" character varying(100) NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_b36bcfe02fc8de3c57a8b2391c2" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TABLE "user"."user_role" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "user_id" character varying NOT NULL, "organisation_id" character varying(150) NOT NULL, "role_id" uuid NOT NULL, CONSTRAINT "PK_38abbb50a455f9a7da9651ce5d7" PRIMARY KEY ("id", "user_id", "organisation_id", "role_id"))`);
+        await queryRunner.query(`ALTER TABLE "user"."user_role" ADD CONSTRAINT "FK_d0e5815877f7395a198a4cb0a46" FOREIGN KEY ("user_id") REFERENCES "user"."user"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "user"."user_role" ADD CONSTRAINT "FK_fe76718250bdec1ebff3494c99b" FOREIGN KEY ("organisation_id") REFERENCES "user"."organisation"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "user"."user_role" ADD CONSTRAINT "FK_32a6fc2fcb019d8e3a8ace0f55f" FOREIGN KEY ("role_id") REFERENCES "user"."role"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."user_role" DROP CONSTRAINT "FK_32a6fc2fcb019d8e3a8ace0f55f"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_role" DROP CONSTRAINT "FK_fe76718250bdec1ebff3494c99b"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_role" DROP CONSTRAINT "FK_d0e5815877f7395a198a4cb0a46"`);
+        await queryRunner.query(`DROP TABLE "user"."user_role"`);
+        await queryRunner.query(`DROP TABLE "user"."role"`);
+    }
+}

package/dist/migration/user/1641903059924-add_roles_kyc.js

@@ -0,0 +1,13 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class addRolesKyc1641903059924 {
+    name = 'addRolesKyc1641903059924'
+
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."role" ADD "kyc_required" boolean NOT NULL`);;
+    }
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."role" DROP COLUMN "kyc_required"`);
+    }
+}

package/dist/migration/user/1641903425025-roles-defaults.js

@@ -0,0 +1,15 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class rolesDefaults1641903425025 {
+    name = 'rolesDefaults1641903425025'
+
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."role" ALTER COLUMN "parent_only" SET DEFAULT false`);
+        await queryRunner.query(`ALTER TABLE "user"."role" ALTER COLUMN "kyc_required" SET DEFAULT false`);
+    }
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."role" ALTER COLUMN "kyc_required" DROP DEFAULT`);
+        await queryRunner.query(`ALTER TABLE "user"."role" ALTER COLUMN "parent_only" DROP DEFAULT`);
+    }
+}

package/dist/migration/user/1641939221103-feature.js

@@ -0,0 +1,13 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class feature1641939221103 {
+    name = 'feature1641939221103'
+
+    async up(queryRunner) {
+        await queryRunner.query(`CREATE TABLE "user"."feature" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "machine_name" character varying(50) NOT NULL, "name" character varying(150) NOT NULL, "created_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_03930932f909ca4be8e33d16a2d" PRIMARY KEY ("id"))`);
+   }
+
+    async down(queryRunner) {
+        await queryRunner.query(`DROP TABLE "user"."feature"`);
+    }
+}

package/dist/migration/user/1642019067334-organisation-feature.js

@@ -0,0 +1,17 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class organisationFeature1642019067334 {
+    name = 'organisationFeature1642019067334'
+
+    async up(queryRunner) {
+        await queryRunner.query(`CREATE TABLE "user"."organisation_feature" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "organisation_id" character varying(150), "feature_id" uuid, CONSTRAINT "PK_ee793662f5baf61d42cf0213a5d" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`ALTER TABLE "user"."organisation_feature" ADD CONSTRAINT "FK_65a20c77a2387c9717c02efd4ab" FOREIGN KEY ("organisation_id") REFERENCES "user"."organisation"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "user"."organisation_feature" ADD CONSTRAINT "FK_a8920942bf7f3703d9968fa8eae" FOREIGN KEY ("feature_id") REFERENCES "user"."feature"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."organisation_feature" DROP CONSTRAINT "FK_a8920942bf7f3703d9968fa8eae"`);
+        await queryRunner.query(`ALTER TABLE "user"."organisation_feature" DROP CONSTRAINT "FK_65a20c77a2387c9717c02efd4ab"`);
+        await queryRunner.query(`DROP TABLE "user"."organisation_feature"`);
+    }
+}

package/dist/migration/user/1642078564295-user-activity-relation.js

@@ -0,0 +1,16 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class userActivityRelation1642078564295 {
+    name = 'userActivityRelation1642078564295'
+
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."user_activity" DROP COLUMN "user_id"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_activity" ADD "user_id" character varying NOT NULL`);
+        await queryRunner.query(`ALTER TABLE "user"."user_activity" ADD CONSTRAINT "FK_11108754ec780c670440e32baad" FOREIGN KEY ("user_id") REFERENCES "user"."user"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);}
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."user_activity" DROP CONSTRAINT "FK_11108754ec780c670440e32baad"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_activity" DROP COLUMN "user_id"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_activity" ADD "user_id" uuid NOT NULL`);
+    }
+}

package/dist/migration/user/1642207858247-fix-user-constraint.js

@@ -0,0 +1,19 @@
+const { MigrationInterface, QueryRunner } = require("typeorm");
+
+module.exports = class fixUserConstraint1642207858247 {
+    name = 'fixUserConstraint1642207858247'
+
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" DROP CONSTRAINT "FK_81c4608739c8cf71fa1f96e11ae"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" DROP CONSTRAINT "FK_d9628e009b6d71bf677c04f8494"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" ADD CONSTRAINT "FK_81c4608739c8cf71fa1f96e11ae" FOREIGN KEY ("user_id") REFERENCES "user"."user"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" ADD CONSTRAINT "FK_d9628e009b6d71bf677c04f8494" FOREIGN KEY ("organisation_id") REFERENCES "user"."organisation"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" DROP CONSTRAINT "FK_d9628e009b6d71bf677c04f8494"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" DROP CONSTRAINT "FK_81c4608739c8cf71fa1f96e11ae"`);
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" ADD CONSTRAINT "FK_d9628e009b6d71bf677c04f8494" FOREIGN KEY ("organisation_id") REFERENCES "user"."organisation"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "user"."user_organisation" ADD CONSTRAINT "FK_81c4608739c8cf71fa1f96e11ae" FOREIGN KEY ("user_id") REFERENCES "user"."user"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
+    }
+}

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;

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;