@felloh-org/lambda-wrapper 1.1.45 → 1.1.46

package/dist/config/dependencies.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.Dependencies = exports.DEFINITIONS = void 0;
 
+var _authentication = _interopRequireDefault(require("../service/authentication"));
+
 var _eventBridge = _interopRequireDefault(require("../service/event-bridge"));
 
 var _http = _interopRequireDefault(require("../service/http"));
@@ -18,6 +20,7 @@ var _warehouse = _interopRequireDefault(require("../service/warehouse"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const DEFINITIONS = {
+  AUTHENTICATION: 'AUTHENTICATION',
   EVENT_BRIDGE: 'EVENT_BRIDGE',
   HTTP: 'HTTP',
   LOGGER: 'LOGGER',
@@ -30,7 +33,8 @@ const Dependencies = {
   [DEFINITIONS.HTTP]: _http.default,
   [DEFINITIONS.LOGGER]: _logger.default,
   [DEFINITIONS.REQUEST]: _request.default,
-  [DEFINITIONS.WAREHOUSE]: _warehouse.default
+  [DEFINITIONS.WAREHOUSE]: _warehouse.default,
+  [DEFINITIONS.AUTHENTICATION]: _authentication.default
 };
 exports.Dependencies = Dependencies;
 var _default = {

package/dist/service/authentication.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _dependencies = require("../config/dependencies");
+
+var _dependencyAware = _interopRequireDefault(require("../dependency-injection/dependency-aware"));
+
+var _organisation = _interopRequireDefault(require("../entity/user/organisation"));
+
+var _userRole = _interopRequireDefault(require("../entity/user/user-role"));
+
+var _response = _interopRequireDefault(require("../model/response"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-next-line import/no-named-as-default,import/no-named-as-default-member
+// eslint-disable-next-line import/no-named-as-default,import/no-named-as-default-member
+
+/**
+ * Authentication Service class
+ */
+class AuthenticationService extends _dependencyAware.default {
+  constructor(di) {
+    super(di);
+    this.initialised = false;
+    const that = this;
+
+    this.initialise = async () => {
+      if (that.initialised === false) {
+        const warehouse = di.get(_dependencies.DEFINITIONS.WAREHOUSE);
+        that.connection = await warehouse.connect();
+        this.initialised = true;
+        this.userRoleRepository = await that.connection.getRepository(_userRole.default);
+        this.organisationRepository = await that.connection.getRepository(_organisation.default);
+        this.user = JSON.parse(di.getEvent().requestContext.authorizer.user);
+      }
+    };
+  }
+  /**
+   * Fetch a users organisations
+   * @param user
+   * @returns {Promise<*[]>}
+   */
+
+
+  async fetchUserOrganisations(user) {
+    await this.initialise();
+    const response = [];
+
+    for await (const organisation of user.organisations) {
+      const orgs = await this.organisationRepository.findDescendants(organisation, {
+        relations: ['parent']
+      });
+
+      for (const org of orgs) {
+        response.push(org);
+      }
+    }
+
+    return response;
+  }
+  /**
+   * Check user role and organisation access
+   * @param organisationID
+   * @param roles
+   * @returns {Promise<boolean>}
+   */
+
+
+  async checkUserRoles(organisationID = null, roles = []) {
+    await this.initialise(); // If the organisation is not null, then check the user organisation permissions
+
+    if (organisationID !== null) {
+      // Fetch the users organisations that they have access to
+      const organisations = await this.fetchUserOrganisations(this.user); // Loop through the organisations and try to find
+
+      let organisationFound = false;
+
+      for (const organisationEntity of organisations) {
+        if (organisationEntity.id === organisationID) {
+          organisationFound = true;
+        }
+      } // Throw an error if the user does not have the organisation
+
+
+      if (organisationFound === false) {
+        const notFoundResponse = new _response.default(null, 401);
+        notFoundResponse.addError({
+          title: 'Unauthorized',
+          message: 'You do not have sufficient privileges to access data for this organisation',
+          documentation_url: 'https://developers.felloh.com/errors#error-responses',
+          type: 'unauthorized',
+          code: 'unauthorized.organisation'
+        });
+        throw notFoundResponse;
+      }
+    } // If the roles are not null, then check the users roles
+
+
+    if (roles.length >= 1) {
+      // Fetch the users assigned roles
+      const userRoles = await this.userRoleRepository.createQueryBuilder('user_roles').leftJoinAndSelect('user_roles.role', 'role').where('user_id = :userID', {
+        userID: this.user.id
+      }).getMany(); // Loop through the roles and determine match count
+
+      let roleCount = 0;
+
+      for (const userRole of userRoles) {
+        if (roles.indexOf(userRole.role.machine_name) !== -1) {
+          roleCount += 1;
+        }
+      } // Throw an error if the user does not have all the roles
+
+
+      if (roleCount !== roles.length) {
+        const notFoundResponse = new _response.default(null, 401);
+        notFoundResponse.addError({
+          title: 'Unauthorized',
+          message: 'You do not have sufficient privileges to be able to facilitate this request',
+          documentation_url: 'https://developers.felloh.com/errors#error-responses',
+          type: 'unauthorized',
+          code: 'unauthorized.roles'
+        });
+        throw notFoundResponse;
+      }
+    }
+
+    return true;
+  }
+
+}
+
+exports.default = AuthenticationService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@felloh-org/lambda-wrapper",
-  "version": "1.1.45",
+  "version": "1.1.46",
   "description": "Lambda wrapper for all Felloh Serverless Projects",
   "main": "dist/index.js",
   "scripts": {