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

package/auth/SSOState/actions/actions.v2.js

@@ -0,0 +1,359 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback", "ssoConfigId"],
+  _excluded3 = ["callback", "ssoConfigId"],
+  _excluded4 = ["callback", "ssoConfigId"];
+import { SSOStateKeys } from '../interfaces';
+import { errorHandler, readFileAsText } from '../../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * @private
+   */
+  const __loadOidc = async () => {
+    try {
+      return await api.auth.getOidcConfiguration();
+    } catch (e) {
+      return null;
+    }
+  };
+
+  /**
+   * @private
+   */
+  const __loadSaml = async () => {
+    try {
+      return await api.metadata.getSamlMetadata();
+    } catch (e) {
+      return null;
+    }
+  };
+
+  /**
+   * Helper function to perform loading and error handling with try catch
+   * @param key loading / error key
+   * @param callback withCallback function
+   * @param block function to execute
+   * @private
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const __ssoTryCatch = async (key, callback, block) => {
+    actions.setSSOLoader({
+      key,
+      value: true
+    });
+    try {
+      await block();
+    } catch (error) {
+      actions.setSSOError({
+        key,
+        value: errorHandler(error)
+      });
+      callback == null ? void 0 : callback(null, error);
+    } finally {
+      actions.setSSOLoader({
+        key,
+        value: false
+      });
+    }
+  };
+  const loadSSOConfigurationsV2 = async () => {
+    await __ssoTryCatch(SSOStateKeys.LOAD_SSO_CONFIGURATIONS, undefined, async () => {
+      const [oidcConfiguration, samlMetadata] = await Promise.all([__loadOidc(), __loadSaml()]);
+      const ssoConfigurations = await api.auth.getSSOConfigurations();
+      actions.setSSOState({
+        ssoConfigurations,
+        oidcConfiguration,
+        samlMetadata
+      });
+    });
+  };
+  const saveSSOConfigurationV2 = async payload => {
+    const {
+        callback
+      } = payload,
+      ssoConfiguration = _objectWithoutPropertiesLoose(payload, _excluded);
+    const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_CONFIGURATION, callback, async () => {
+      var _ssoConfiguration$ena;
+      const newSsoConfiguration = await api.auth.createSSOConfiguration(_extends({}, ssoConfiguration, {
+        enabled: (_ssoConfiguration$ena = ssoConfiguration.enabled) != null ? _ssoConfiguration$ena : false
+      }));
+      actions.setSSOState({
+        ssoConfigurations: [...ssoConfigurations, newSsoConfiguration]
+      });
+      callback == null ? void 0 : callback(newSsoConfiguration);
+    });
+  };
+  const updateSSOConfiguration = async payload => {
+    const {
+        callback,
+        ssoConfigId
+      } = payload,
+      ssoConfiguration = _objectWithoutPropertiesLoose(payload, _excluded2);
+    const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+    await __ssoTryCatch(SSOStateKeys.UPDATE_SSO_CONFIGURATION, callback, async () => {
+      const newSsoConfiguration = await api.auth.updateSSOConfiguration(ssoConfigId, ssoConfiguration);
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => ssoConfig.id === ssoConfigId ? newSsoConfiguration : ssoConfig);
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(newSsoConfiguration);
+    });
+  };
+  const deleteSSOConfiguration = async payload => {
+    const {
+      ssoConfigId,
+      callback
+    } = payload;
+    const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+    await __ssoTryCatch(SSOStateKeys.DELETE_SSO_CONFIGURATION, callback, async () => {
+      await api.auth.deleteSSOConfiguration(ssoConfigId);
+      actions.setSSOState({
+        ssoConfigurations: ssoConfigurations.filter(({
+          id
+        }) => id !== ssoConfigId)
+      });
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const saveSSODomain = async payload => {
+    const {
+        callback,
+        ssoConfigId
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded3);
+    const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_DOMAIN, callback, async () => {
+      const domain = await api.auth.createSSODomain(ssoConfigId, body);
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => {
+        if (ssoConfig.id === ssoConfigId) {
+          return _extends({}, ssoConfig, {
+            domains: [...ssoConfig.domains, domain]
+          });
+        }
+        return ssoConfig;
+      });
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(domain);
+    });
+  };
+  const deleteSSODomain = async payload => {
+    const {
+      ssoConfigId,
+      domainId,
+      callback
+    } = payload;
+    const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+    await __ssoTryCatch(SSOStateKeys.DELETE_SSO_DOMAIN, callback, async () => {
+      await api.auth.deleteSSODomain(ssoConfigId, domainId);
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => {
+        if (ssoConfig.id === ssoConfigId) {
+          return _extends({}, ssoConfig, {
+            domains: ssoConfig.domains.filter(({
+              id
+            }) => id !== domainId)
+          });
+        }
+        return ssoConfig;
+      });
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const validateSSODomainV2 = async payload => {
+    const {
+      callback,
+      domainId,
+      ssoConfigId
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.VALIDATE_SSO_DOMAIN, callback, async () => {
+      const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+      await api.auth.validateSSODomainV2(ssoConfigId, domainId);
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => {
+        if (ssoConfig.id === ssoConfigId) {
+          return _extends({}, ssoConfig, {
+            domains: ssoConfig.domains.map(ssoDomain => ssoDomain.id === domainId ? _extends({}, ssoDomain, {
+              validated: true
+            }) : ssoDomain)
+          });
+        }
+        return ssoConfig;
+      });
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const setSSODefaultRoles = async payload => {
+    const {
+      callback,
+      ssoConfigId,
+      roleIds
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.UPDATE_SSO_DEFAULT_ROLES, callback, async () => {
+      const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+      await api.auth.setSSODefaultRoles(ssoConfigId, {
+        roleIds
+      });
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => {
+        if (ssoConfig.id === ssoConfigId) {
+          return _extends({}, ssoConfig, {
+            roleIds
+          });
+        }
+        return ssoConfig;
+      });
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const setSSOGroups = async payload => {
+    const {
+      groupsToAdd,
+      groupsToDelete,
+      ssoConfigId,
+      callback
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_GROUPS, callback, async () => {
+      const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+      await Promise.all(groupsToDelete.map(groupId => api.auth.deleteSSOGroup(ssoConfigId, groupId)));
+      await Promise.all(groupsToAdd.map(group => api.auth.createSSOGroup(ssoConfigId, group)));
+      const groups = await api.auth.getSSOGroups(ssoConfigId);
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => {
+        if (ssoConfig.id === ssoConfigId) {
+          return _extends({}, ssoConfig, {
+            groups
+          });
+        }
+        return ssoConfig;
+      });
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const updateSSOGroups = async payload => {
+    const {
+      ssoConfigId,
+      changedGroups,
+      callback
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_GROUPS, callback, async () => {
+      await Promise.all(changedGroups.map(group => api.auth.updateSSOGroup(ssoConfigId, group)));
+      callback == null ? void 0 : callback(true);
+    });
+  };
+  const saveSSOConfigurationByMetadata = async payload => {
+    const {
+      configFile,
+      callback
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_CONFIGURATION_BY_METADATA, callback, async () => {
+      const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+      const metadata = await readFileAsText(configFile);
+      const newSsoConfiguration = await api.auth.createSSOConfigurationByMetadata({
+        metadata
+      });
+      actions.setSSOState({
+        ssoConfigurations: [...ssoConfigurations, newSsoConfiguration]
+      });
+      callback == null ? void 0 : callback(newSsoConfiguration);
+    });
+  };
+  const updateSSOConfigurationByMetadata = async payload => {
+    const {
+      callback,
+      ssoConfigId,
+      configFile
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.UPDATE_SSO_CONFIGURATION_BY_METADATA, callback, async () => {
+      const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+      const metadata = await readFileAsText(configFile);
+      const newSsoConfiguration = await api.auth.updateSSOConfigurationByMetadata(ssoConfigId, {
+        metadata
+      });
+      const newSsoConfigurations = ssoConfigurations.map(ssoConfig => ssoConfig.id === ssoConfigId ? newSsoConfiguration : ssoConfig);
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(newSsoConfiguration);
+    });
+  };
+  const saveSSOConfigurationByData = async payload => {
+    const {
+        callback,
+        ssoConfigId
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded4);
+    const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_CONFIGURATION, callback, async () => {
+      let newSsoConfiguration;
+      let newSsoConfigurations;
+      if (ssoConfigId) {
+        newSsoConfiguration = await api.auth.updateSSOConfiguration(ssoConfigId, body);
+        newSsoConfigurations = ssoConfigurations.map(ssoConfig => ssoConfig.id === ssoConfigId ? newSsoConfiguration : ssoConfig);
+      } else {
+        newSsoConfiguration = await api.auth.createSSOConfiguration(body);
+        newSsoConfigurations = [newSsoConfiguration, ...ssoConfigurations];
+      }
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(newSsoConfiguration);
+    });
+  };
+  const saveSSOConfigurationByUrl = async payload => {
+    const {
+      metadataUrl,
+      configMetadata,
+      ssoConfigId,
+      callback
+    } = payload;
+    await __ssoTryCatch(SSOStateKeys.SAVE_SSO_CONFIGURATION_BY_METADATA, callback, async () => {
+      const ssoConfigurations = store.auth.ssoState.ssoConfigurations;
+      const body = {
+        url: metadataUrl,
+        configMetadata
+      };
+      let newSsoConfiguration;
+      let newSsoConfigurations;
+      if (ssoConfigId) {
+        newSsoConfiguration = await api.auth.updateSSOConfigurationByMetadataUrl(ssoConfigId, body);
+        newSsoConfigurations = ssoConfigurations.map(ssoConfig => ssoConfig.id === ssoConfigId ? newSsoConfiguration : ssoConfig);
+      } else {
+        newSsoConfiguration = await api.auth.createSSOConfigurationByMetadataUrl(body);
+        newSsoConfigurations = [newSsoConfiguration, ...ssoConfigurations];
+      }
+      actions.setSSOState({
+        ssoConfigurations: newSsoConfigurations
+      });
+      callback == null ? void 0 : callback(newSsoConfiguration);
+    });
+  };
+  return {
+    loadSSOConfigurationsV2,
+    saveSSOConfigurationV2,
+    updateSSOConfiguration,
+    deleteSSOConfiguration,
+    saveSSODomain,
+    deleteSSODomain,
+    validateSSODomainV2,
+    setSSOGroups,
+    updateSSOGroups,
+    setSSODefaultRoles,
+    saveSSOConfigurationByMetadata,
+    updateSSOConfigurationByMetadata,
+    saveSSOConfigurationByUrl,
+    saveSSOConfigurationByData
+  };
+});

package/auth/SSOState/actions/index.d.ts

@@ -0,0 +1,75 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    loadSSOConfigurationsV2: () => Promise<void>;
+    saveSSOConfigurationV2: (payload: import("../../../interfaces").WithCallback<Partial<Pick<import("@frontegg/rest-api").ISSOConfiguration, "roleIds" | "type" | "groups" | "generatedVerification" | "enabled" | "ssoEndpoint" | "publicCertificate" | "signRequest" | "acsUrl" | "spEntityId" | "oidcClientId" | "oidcSecret" | "skipEmailDomainValidation">>, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    updateSSOConfiguration: (payload: import("../../../interfaces").WithCallback<Partial<Pick<import("@frontegg/rest-api").ISSOConfiguration, "roleIds" | "type" | "groups" | "generatedVerification" | "enabled" | "ssoEndpoint" | "publicCertificate" | "signRequest" | "acsUrl" | "spEntityId" | "oidcClientId" | "oidcSecret" | "skipEmailDomainValidation">> & {
+        ssoConfigId: string;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    deleteSSOConfiguration: (payload: import("../../../interfaces").WithCallback<{
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    saveSSODomain: (payload: import("../../../interfaces").WithCallback<import("@frontegg/rest-api").ICreateSSODomain & {
+        ssoConfigId: string;
+    }, import("@frontegg/rest-api").ISSODomain>) => Promise<void>;
+    deleteSSODomain: (payload: import("../../../interfaces").WithCallback<{
+        domainId: string;
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    validateSSODomainV2: (payload: import("../../../interfaces").WithCallback<{
+        domainId: string;
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    setSSOGroups: (payload: import("../../../interfaces").WithCallback<{
+        ssoConfigId: string;
+        groupsToAdd: import("@frontegg/rest-api").ICreateSamlGroup[];
+        groupsToDelete: string[];
+    }, boolean>) => Promise<void>;
+    updateSSOGroups: (payload: import("../../../interfaces").WithCallback<{
+        ssoConfigId: string;
+        changedGroups: import("@frontegg/rest-api").IUpdateSamlGroup[];
+    }, boolean>) => Promise<void>;
+    setSSODefaultRoles: (payload: import("../../../interfaces").WithCallback<{
+        roleIds: string[];
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    saveSSOConfigurationByMetadata: (payload: import("../../../interfaces").WithCallback<{
+        configFile: File;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    updateSSOConfigurationByMetadata: (payload: import("../../../interfaces").WithCallback<{
+        configFile: File;
+        ssoConfigId: string;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    saveSSOConfigurationByUrl: (payload: import("../../../interfaces").WithCallback<{
+        ssoConfigId?: string | undefined;
+        configMetadata?: Record<string, string> | undefined;
+        metadataUrl: string;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    saveSSOConfigurationByData: (payload: import("../../../interfaces").WithCallback<Partial<import("@frontegg/rest-api").ISSOConfiguration> & {
+        ssoConfigId?: string | undefined;
+        configMetadata?: Record<string, string> | undefined;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    setSSOState: (state: Partial<import("../interfaces").SSOState>) => void;
+    resetSSOState: () => void;
+    setSSOLoader: (payload: import("../interfaces").SSOStateIndicator) => void;
+    setSSOError: (payload: import("../interfaces").SSOStateIndicator) => void;
+    loadSSOConfigurations: () => Promise<void>;
+    saveSSOConfigurations: (payload: import("../../../interfaces").WithCallback<Partial<Pick<import("@frontegg/rest-api").ISamlConfiguration, "type" | "enabled" | "domain" | "ssoEndpoint" | "publicCertificate" | "signRequest" | "acsUrl" | "spEntityId" | "isSamlActive" | "oidcClientId" | "oidcSecret"> & {
+        samlVendor: import("../interfaces").SamlVendors;
+    }>, boolean>) => Promise<void>;
+    saveSSOConfigurationsFile: (configFile: File[]) => Promise<void>;
+    saveSSOConfigurationsFileWithCallback: (payload: import("../../../interfaces").WithCallback<{
+        configFile: File;
+    }, boolean>) => Promise<void>;
+    validateSSODomain: (payload?: import("../../../interfaces").WithCallback<object, boolean> | undefined) => Promise<void>;
+    loadSSOAuthorizationRoles: () => Promise<void>;
+    updateSSOAuthorizationRoles: (payload: import("../../../interfaces").WithCallback<{
+        authorizationRoles: string[];
+        groups?: import("@frontegg/rest-api").ISamlRolesGroup[] | undefined;
+    }, boolean>) => Promise<void>;
+    deleteSamlGroup: (payload: import("../../../interfaces").WithCallback<{
+        id: string;
+    }, boolean>) => Promise<void>;
+    createSamlGroup: (payload: import("../../../interfaces").WithCallback<import("@frontegg/rest-api").ICreateSamlGroup, boolean>) => Promise<void>;
+    oidcPostlogin: (payload: import("@frontegg/rest-api").IOidcPostLogin) => Promise<void>;
+};
+export default _default;

package/auth/SSOState/actions/index.js

@@ -0,0 +1,6 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import ssoActionsV1 from './actions.v1';
+import ssoActionsV2 from './actions.v2';
+export default ((store, api, sharedActions) => {
+  return _extends({}, ssoActionsV1(store, api, sharedActions), ssoActionsV2(store, api, sharedActions));
+});