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

package/node/auth/SocialLoginState/actions.js

@@ -0,0 +1,171 @@
+"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 _state = require("./state");
+var _interfaces = require("../interfaces");
+var _gtm = require("../../helpers/gtm");
+const _excluded = ["authorizationUrl"],
+  _excluded2 = ["events", "url"];
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * @private
+   */
+  const __getSocialLoginsConfigurationsV2 = async () => {
+    const isAuthenticated = store.auth.isAuthenticated;
+    let socialLoginsConfigV2;
+    if (isAuthenticated) {
+      socialLoginsConfigV2 = await api.auth.getSocialLoginProvidersV2ForAuthenticatedUser();
+    } else {
+      socialLoginsConfigV2 = await api.auth.getSocialLoginProvidersV2();
+    }
+    return socialLoginsConfigV2;
+  };
+  const setSocialLoginsState = state => {
+    Object.assign(store.auth.socialLoginState, state);
+  };
+  const resetSocialLoginsState = () => {
+    store.auth.socialLoginState = (0, _helpers.deepClone)(_state.initialState);
+  };
+  const setSocialLoginError = payload => {
+    setSocialLoginsState({
+      error: payload.error,
+      loading: false,
+      firstLoad: false
+    });
+  };
+  const loadSocialLoginsConfiguration = async () => {
+    try {
+      setSocialLoginsState({
+        loading: true
+      });
+      const socialLoginsConfig = await api.auth.getSocialLoginProviders();
+      setSocialLoginsState({
+        socialLoginsConfig,
+        loading: false,
+        firstLoad: false
+      });
+    } catch (e) {
+      setSocialLoginsState({
+        error: (0, _helpers.errorHandler)(e),
+        loading: false,
+        firstLoad: false
+      });
+    }
+  };
+  const loadSocialLoginsConfigurationV2 = async payload => {
+    try {
+      var _payload$callback;
+      const context = store.root.context;
+      setSocialLoginsState({
+        loading: true
+      });
+      const socialLoginsConfigV2 = await __getSocialLoginsConfigurationsV2();
+      const {
+        providers: customSocialLoginsConfig
+      } = await api.auth.getCustomSocialLoginProvidersV1();
+      const socialLoginsConfigWithFullUrl = socialLoginsConfigV2.map(_ref => {
+        let {
+            authorizationUrl
+          } = _ref,
+          config = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+        const baseUrl = api.fetch.getBaseUrl(context, authorizationUrl != null ? authorizationUrl : '');
+        return (0, _extends2.default)({}, config, {
+          authorizationUrl: authorizationUrl ? `${baseUrl}${authorizationUrl}` : null
+        });
+      });
+      const newState = {
+        socialLoginsConfigV2: socialLoginsConfigWithFullUrl,
+        customSocialLoginsConfig,
+        loading: false,
+        firstLoad: false
+      };
+      setSocialLoginsState(newState);
+      payload == null ? void 0 : (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, newState);
+    } catch (e) {
+      var _payload$callback2;
+      payload == null ? void 0 : (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, null, e);
+      setSocialLoginsState({
+        error: (0, _helpers.errorHandler)(e),
+        loading: false,
+        firstLoad: false
+      });
+    }
+  };
+  const loginViaSocialLogin = async _payload => {
+    const {
+        events,
+        url
+      } = _payload,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_payload, _excluded2);
+    try {
+      setSocialLoginsState({
+        loading: true
+      });
+      const {
+        email,
+        isNewUser,
+        userId,
+        tenantId,
+        name
+      } = await api.auth.loginViaSocialLogin(payload);
+      if (isNewUser) {
+        var _events$signUpComplet, _events$userVerified;
+        const basePayload = {
+          email,
+          url,
+          createdAt: new Date(),
+          id: userId,
+          tenantId
+        };
+        const signUpCompletePayload = (0, _extends2.default)({}, basePayload, {
+          socialProvider: payload.provider,
+          authenticationType: _interfaces.AuthenticationTypes.SOCIAL_LOGIN
+        });
+        events == null ? void 0 : (_events$signUpComplet = events.signUpComplete) == null ? void 0 : _events$signUpComplet.call(events, signUpCompletePayload);
+        (0, _gtm.reportGTMEvent)(_gtm.GTMEventAction.SIGNUP_COMPLETED, signUpCompletePayload);
+        const userVerifiedPayload = (0, _extends2.default)({}, basePayload, {
+          origin: _interfaces.UserVeirifedOriginTypes.SOCIAL_LOGIN,
+          name
+        });
+        events == null ? void 0 : (_events$userVerified = events.userVerified) == null ? void 0 : _events$userVerified.call(events, userVerifiedPayload);
+        (0, _gtm.reportGTMEvent)(_gtm.GTMEventAction.USER_VERIFIED, userVerifiedPayload);
+      }
+      if (userId) {
+        localStorage.setItem('userId', userId);
+      }
+      actions.setLoginState({
+        email,
+        isNewUser
+      });
+      actions.refreshTokenForSocialLogins();
+      localStorage.removeItem('register-quick-login');
+      setSocialLoginsState({
+        loading: false
+      });
+    } catch (e) {
+      setSocialLoginsState({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e, 'Failed to authenticate'),
+        firstLoad: false
+      });
+    }
+  };
+  return {
+    setSocialLoginsState,
+    resetSocialLoginsState,
+    setSocialLoginError,
+    loadSocialLoginsConfiguration,
+    loadSocialLoginsConfigurationV2,
+    loginViaSocialLogin
+  };
+};
+exports.default = _default;

package/node/auth/SocialLoginState/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "buildSocialLoginActions", {
+  enumerable: true,
+  get: function () {
+    return _actions.default;
+  }
+});
+Object.defineProperty(exports, "createSocialLoginState", {
+  enumerable: true,
+  get: function () {
+    return _state.default;
+  }
+});
+var _state = _interopRequireDefault(require("./state"));
+var _actions = _interopRequireDefault(require("./actions"));

package/node/auth/SocialLoginState/state.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialState = exports.default = void 0;
+var _proxy = require("../../toolkit/proxy");
+const initialState = {
+  firstLoad: true,
+  loading: false,
+  error: ''
+};
+exports.initialState = initialState;
+var _default = overrideState => (0, _proxy.createProxy)(initialState, overrideState);
+exports.default = _default;

package/node/auth/StepUpState/actions/generateStepUpSession.actions.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _restApi = require("@frontegg/rest-api");
+var _helpers = require("../../LoginState/helpers");
+var _interfaces = require("../../MfaState/interfaces");
+var _consts = require("../consts");
+/**
+ * Error returned from the BE when the user is not enrolled to MFA and logged in with email magic code/link
+ */
+const MFA_IS_NOT_ENROLLED_ERROR = 'MFA is not enrolled';
+
+/**
+ * @param error API error
+ * @returns true when the error is MFA is not enrolled error
+ */
+const isMfaIsNotEnrolledError = error => (error == null ? void 0 : error['message']) === MFA_IS_NOT_ENROLLED_ERROR;
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Handle an edge case when the user should NOT step up, so the response including the generated stepped-up jwt
+   * Relevant for scenarios like login with magic code, no other mfa enrolled, allowed to skip mfa and max age is valid
+   * @param generateResponse
+   * @private
+   */
+  const __handleNoNeedToStepUpFlow = async generateResponse => {
+    await actions.__afterAuthenticationStateUpdate(generateResponse);
+    await actions.afterStepUpAuthNavigation();
+  };
+
+  /**
+   * Handle the common scenario when the user should step up by the mfa token and devices returned from the generate req
+   * @param generateStepUpSessionResponse
+   * @private
+   */
+  const __handleNeedToStepUpFlow = async ({
+    mfaToken,
+    mfaDevices
+  }) => {
+    actions.setStepUpState({
+      mfaDevices,
+      mfaToken
+    });
+
+    // to handle scenarios when sms, email or authenticator are the only options - show immediately the enrolled one
+    const step = await (0, _helpers.getMfaStepForEnrolledUsers)(mfaDevices);
+    actions.setMfaState({
+      step
+    });
+  };
+
+  /**
+   * Handle step up generation request error
+   * @param error
+   * @private
+   */
+  const __handleStepUpError = async error => {
+    if (isMfaIsNotEnrolledError(error)) {
+      actions.setMfaState({
+        step: _interfaces.MFAStep.noMFAEnrolledStepUp
+      });
+      return;
+    }
+    window.localStorage.setItem(_consts.SHOULD_STEP_UP_KEY, 'true');
+    const routes = store.auth.routes;
+    _restApi.ContextHolder.for(store.root.appName).onRedirectTo(routes.logoutUrl, {
+      preserveQueryParams: true
+    });
+  };
+
+  /**
+   * Generate step up session
+   * Logout on error and redirecting to the login page
+   * @param payload.maxAge - The max age of the session in seconds
+   * @param payload.callback - The callback function to be called after the request is done
+   */
+  const generateStepUpSession = async payload => {
+    const {
+      maxAge,
+      callback
+    } = payload;
+    actions.setStepUpState({
+      mfaDevices: undefined,
+      mfaToken: ''
+    });
+    try {
+      const response = await api.auth.generateStepupSession({
+        maxAge
+      });
+      if (response.hasOwnProperty('user')) {
+        // got stepped up jwt, no need to continue step up by a second factor
+        await __handleNoNeedToStepUpFlow(response);
+      } else {
+        // regular step up flow
+        await __handleNeedToStepUpFlow(response);
+      }
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      callback == null ? void 0 : callback(false);
+      await __handleStepUpError(e);
+    }
+  };
+  return {
+    generateStepUpSession
+  };
+};
+exports.default = _default;

package/node/auth/StepUpState/actions/index.js

@@ -0,0 +1,106 @@
+"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 _helpers = require("../../../helpers");
+var _state = require("../state");
+var _generateStepUpSession = _interopRequireDefault(require("./generateStepUpSession.actions"));
+var _stepUpHostedLogin = _interopRequireDefault(require("./stepUpHostedLogin.actions"));
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setStepUpState = state => {
+    Object.assign(store.auth.stepUpState, state);
+  };
+  const resetStepUpState = () => {
+    store.auth.stepUpState = (0, _helpers.deepClone)(_state.initialState);
+  };
+
+  /**
+   * Step up with authenticator app
+   * @param payload.callback - callback function to be called after the verification is done
+   * @param payload.mfaToken
+   * @param payload.value - 6 digits code input by the user
+   */
+  const stepUpWithAuthenticator = async payload => {
+    await actions.mfaWithAuthenticator(payload, actions.setStepUpState, true);
+  };
+
+  /**
+   * Pre verify step for MFA SMS step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFASMSForStepUp = async payload => {
+    await actions.preVerifyMFASMS(payload, actions.setStepUpState);
+  };
+
+  /**
+   * Verify step for MFA SMS step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.otcToken
+   * @param payload.code - 6 digits code input by the user
+   */
+  const verifyMFASMSForStepUp = async payload => {
+    await actions.verifyMFASMS(payload, actions.setStepUpState, true);
+  };
+
+  /**
+   * Pre verify step for MFA Webauthn step up
+   * @param payload.callback - callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFAWebAuthnForStepUp = async payload => {
+    await actions.preVerifyMFAWebAuthn(payload, actions.setStepUpState);
+  };
+
+  /**
+   * Verify step for MFA Webauthn step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.deviceId
+   * @param payload.webauthnToken
+   * @param payload.mfaToken
+   * @param payload.publicKey - public key object from browser navigator credentials
+   * @param payload.code - 6 digits code input by the user
+   */
+  const verifyMFAWebAuthnForStepUp = async payload => {
+    await actions.verifyMFAWebAuthn(payload, actions.setStepUpState, true);
+  };
+
+  /**
+   * Pre verify step for MFA Email code step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.mfaToken
+   */
+  const preVerifyMFAEmailCodeForStepUp = async payload => {
+    await actions.preVerifyMFAEmailCode(payload, actions.setStepUpState);
+  };
+
+  /**
+   * Verify step for MFA Email code step up
+   * @param payload.callback - callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.otcToken
+   * @param payload.code - 6 digits code input by the user
+   */
+  const verifyMFAEmailCodeForStepUp = async payload => {
+    await actions.verifyMFAEmailCode(payload, actions.setStepUpState);
+  };
+  return (0, _extends2.default)({
+    setStepUpState,
+    resetStepUpState,
+    stepUpWithAuthenticator,
+    preVerifyMFASMSForStepUp,
+    verifyMFASMSForStepUp,
+    preVerifyMFAWebAuthnForStepUp,
+    verifyMFAWebAuthnForStepUp,
+    preVerifyMFAEmailCodeForStepUp,
+    verifyMFAEmailCodeForStepUp
+  }, (0, _generateStepUpSession.default)(store, api, sharedActions), (0, _stepUpHostedLogin.default)(store, api, sharedActions));
+};
+exports.default = _default;

package/node/auth/StepUpState/actions/stepUpHostedLogin.actions.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _consts = require("../consts");
+var _helpers = require("../helpers");
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Step up for hosted login apps
+   * @param payload.maxAge
+   */
+  const stepUpHostedLogin = async payload => {
+    var _store$auth$tenantsSt, _store$auth$tenantsSt2;
+    const params = {
+      acr_values: _consts.ACR_VALUE
+    };
+    const {
+      maxAge
+    } = payload || {};
+    if (maxAge !== undefined) {
+      params['max_age'] = maxAge.toString();
+    }
+    const alias = (_store$auth$tenantsSt = store.auth.tenantsState) == null ? void 0 : (_store$auth$tenantsSt2 = _store$auth$tenantsSt.activeTenant) == null ? void 0 : _store$auth$tenantsSt2.alias;
+    if (alias) {
+      params['organization'] = alias;
+    }
+    (0, _helpers.setAfterAuthRedirectUrlForStepUp)();
+    window.localStorage.setItem(_consts.SHOULD_STEP_UP_KEY, 'true');
+    await actions.__requestHostedLoginAuthorize(params);
+  };
+  return {
+    stepUpHostedLogin
+  };
+};
+exports.default = _default;

package/node/auth/StepUpState/consts.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STEP_UP_MAX_AGE_PARAM_NAME = exports.SHOULD_STEP_UP_KEY = exports.AMR_MFA_VALUE = exports.AMR_ADDITIONAL_VALUE = exports.ACR_VALUE = void 0;
+/**
+ * The required ACR (Authorization Context Reference) value for the step up flow
+ */
+const ACR_VALUE = 'http://schemas.openid.net/pape/policies/2007/06/multi-factor';
+
+/**
+ * One of the required AMR (Authentication Methods References) values for the step up flow
+ */
+exports.ACR_VALUE = ACR_VALUE;
+const AMR_MFA_VALUE = 'mfa';
+
+/**
+ * One of the required AMR (Authentication Methods References) values should be from the array for the step up flow
+ */
+exports.AMR_MFA_VALUE = AMR_MFA_VALUE;
+const AMR_ADDITIONAL_VALUE = ['otp', 'sms', 'hwk'];
+
+/**
+ * SHOULD_STEP_UP_KEY local storage key
+ * Used for scenarios when we logout for re-login and then should redirect to step up page
+ */
+exports.AMR_ADDITIONAL_VALUE = AMR_ADDITIONAL_VALUE;
+const SHOULD_STEP_UP_KEY = 'SHOULD_STEP_UP';
+
+/**
+ * The name of the query param that contains the max age of the step up
+ */
+exports.SHOULD_STEP_UP_KEY = SHOULD_STEP_UP_KEY;
+const STEP_UP_MAX_AGE_PARAM_NAME = 'maxAge';
+exports.STEP_UP_MAX_AGE_PARAM_NAME = STEP_UP_MAX_AGE_PARAM_NAME;

package/node/auth/StepUpState/helpers.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.redirectByStepUpUrl = exports.isSteppedUp = void 0;
+exports.setAfterAuthRedirectUrlForStepUp = setAfterAuthRedirectUrlForStepUp;
+var _constants = require("../../constants");
+var _consts = require("./consts");
+/**
+ * @param options.amr
+ * @param options.acr
+ * @param options.auth_time - auth time of the user (last login time)
+ * @param options.maxAge - max age of step up
+ * @returns true when the user is stepped up, false otherwise
+ */
+const isSteppedUp = (user, {
+  maxAge
+} = {}) => {
+  if (!user) return false;
+  const {
+    amr = [],
+    acr = '',
+    auth_time
+  } = user;
+  if (maxAge && auth_time) {
+    // when user is logged in for a long time (more than maxAge, but jwt is still valid because it's not refreshed yet)
+    const isMaxAgeValid = Date.now() / 1000 - auth_time <= maxAge;
+    if (!isMaxAgeValid) return false;
+  }
+  const isACRValid = acr === _consts.ACR_VALUE;
+  const isAMRIncludesMFA = amr.indexOf(_consts.AMR_MFA_VALUE) !== -1;
+  const isAMRIncludesMethod = _consts.AMR_ADDITIONAL_VALUE.find(method => amr.indexOf(method)) !== undefined;
+  return isACRValid && isAMRIncludesMFA && isAMRIncludesMethod;
+};
+
+/**
+ * Set the url and query params in the local storage FRONTEGG_AFTER_AUTH_REDIRECT_URL value
+ */
+exports.isSteppedUp = isSteppedUp;
+function setAfterAuthRedirectUrlForStepUp() {
+  const encodedRedirectUrl = window.location.pathname + window.location.search;
+  window.localStorage.setItem(_constants.FRONTEGG_AFTER_AUTH_REDIRECT_URL, encodedRedirectUrl);
+}
+
+/**
+ * Redirects to the step up url with the max age param and set the redirect url in the local storage
+ * The redirect url will be used after the step up flow is done
+ * @param stepUpUrl - step up url to redirect to
+ * @param onRedirectTo - redirect to function
+ * @param maxAge - max age of step up
+ */
+const redirectByStepUpUrl = (stepUpUrl, onRedirectTo, maxAge) => {
+  setAfterAuthRedirectUrlForStepUp();
+  const searchParams = new URLSearchParams(window.location.search);
+  if (maxAge) {
+    searchParams.set(_consts.STEP_UP_MAX_AGE_PARAM_NAME, maxAge.toString());
+  }
+  onRedirectTo(`${stepUpUrl}${searchParams ? `?${searchParams}` : ''}`, {
+    refresh: false
+  });
+};
+exports.redirectByStepUpUrl = redirectByStepUpUrl;

package/node/auth/StepUpState/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "buildStepUpActions", {
+  enumerable: true,
+  get: function () {
+    return _actions.default;
+  }
+});
+Object.defineProperty(exports, "createStepUpState", {
+  enumerable: true,
+  get: function () {
+    return _state.default;
+  }
+});
+var _state = _interopRequireDefault(require("./state"));
+var _actions = _interopRequireDefault(require("./actions"));

package/node/auth/StepUpState/interfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/auth/StepUpState/state.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialState = exports.default = void 0;
+var _proxy = require("../../toolkit/proxy");
+const initialState = {
+  loading: false,
+  mfaDevices: undefined,
+  mfaToken: ''
+};
+exports.initialState = initialState;
+var _default = overrideState => (0, _proxy.createProxy)(initialState, overrideState);
+exports.default = _default;