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

package/node/auth/interfaces.js

@@ -17,7 +17,7 @@ exports.AuthenticationTypes = AuthenticationTypes;
   AuthenticationTypes["SOCIAL_LOGIN"] = "SOCIAL_LOGIN";
   AuthenticationTypes["PASSWORD"] = "PASSWORD";
 })(AuthenticationTypes || (exports.AuthenticationTypes = AuthenticationTypes = {}));
-let AdminPortalPagesForEvents;
+let AdminPortalPagesForEvents; // noinspection JSUnusedGlobalSymbols
 exports.AdminPortalPagesForEvents = AdminPortalPagesForEvents;
 (function (AdminPortalPagesForEvents) {
   AdminPortalPagesForEvents["profile"] = "profile";

package/node/connectivity/actions.js

@@ -0,0 +1,542 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _consts = require("./consts");
+var _helpers = require("../helpers");
+var _state = require("./state");
+const _excluded = ["id"],
+  _excluded2 = ["id", "enabled"];
+var _default = (store, api, sharedActions) => {
+  const type2ApiGet = {
+    slack: api.connectivity.getSlackConfiguration,
+    email: api.connectivity.getEmailConfiguration,
+    sms: api.connectivity.getSMSConfiguration,
+    webhook: api.connectivity.getWebhooksConfigurations,
+    categories: api.connectivity.getCategories,
+    channelMap: api.connectivity.getChannelMaps
+  };
+  const addApi = ['categories', 'channelMap'];
+  const type2ApiPost = {
+    slack: api.connectivity.postSlackConfiguration,
+    email: api.connectivity.postEmailConfiguration,
+    sms: api.connectivity.postSMSConfiguration,
+    webhook: api.connectivity.postWebhooksConfiguration
+  };
+  const setConnectivityState = state => {
+    Object.assign(store.connectivity, state);
+  };
+  const postWebhookRetryResult = result => {
+    var _store$connectivity$r;
+    const retryResult = (_store$connectivity$r = store.connectivity.retryResult) != null ? _store$connectivity$r : {};
+    store.connectivity.retryResult = (0, _extends2.default)({}, retryResult, result);
+  };
+  const resetConnectivityState = () => {
+    store.connectivity = (0, _helpers.deepClone)(_state.initialState);
+  };
+  const loadConfigurationFor = async (api, params) => {
+    try {
+      return await type2ApiGet[api](params);
+    } catch (e) {
+      return undefined;
+    }
+  };
+  const loadSlackChannels = async () => {
+    try {
+      setConnectivityState({
+        slackChannels: {
+          isLoading: true
+        }
+      });
+      // @ts-ignore // TODO: [Typescript 4.8] fix @frontegg/rest-api return value
+      const data = await api.connectivity.getSlackChannels();
+      setConnectivityState({
+        error: undefined,
+        slackChannels: {
+          isLoading: false,
+          data
+        }
+      });
+    } catch (e) {
+      setConnectivityState({
+        error: undefined,
+        slackChannels: {
+          isLoading: false
+        }
+      });
+    }
+  };
+  const loadConnectivityChannels = async _payload => {
+    const payload = _payload != null ? _payload : _consts.channels;
+    setConnectivityState({
+      isLoading: true
+    });
+    try {
+      const values = await Promise.all([
+      // @ts-ignore
+      ...payload.map(a => loadConfigurationFor(a)),
+      // @ts-ignore
+      loadConfigurationFor('categories'),
+      // @ts-ignore
+      (async () => {
+        const res = await Promise.all(payload.map(ch => loadConfigurationFor('channelMap', ch)));
+        return res.reduce((acc, curr, idx) => (0, _extends2.default)({}, acc, {
+          [`${payload[idx]}`]: curr
+        }), {});
+      })()]);
+      const webhooks = await loadConfigurationFor('webhook');
+      const data = values.reduce((acc, curr, idx) => {
+        if (payload[idx]) {
+          if (values[values.length - 1][payload[idx]].length) {
+            return (0, _extends2.default)({}, acc, {
+              [`${payload[idx]}`]: curr,
+              list: [...acc.list, {
+                id: idx,
+                key: payload[idx],
+                events: _consts.channels2Platform[payload[idx]].events(curr),
+                active: _consts.channels2Platform[payload[idx]].isActive(curr),
+                platform: _consts.channels2Platform[payload[idx]].title,
+                image: _consts.channels2Platform[payload[idx]].image
+              }]
+            });
+          } else {
+            return acc;
+          }
+        } else {
+          return (0, _extends2.default)({}, acc, {
+            [`${addApi[idx - payload.length]}`]: curr
+          });
+        }
+      }, {
+        list: [],
+        webhook: webhooks
+      });
+      setConnectivityState((0, _extends2.default)({}, data, {
+        error: undefined,
+        isSaving: false,
+        isLoading: false
+      }));
+    } catch (e) {
+      setConnectivityState({
+        isLoading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+    }
+  };
+  const postSlackData = async payload => {
+    var _store$connectivity$s;
+    const stateSlackSubscriptions = (_store$connectivity$s = store.connectivity.slack) == null ? void 0 : _store$connectivity$s.slackSubscriptions;
+    if (!stateSlackSubscriptions) {
+      return;
+    }
+    const {
+      slackSubscriptions
+    } = payload;
+    await Promise.all([...slackSubscriptions.reduce((acc, curr) => {
+      var _curr$slackEvents$0$c, _curr$slackEvents$0$c2;
+      if (!curr.id && curr.slackEvents && (_curr$slackEvents$0$c = curr.slackEvents[0].channelIds) != null && _curr$slackEvents$0$c.length) {
+        return [...acc, curr];
+      }
+      const el = stateSlackSubscriptions == null ? void 0 : stateSlackSubscriptions.find(_ref => {
+        let {
+            id
+          } = _ref,
+          props = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+        return id === curr.id && JSON.stringify((0, _extends2.default)({
+          id
+        }, props)) !== JSON.stringify(curr);
+      });
+      if (el && curr.slackEvents && (_curr$slackEvents$0$c2 = curr.slackEvents[0].channelIds) != null && _curr$slackEvents$0$c2.length) {
+        return [...acc, curr];
+      }
+      return acc;
+    }, []).map(el => type2ApiPost.slack(el)), ...slackSubscriptions.reduce((acc, curr) => {
+      if (curr.id && !curr.slackEvents[0].channelIds.length) {
+        return [...acc, curr];
+      }
+      return acc;
+    }, []).map(el => api.connectivity.deleteSlackConfiguration(el))]);
+  };
+  const postEmailSMSData = async (payload, type) => {
+    const processIds = store.connectivity.processIds;
+    const stateData = store.connectivity[type];
+    if (!stateData) return;
+    let actionsResult = [];
+    try {
+      actionsResult = await Promise.all([
+      // create new
+      ...payload.reduce((acc, curr) => {
+        const state = stateData.find(({
+          eventKey
+        }) => eventKey === curr.eventKey);
+        if (!state && curr.subscriptions[0].recipients.filter(el => el).length) {
+          return [...acc, curr];
+        }
+        return acc;
+      }, []).map(data => {
+        if (type === 'email') {
+          return api.connectivity.postEmailConfiguration(data);
+        } else {
+          return api.connectivity.postSMSConfiguration(data);
+        }
+      }), ...payload.reduce((acc, curr) => {
+        const state = stateData.find(({
+          eventKey
+        }) => eventKey === curr.eventKey);
+        if (state && JSON.stringify(state) !== JSON.stringify(curr)) {
+          return [...acc, curr];
+        }
+        return acc;
+      }, []).map(data => {
+        const {
+          subscriptions,
+          eventKey
+        } = data;
+        const _subscriptions$ = subscriptions[0],
+          {
+            id = '',
+            enabled
+          } = _subscriptions$,
+          body = (0, _objectWithoutPropertiesLoose2.default)(_subscriptions$, _excluded2);
+        return Promise.all([type === 'email' ? api.connectivity.patchEmailConfiguration({
+          eventKey,
+          enabled
+        }) : api.connectivity.patchSMSConfiguration({
+          eventKey,
+          enabled
+        }), type === 'email' ? api.connectivity.putEmailSubscriptions(id, eventKey, (0, _extends2.default)({}, body, {
+          enabled
+        })) : api.connectivity.putSMSSubscriptions(id, eventKey, (0, _extends2.default)({}, body, {
+          enabled
+        }))]);
+      }),
+      // delete record with empty recipients
+      ...payload.reduce((acc, curr) => {
+        const state = stateData.find(({
+          eventKey
+        }) => eventKey === curr.eventKey);
+        if (state && state.subscriptions[0].recipients.length && !curr.subscriptions[0].recipients.filter(el => !!el).length) {
+          return [...acc, curr];
+        }
+        return acc;
+      }, []).map(({
+        eventKey,
+        subscriptions
+      }) => {
+        if (type === 'email') {
+          return api.connectivity.deleteEmailSubscriptions(eventKey, subscriptions[0].id || '');
+        } else {
+          return api.connectivity.deleteSMSSubscriptions(eventKey, subscriptions[0].id || '');
+        }
+      })]);
+    } catch {
+      /* empty */
+    }
+    if (actionsResult.length) {
+      // @ts-ignore
+      const newData = await loadConfigurationFor(type);
+      setConnectivityState({
+        error: undefined,
+        isSaving: false,
+        [`${type}`]: newData,
+        processIds: newData.id ? processIds.filter(el => el !== newData.id) : processIds
+      });
+      await checkNewStatus(type, newData);
+    } else {
+      setConnectivityState({
+        error: undefined,
+        isSaving: false,
+        [`${type}`]: stateData,
+        processIds: processIds
+      });
+    }
+  };
+  const checkNewStatus = async (platform, data) => {
+    const {
+      list
+    } = store.connectivity;
+    const currPlatform = list.find(({
+      key
+    }) => key === platform);
+    if (!currPlatform) return;
+    const newActive = _consts.channels2Platform[platform].isActive(data);
+    if (newActive === currPlatform.active) return;
+    setConnectivityState({
+      list: list.map(elm => elm.key === platform ? (0, _extends2.default)({}, elm, {
+        active: newActive
+      }) : elm)
+    });
+  };
+  const postChannelData = async payload => {
+    const {
+      platform,
+      data,
+      callback
+    } = payload;
+    const processIds = store.connectivity.processIds;
+    try {
+      setConnectivityState({
+        isSaving: true,
+        //@ts-ignore
+        processIds: platform === 'webhook' ? [data._id, ...processIds] : processIds
+      });
+      if (platform === 'slack') {
+        await postSlackData(data);
+      } else if (['sms', 'email'].includes(platform)) {
+        await postEmailSMSData(data, platform);
+      } else {
+        await type2ApiPost[platform](data);
+      }
+      if (!['sms', 'email'].includes(platform)) {
+        // @ts-ignore
+        const newData = await loadConfigurationFor(platform);
+        if (platform === 'webhook') {
+          newData.id = data._id;
+        }
+        setConnectivityState({
+          error: undefined,
+          isSaving: false,
+          [`${platform}`]: newData,
+          processIds: newData.id ? processIds.filter(el => el !== newData.id) : processIds
+        });
+        await checkNewStatus(platform, newData);
+        callback == null ? void 0 : callback(true);
+      }
+    } catch (e) {
+      setConnectivityState({
+        error: (0, _helpers.errorHandler)(e),
+        isSaving: false,
+        isLoading: false
+      });
+    }
+  };
+  const postSlackCode = async payload => {
+    try {
+      await api.connectivity.postSlackCode(payload);
+    } catch {
+      /* empty */
+    }
+    setConnectivityState({
+      error: undefined,
+      isSaving: false
+    });
+  };
+  const loadSlackPermissions = async () => {
+    const slackChannels = store.connectivity.slackChannels;
+    try {
+      setConnectivityState({
+        slackChannels: (0, _extends2.default)({}, slackChannels, {
+          isLoadingScope: true
+        })
+      });
+      // TODO: fix rest-api types
+      const {
+        clientId
+      } = await api.connectivity.getSlackScope();
+      setConnectivityState({
+        slackChannels: {
+          error: undefined,
+          clientId,
+          isLoadingScope: false,
+          isLoading: false
+        }
+      });
+    } catch {
+      setConnectivityState({
+        slackChannels: {
+          error: undefined,
+          isLoadingScope: false,
+          isLoading: false
+        }
+      });
+    }
+  };
+  const deleteWebhookConfig = async payload => {
+    const {
+      callback,
+      webhookId
+    } = payload;
+    const processIds = store.connectivity.processIds;
+    try {
+      setConnectivityState({
+        isSaving: true
+      });
+      await api.connectivity.deleteWebhooksConfiguration(webhookId);
+    } catch (e) {
+      callback == null ? void 0 : callback(null, (0, _helpers.errorHandler)(e));
+    }
+    const newData = await loadConfigurationFor('webhook');
+    if (newData) {
+      setConnectivityState({
+        error: undefined,
+        isSaving: false,
+        webhook: newData,
+        processIds: newData.id ? processIds.filter(el => el !== newData.id) : processIds
+      });
+    }
+    callback == null ? void 0 : callback(true);
+  };
+  const postWebhookTest = async payload => {
+    try {
+      setConnectivityState({
+        isTesting: true
+      });
+      // TODO: fix rest-api types
+      const {
+        statusCode,
+        body
+      } = await api.connectivity.postWebhookTest(payload);
+      if ([201, 200].includes(statusCode)) {
+        const message = JSON.stringify(body, null, 2);
+        setConnectivityState({
+          isTesting: false,
+          testResult: {
+            status: 'success',
+            message
+          }
+        });
+      } else {
+        setConnectivityState({
+          isTesting: false,
+          testResult: {
+            status: 'failed'
+          }
+        });
+      }
+    } catch (e) {
+      setConnectivityState({
+        isTesting: false,
+        testResult: {
+          status: 'failed',
+          message: (0, _helpers.errorHandler)(e)
+        }
+      });
+    }
+  };
+  const postWebhookRetry = async payload => {
+    try {
+      // TODO: fix rest-api types
+      const {
+        statusCode
+      } = await api.connectivity.postWebhookRetry(payload);
+      postWebhookRetryResult({
+        [payload]: {
+          isProcess: false,
+          success: statusCode === 202
+        }
+      });
+    } catch (e) {
+      postWebhookRetryResult({
+        [payload]: {
+          isProcess: false,
+          success: false
+        }
+      });
+    }
+  };
+  const loadWebhookLogs = async payload => {
+    const {
+      id,
+      limit,
+      offset
+    } = payload;
+    const webhookLogs = store.connectivity.webhookLogs;
+    try {
+      setConnectivityState({
+        webhookLogs: (0, _extends2.default)({}, webhookLogs, {
+          isLoading: true
+        })
+      });
+      //TODO: Fix types
+      const data = await api.connectivity.getWebhookLog(id, offset, limit);
+      setConnectivityState({
+        error: undefined,
+        webhookLogs: (0, _extends2.default)({
+          isLoading: false
+        }, data)
+      });
+    } catch (e) {
+      setConnectivityState({
+        error: undefined,
+        webhookLogs: {
+          isLoading: false
+        }
+      });
+    }
+  };
+  const cleanWebhookTestData = () => {
+    setConnectivityState({
+      testResult: undefined
+    });
+  };
+  const cleanWebhookLogsData = async () => {
+    setConnectivityState({
+      webhookLogs: undefined
+    });
+  };
+  const cleanWebhookTestMessage = async state => {
+    var _state$testResult;
+    setConnectivityState({
+      testResult: {
+        status: (_state$testResult = state.testResult) == null ? void 0 : _state$testResult.status,
+        message: undefined
+      }
+    });
+  };
+  const cleanError = async () => {
+    setConnectivityState({
+      error: undefined
+    });
+  };
+  const cleanSlackData = async () => {
+    setConnectivityState({
+      slackChannels: {
+        isLoading: false
+      }
+    });
+  };
+  return {
+    setConnectivityState,
+    // @deprecated Use  resetConnectivityState
+    initData: resetConnectivityState,
+    resetConnectivityState,
+    // @deprecated Use loadSlackChannels
+    loadSlackActions: loadSlackChannels,
+    loadSlackChannels,
+    // @deprecated Use loadConnectivityChannels
+    loadDataAction: loadConnectivityChannels,
+    loadConnectivityChannels,
+    // @deprecated Use postChannelData
+    postDataAction: postChannelData,
+    postChannelData,
+    // @deprecated Use postSlackCode
+    postCodeAction: postSlackCode,
+    postSlackCode,
+    // @deprecated Use loadSlackPermissions
+    loadScope: loadSlackPermissions,
+    loadSlackPermissions,
+    // @deprecated Use deleteWebhookConfig
+    deleteWebhookConfigAction: deleteWebhookConfig,
+    deleteWebhookConfig,
+    // @deprecated Use postWebhookTest
+    postWebhookTestAction: postWebhookTest,
+    postWebhookTest,
+    // @deprecated Use postWebhookRetry
+    postWebhookRetryAction: postWebhookRetry,
+    postWebhookRetry,
+    // @deprecated Use loadWebhookLogs
+    loadWebhookLogsAction: loadWebhookLogs,
+    loadWebhookLogs,
+    cleanWebhookTestData,
+    cleanWebhookLogsData,
+    cleanWebhookTestMessage,
+    cleanError,
+    cleanSlackData
+  };
+};
+exports.default = _default;

package/node/connectivity/consts.js

@@ -3,28 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.type2ApiPost = exports.type2ApiGet = exports.defaultRootPath = exports.channels2Platform = exports.channels = void 0;
-var _restApi = require("@frontegg/rest-api");
-/* eslint-disable */
-
-const type2ApiGet = {
-  slack: _restApi.api.connectivity.getSlackConfiguration,
-  email: _restApi.api.connectivity.getEmailConfiguration,
-  sms: _restApi.api.connectivity.getSMSConfiguration,
-  webhook: _restApi.api.connectivity.getWebhooksConfigurations,
-  categories: _restApi.api.connectivity.getCategories,
-  channelMap: _restApi.api.connectivity.getChannelMaps
-};
-exports.type2ApiGet = type2ApiGet;
-const type2ApiPost = {
-  slack: _restApi.api.connectivity.postSlackConfiguration,
-  email: _restApi.api.connectivity.postEmailConfiguration,
-  sms: _restApi.api.connectivity.postSMSConfiguration,
-  webhook: _restApi.api.connectivity.postWebhooksConfiguration
-};
-exports.type2ApiPost = type2ApiPost;
-const defaultRootPath = '/connectivity';
-exports.defaultRootPath = defaultRootPath;
+exports.channels2Platform = exports.channels = void 0;
 const channels = ['email', 'slack', 'sms', 'webhook'];
 exports.channels = channels;
 const channels2Platform = {
@@ -56,12 +35,9 @@ const channels2Platform = {
       var _slackSubscriptions;
       return (data == null ? void 0 : (_slackSubscriptions = data.slackSubscriptions) == null ? void 0 : _slackSubscriptions.length) || 0;
     },
-    isActive: data => {
-      var _slackSubscriptions$s;
-      return (_slackSubscriptions$s = !!(data != null && data.slackSubscriptions.some(({
-        isActive
-      }) => isActive))) != null ? _slackSubscriptions$s : false;
-    },
+    isActive: data => !!(data != null && data.slackSubscriptions.some(({
+      isActive
+    }) => isActive)),
     image: 'slack'
   },
   webhook: {

package/node/connectivity/index.js

@@ -1,68 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _exportNames = {
-  connectivityReducers: true,
-  connectivityActions: true,
-  connectivityInitialState: true,
-  connectivitySagas: true,
-  connectivityStoreName: true
-};
-Object.defineProperty(exports, "connectivityActions", {
+Object.defineProperty(exports, "buildConnectivityActions", {
   enumerable: true,
   get: function () {
-    return _reducer.actions;
+    return _actions.default;
   }
 });
-Object.defineProperty(exports, "connectivityInitialState", {
+Object.defineProperty(exports, "createConnectivityState", {
   enumerable: true,
   get: function () {
-    return _reducer.initialState;
+    return _state.default;
   }
 });
-Object.defineProperty(exports, "connectivityReducers", {
-  enumerable: true,
-  get: function () {
-    return _reducer.reducer;
-  }
-});
-Object.defineProperty(exports, "connectivitySagas", {
-  enumerable: true,
-  get: function () {
-    return _saga.sagas;
-  }
-});
-Object.defineProperty(exports, "connectivityStoreName", {
-  enumerable: true,
-  get: function () {
-    return _constants.connectivityStoreName;
-  }
-});
-exports.default = void 0;
-var _reducer = require("./reducer");
-var _saga = require("./saga");
-var _constants = require("../constants");
-var _interfaces = require("./interfaces");
-Object.keys(_interfaces).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _interfaces[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _interfaces[key];
-    }
-  });
-});
-// export types
-// export store
-var _default = {
-  sagas: _saga.sagas,
-  storeName: _constants.connectivityStoreName,
-  initialState: _reducer.initialState,
-  reducer: _reducer.reducer,
-  actions: _reducer.actions
-};
-exports.default = _default;
+var _state = _interopRequireDefault(require("./state"));
+var _actions = _interopRequireDefault(require("./actions"));

package/node/connectivity/state.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialState = exports.default = void 0;
+var _proxy = require("../toolkit/proxy");
+const initialState = {
+  isLoading: false,
+  isSaving: false,
+  list: [],
+  processIds: [],
+  slackChannels: {
+    isLoading: false
+  }
+};
+exports.initialState = initialState;
+var _default = overrideState => (0, _proxy.createProxy)(initialState, overrideState);
+exports.default = _default;