@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/node/auth/Security/RestrictionsState/actions.js

@@ -0,0 +1,452 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _helpers = require("../../../helpers");
+var _restApi = require("@frontegg/rest-api");
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback"],
+  _excluded4 = ["callback"];
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * @private
+   */
+  const __getPagination = statePagination => {
+    var _statePagination$_fil, _statePagination$_lim, _statePagination$_off;
+    return {
+      _filter: (_statePagination$_fil = statePagination == null ? void 0 : statePagination._filter) != null ? _statePagination$_fil : _restApi.RestrictionType.ALLOW,
+      _limit: (_statePagination$_lim = statePagination == null ? void 0 : statePagination._limit) != null ? _statePagination$_lim : 10,
+      _offset: (_statePagination$_off = statePagination == null ? void 0 : statePagination._offset) != null ? _statePagination$_off : 0
+    };
+  };
+
+  /**
+   * This function is used to wrap sagas of the security page.
+   * This function returns function,
+   * that execute the saga it gets as a parameter,
+   * and after it execute loadRecommendations and loadInsights sagas.
+   * We need to call loadRecommendations and loadInsights after all change in the security page,
+   * in order to keep the recommendations and insights updated.
+   * @param action - saga to execute
+   * @protected
+   */
+  const __securityCenterSagaWrapper = action => {
+    return async (...args) => {
+      const [securityCenterFeatureFlag] = await actions.getFeatureFlags(['security-center-admin-portal-major-version']);
+      await action(...args);
+      if (securityCenterFeatureFlag) {
+        await actions.loadRecommendations();
+        await actions.loadInsights();
+      }
+    };
+  };
+  const setRestrictionsState = state => {
+    Object.assign(store.auth.restrictionsState, state);
+  };
+  const setIpRestrictionsState = state => {
+    Object.assign(store.auth.restrictionsState.ipRestrictions, state);
+  };
+  const setEmailDomainRestrictionsState = state => {
+    Object.assign(store.auth.restrictionsState.emailDomainRestrictions, state);
+  };
+  const loadIpRestrictions = async () => {
+    setIpRestrictionsState({
+      loading: true,
+      error: null
+    });
+    try {
+      const ipRestrictionState = store.auth.restrictionsState.ipRestrictions;
+      const restrictionsConfig = await api.auth.getIPRestrictionsConfig();
+      const pagination = __getPagination({
+        _filter: restrictionsConfig.strategy,
+        _limit: ipRestrictionState.pagination._limit,
+        _offset: ipRestrictionState.pagination._offset
+      });
+      const {
+        items,
+        _metadata: {
+          totalPages
+        }
+      } = await api.auth.getIPRestrictions(pagination);
+
+      // @ts-ignore // TODO: fix type in rest-api
+      const restrictions = items;
+      setIpRestrictionsState({
+        data: {
+          restrictions,
+          config: restrictionsConfig
+        },
+        totalPages,
+        pagination,
+        loading: false
+      });
+    } catch (e) {
+      setIpRestrictionsState({
+        error: (0, _helpers.errorHandler)(e),
+        loading: false
+      });
+    }
+  };
+  const saveIpRestriction = async payload => {
+    const {
+        callback
+      } = payload,
+      newRestriction = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded);
+    setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    try {
+      var _ipRestrictionsState$, _ipRestrictionsState$2;
+      await api.auth.createIPRestriction(newRestriction);
+      const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+      const pagination = __getPagination(ipRestrictionsState.pagination);
+      const {
+        items,
+        _metadata: {
+          totalPages
+        }
+      } = await api.auth.getIPRestrictions(pagination);
+
+      // @ts-ignore // TODO: fix type in rest-api
+      const restrictions = items;
+      await checkIfUserIpValid();
+      setIpRestrictionsState({
+        data: {
+          config: (_ipRestrictionsState$ = (_ipRestrictionsState$2 = ipRestrictionsState.data) == null ? void 0 : _ipRestrictionsState$2.config) != null ? _ipRestrictionsState$ : {
+            isActive: false,
+            strategy: _restApi.RestrictionType.ALLOW
+          },
+          restrictions
+        },
+        pagination,
+        totalPages,
+        saving: false
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setIpRestrictionsState({
+        saving: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null, e);
+    }
+  };
+  const saveIpRestrictionsConfig = async payload => {
+    const {
+        callback
+      } = payload,
+      config = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded2);
+    setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    try {
+      await api.auth.updateIPRestrictionConfig(config);
+      const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+      const restrictionsConfig = await api.auth.getIPRestrictionsConfig();
+      const pagination = __getPagination((0, _extends2.default)({}, ipRestrictionsState.pagination, {
+        _filter: restrictionsConfig.strategy
+      }));
+      const {
+        items,
+        _metadata: {
+          totalPages
+        }
+      } = await api.auth.getIPRestrictions(pagination);
+
+      // @ts-ignore // TODO: fix type in rest-api
+      const restrictions = items;
+      await checkIfUserIpValid();
+      setIpRestrictionsState({
+        data: {
+          config: restrictionsConfig,
+          restrictions
+        },
+        pagination,
+        totalPages,
+        saving: false
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setIpRestrictionsState({
+        saving: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null, e);
+    }
+  };
+  const deleteIpRestriction = async payload => {
+    const {
+      id,
+      callback
+    } = payload;
+    setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    try {
+      var _ipRestrictionsState$3;
+      await api.auth.deleteIPRestriction(id);
+      const ipRestrictionsState = store.auth.restrictionsState.ipRestrictions;
+      const pagination = __getPagination(ipRestrictionsState.pagination);
+      const {
+        items,
+        _metadata: {
+          totalPages
+        }
+      } = await api.auth.getIPRestrictions(pagination);
+
+      // @ts-ignore // TODO: fix type in rest-api
+      const restrictions = items;
+      await checkIfUserIpValid();
+      setIpRestrictionsState({
+        data: {
+          config: ((_ipRestrictionsState$3 = ipRestrictionsState.data) == null ? void 0 : _ipRestrictionsState$3.config) || {
+            isActive: false,
+            strategy: _restApi.RestrictionType.ALLOW
+          },
+          restrictions
+        },
+        pagination,
+        totalPages,
+        saving: false
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setIpRestrictionsState({
+        saving: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null, e);
+    }
+  };
+  const checkIfUserIpValid = async () => {
+    try {
+      const {
+        valid: userIpValid
+      } = await api.auth.testCurrentIpInAllowList();
+      setIpRestrictionsState({
+        userIpValid
+      });
+    } catch (e) {
+      setIpRestrictionsState({
+        error: (0, _helpers.errorHandler)(e)
+      });
+    }
+  };
+  const addCurrentUserIpAndActivate = async payload => {
+    const {
+      callback
+    } = payload;
+    setIpRestrictionsState({
+      saving: true,
+      error: null
+    });
+    try {
+      var _store$auth$userIp;
+      const userIp = (_store$auth$userIp = store.auth.userIp) != null ? _store$auth$userIp : '';
+      await Promise.all([api.auth.createIPRestriction({
+        ip: userIp,
+        isActive: true,
+        description: 'My IP',
+        strategy: _restApi.RestrictionType.ALLOW
+      }), api.auth.updateIPRestrictionConfig({
+        isActive: true
+      })]);
+      const ipRestrictionState = store.auth.restrictionsState.ipRestrictions;
+      const pagination = __getPagination(ipRestrictionState.pagination);
+      const {
+        items,
+        _metadata: {
+          totalPages
+        }
+      } = await api.auth.getIPRestrictions(pagination);
+
+      // @ts-ignore // TODO: fix type in rest-api
+      const restrictions = items;
+      setIpRestrictionsState({
+        data: {
+          config: {
+            isActive: true,
+            strategy: _restApi.RestrictionType.ALLOW
+          },
+          restrictions
+        },
+        userIpValid: true,
+        pagination,
+        totalPages,
+        saving: false
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setIpRestrictionsState({
+        saving: false,
+        error: e
+      });
+      callback == null ? void 0 : callback(false, e);
+    }
+  };
+  const loadEmailDomainRestrictions = async () => {
+    setEmailDomainRestrictionsState({
+      loading: true,
+      error: null
+    });
+    try {
+      const restrictionsConfig = await api.auth.getDomainRestrictionsConfig();
+      const restrictions = await api.auth.getDomainRestrictions();
+      const filteredRestrictions = restrictions.items.filter(restriction => restriction.type === restrictionsConfig.listType);
+      setEmailDomainRestrictionsState({
+        data: {
+          restrictions: filteredRestrictions,
+          config: restrictionsConfig
+        },
+        loading: false
+      });
+    } catch (e) {
+      setEmailDomainRestrictionsState({
+        error: (0, _helpers.errorHandler)(e),
+        loading: false
+      });
+    }
+  };
+  const saveEmailDomainRestriction = async payload => {
+    const {
+        callback
+      } = payload,
+      newRestriction = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded3);
+    setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    try {
+      var _emailDomainRestricti2;
+      await api.auth.createDomainRestriction(newRestriction);
+      const restrictions = await api.auth.getDomainRestrictions();
+      const filteredRestrictions = restrictions.items.filter(restriction => {
+        var _emailDomainRestricti;
+        return restriction.type === ((_emailDomainRestricti = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti.config.listType);
+      });
+      setEmailDomainRestrictionsState({
+        data: {
+          config: ((_emailDomainRestricti2 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti2.config) || {
+            active: false,
+            blockPublicDomains: false,
+            listType: newRestriction.type
+          },
+          restrictions: filteredRestrictions
+        },
+        saving: false
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setEmailDomainRestrictionsState({
+        saving: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null, e);
+    }
+  };
+  const saveEmailDomainRestrictionsConfig = async payload => {
+    const {
+        callback
+      } = payload,
+      config = (0, _objectWithoutPropertiesLoose2.default)(payload, _excluded4);
+    setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    try {
+      const updatedConfig = await api.auth.updateDomainRestrictionConfig(config);
+      const restrictions = await api.auth.getDomainRestrictions();
+      const filteredRestrictions = restrictions.items.filter(restriction => restriction.type === updatedConfig.listType);
+      setEmailDomainRestrictionsState({
+        data: {
+          config: updatedConfig,
+          restrictions: filteredRestrictions
+        },
+        saving: false
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setEmailDomainRestrictionsState({
+        saving: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null, e);
+    }
+  };
+  const deleteEmailDomainRestriction = async payload => {
+    const {
+      id
+    } = payload;
+    setEmailDomainRestrictionsState({
+      saving: true,
+      error: null
+    });
+    const emailDomainRestrictionsState = store.auth.restrictionsState.emailDomainRestrictions;
+    try {
+      var _emailDomainRestricti4;
+      await api.auth.deleteDomainRestriction(id);
+      const restrictions = await api.auth.getDomainRestrictions();
+      const filteredRestrictions = restrictions.items.filter(restriction => {
+        var _emailDomainRestricti3;
+        return restriction.type === ((_emailDomainRestricti3 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti3.config.listType);
+      });
+      setEmailDomainRestrictionsState({
+        data: {
+          config: ((_emailDomainRestricti4 = emailDomainRestrictionsState.data) == null ? void 0 : _emailDomainRestricti4.config) || {
+            active: false,
+            blockPublicDomains: false,
+            listType: _restApi.RestrictionType.ALLOW
+          },
+          restrictions: filteredRestrictions
+        },
+        saving: false
+      });
+    } catch (e) {
+      setEmailDomainRestrictionsState({
+        saving: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+    }
+  };
+  const wrappedLoadIpRestrictions = __securityCenterSagaWrapper(loadIpRestrictions);
+  const wrappedSaveIpRestriction = __securityCenterSagaWrapper(saveIpRestriction);
+  const wrappedSaveIpRestrictionsConfig = __securityCenterSagaWrapper(saveIpRestrictionsConfig);
+  const wrappedDeleteIpRestriction = __securityCenterSagaWrapper(deleteIpRestriction);
+  const wrappedCheckIfUserIpValid = __securityCenterSagaWrapper(checkIfUserIpValid);
+  const wrappedAddCurrentUserIpAndActivate = __securityCenterSagaWrapper(addCurrentUserIpAndActivate);
+  const wrappedLoadEmailDomainRestrictions = __securityCenterSagaWrapper(loadEmailDomainRestrictions);
+  const wrappedSaveEmailDomainRestriction = __securityCenterSagaWrapper(saveEmailDomainRestriction);
+  const wrappedSaveEmailDomainRestrictionsConfig = __securityCenterSagaWrapper(saveEmailDomainRestrictionsConfig);
+  const wrappedDeleteEmailDomainRestriction = __securityCenterSagaWrapper(deleteEmailDomainRestriction);
+  return {
+    // reducers
+    setRestrictionsState,
+    setIpRestrictionsState,
+    setEmailDomainRestrictionsState,
+    __securityCenterSagaWrapper,
+    // actions
+    loadIpRestrictions: wrappedLoadIpRestrictions,
+    saveIpRestriction: wrappedSaveIpRestriction,
+    saveIpRestrictionsConfig: wrappedSaveIpRestrictionsConfig,
+    deleteIpRestriction: wrappedDeleteIpRestriction,
+    checkIfUserIpValid: wrappedCheckIfUserIpValid,
+    addCurrentUserIpAndActivate: wrappedAddCurrentUserIpAndActivate,
+    loadEmailDomainRestrictions: wrappedLoadEmailDomainRestrictions,
+    saveEmailDomainRestriction: wrappedSaveEmailDomainRestriction,
+    saveEmailDomainRestrictionsConfig: wrappedSaveEmailDomainRestrictionsConfig,
+    deleteEmailDomainRestriction: wrappedDeleteEmailDomainRestriction
+  };
+};
+exports.default = _default;

package/node/auth/Security/RestrictionsState/index.js

@@ -1,70 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.restrictionsState = exports.restrictionsReducers = exports.restrictionsActions = void 0;
-var _toolkit = require("@reduxjs/toolkit");
-var _utils = require("../../utils");
-var _constants = require("../../../constants");
-var _restApi = require("@frontegg/rest-api");
-const restrictionsState = {
-  ipRestrictions: {
-    loading: false,
-    pagination: {
-      _offset: 0,
-      _limit: 4,
-      _filter: _restApi.RestrictionType.ALLOW
-    },
-    totalPages: 1,
-    userIpValid: false
-  },
-  emailDomainRestrictions: {
-    loading: true
+Object.defineProperty(exports, "buildRestrictionsActions", {
+  enumerable: true,
+  get: function () {
+    return _actions.default;
   }
-};
-exports.restrictionsState = restrictionsState;
-const reducers = {
-  setRestrictionsState: (0, _utils.typeReducerForKey)('restrictionsState'),
-  setIpRestrictionsState: (0, _utils.typeReducerNestedKey)('restrictionsState', 'ipRestrictions'),
-  setEmailDomainRestrictionsState: (0, _utils.typeReducerNestedKey)('restrictionsState', 'emailDomainRestrictions')
-};
-exports.restrictionsReducers = reducers;
-const actions = {
-  checkIfUserIpValid: (0, _toolkit.createAction)(`${_constants.authStoreName}/checkIfUserIpValid`),
-  addCurrentUserIpAndActivate: (0, _toolkit.createAction)(`${_constants.authStoreName}/addCurrentUserIpAndActivate`, payload => ({
-    payload
-  })),
-  loadIpRestrictions: (0, _toolkit.createAction)(`${_constants.authStoreName}/loadIpRestrictions`),
-  saveIpRestriction: (0, _toolkit.createAction)(`${_constants.authStoreName}/saveIpRestriction`, payload => ({
-    payload
-  })),
-  saveIpRestrictionsConfig: (0, _toolkit.createAction)(`${_constants.authStoreName}/saveIpRestrictionsConfig`, payload => ({
-    payload
-  })),
-  deleteIpRestriction: (0, _toolkit.createAction)(`${_constants.authStoreName}/deleteIpRestriction`, payload => ({
-    payload
-  })),
-  loadEmailDomainRestrictions: (0, _toolkit.createAction)(`${_constants.authStoreName}/loadEmailDomainRestrictions`),
-  saveEmailDomainRestriction: (0, _toolkit.createAction)(`${_constants.authStoreName}/saveEmailDomainRestriction`, payload => ({
-    payload
-  })),
-  saveEmailDomainRestrictionsConfig: (0, _toolkit.createAction)(`${_constants.authStoreName}/saveEmailDomainRestrictionsConfig`, payload => ({
-    payload
-  })),
-  deleteEmailDomainRestriction: (0, _toolkit.createAction)(`${_constants.authStoreName}/deleteEmailDomainRestriction`, payload => ({
-    payload
-  }))
-};
-
-/**
- *  To be used for actions types after dispatch, and should contains
- *  the reducers and actions as standalone function
- */
-exports.restrictionsActions = actions;
-// noinspection JSUnusedLocalSymbols
-/**
- *  if you see error in matcher that's mean the DispatchAction does not
- *  contains the same functions in reducers and actions
- */
-const Matcher = {};
+});
+Object.defineProperty(exports, "createRestrictionsState", {
+  enumerable: true,
+  get: function () {
+    return _state.default;
+  }
+});
+var _state = _interopRequireDefault(require("./state"));
+var _actions = _interopRequireDefault(require("./actions"));

package/node/auth/Security/RestrictionsState/state.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialState = exports.default = void 0;
+var _restApi = require("@frontegg/rest-api");
+var _proxy = require("../../../toolkit/proxy");
+const initialState = {
+  ipRestrictions: {
+    loading: false,
+    pagination: {
+      _offset: 0,
+      _limit: 4,
+      _filter: _restApi.RestrictionType.ALLOW
+    },
+    totalPages: 1,
+    userIpValid: false
+  },
+  emailDomainRestrictions: {
+    loading: true
+  }
+};
+exports.initialState = initialState;
+var _default = overrideState => (0, _proxy.createProxy)(initialState, overrideState);
+exports.default = _default;