@builttocreate/engine-utils 1.17.0-rc1 → 1.17.1-rc2

package/dist/reduxApiMiddleware.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.CALL_API = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var CALL_API = 'CALL API';
+exports.CALL_API = CALL_API;
+
+var callApiMiddleware = function callApiMiddleware(_ref) {
+  var dispatch = _ref.dispatch,
+      getState = _ref.getState;
+
+  /**
+   * @param next //Callback for the action
+   * @param action //Action object
+   *
+   * async action example: {
+   *   CALL_API: {
+   *     types: [ACTION_REQUEST, ACTION_SUCCESS, ACTION_FAILURE],
+   *     apiCall: apiMethodCall, //apiMethodCall should return a promise
+   *     success: callbackFunction,
+   *     error: callbackFunction
+   *   }
+   * }
+   */
+  return function (next) {
+    return function (action) {
+      var callApi = action[CALL_API]; //If callApi is not defined then it is a normal action (synchronous) pass it through
+
+      if (typeof callApi === 'undefined') return next(action);
+      var types = callApi.types,
+          apiCall = callApi.apiCall;
+      var successCallback = callApi.success;
+      var errorCallback = callApi.error;
+      /**
+       * Action validation
+       *
+       * Types:
+       * All async actions should have three action types: requested, success, & failure
+       * All actions should be strings.
+       *
+       * apiCall:
+       * All aysnc actions should have an apiCall function
+       */
+
+      if (!Array.isArray(types) || types.length !== 3) {
+        throw new Error('action.types: Expected an array of three action types');
+      }
+
+      if (!types.every(function (type) {
+        return typeof type === 'string';
+      })) {
+        throw new Error('action.types: Expected action types to be strings');
+      }
+
+      if (typeof apiCall !== 'function') {
+        throw new Error('action.apiCall: Expected apiCall to be a function');
+      }
+
+      var actionWith = function actionWith(data) {
+        var finalAction = _objectSpread(_objectSpread({}, action), data);
+
+        delete finalAction[CALL_API];
+        return finalAction;
+      };
+
+      var _callApi$types = (0, _slicedToArray2["default"])(callApi.types, 3),
+          requestType = _callApi$types[0],
+          successType = _callApi$types[1],
+          failureType = _callApi$types[2];
+
+      next(actionWith({
+        type: requestType
+      }));
+      return apiCall().then(function (response) {
+        next(actionWith({
+          type: successType,
+          payload: response
+        }));
+        if (successCallback) successCallback(response, dispatch, getState);
+      })["catch"](function (error) {
+        next(actionWith({
+          type: failureType,
+          payload: error,
+          error: true
+        }));
+        if (errorCallback) errorCallback(error, dispatch, getState);
+      });
+    };
+  };
+};
+
+var _default = callApiMiddleware;
+exports["default"] = _default;

package/dist/roleHelper.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.hasRoles = exports.hasAdminRole = void 0;
+
+var _Roles = _interopRequireDefault(require("./constants/Roles"));
+
+var hasAdminRole = function hasAdminRole(permissions) {
+  return hasRoles([_Roles["default"].admin.value], permissions);
+};
+
+exports.hasAdminRole = hasAdminRole;
+
+var hasRoles = function hasRoles(roles, permissions) {
+  /**
+   * If one of users permissions has a role inside of the
+   * roles property then return true
+   */
+  return !permissions || permissions.length < 1 ? false : permissions.find(function (perm) {
+    return roles.indexOf(perm.role) !== -1;
+  });
+};
+
+exports.hasRoles = hasRoles;
+var _default = {
+  hasAdminRole: hasAdminRole,
+  hasRoles: hasRoles
+};
+exports["default"] = _default;