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

package/node/auth/LoginState/actions/mfaRequiredState.actions.js

@@ -0,0 +1,71 @@
+"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 _interfaces = require("../interfaces");
+var _helpers2 = require("../../../helpers");
+var _state = require("../../MfaState/state");
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+  const getMfaRequiredState = async user => {
+    let step = _interfaces.LoginStep.loginWithTwoFactor;
+    const mfaState = (0, _helpers2.deepClone)(_state.initialState);
+    const loginState = store.auth.loginState;
+    const {
+      isAllowedToRemember,
+      mfaDeviceExpiration
+    } = await api.auth.checkIfAllowToRememberMfaDevice(user.mfaToken);
+    const isEnrolled = !(user.hasOwnProperty('mfaEnrolled') && !user.mfaEnrolled);
+    if (isEnrolled) {
+      Object.assign(mfaState, {
+        mfaDevices: user.mfaDevices,
+        step: (0, _helpers.getMfaStepForEnrolledUsers)(user.mfaDevices)
+      });
+    } else {
+      Object.assign(mfaState, {
+        step: (0, _helpers.getMfaStepForNotEnrolledUsers)(user.mfaStrategies),
+        qrCode: user.qrCode,
+        recoveryCode: user.recoveryCode,
+        loading: false,
+        mfaToken: user.mfaToken,
+        mfaStrategies: user.mfaStrategies
+      });
+      step = _interfaces.LoginStep.forceTwoFactor;
+    }
+    let quickLoginState = {};
+    const quickLoginToRegister = localStorage.getItem('register-quick-login');
+    if (quickLoginToRegister) {
+      quickLoginState = {
+        quickLoginToRegister,
+        flow: _interfaces.LoginFlow.RegisterQuickLogin
+      };
+    }
+    return {
+      user: undefined,
+      isAuthenticated: false,
+      mfaState,
+      loginState: (0, _extends2.default)({}, loginState, quickLoginState, {
+        mfaToken: user.mfaToken,
+        mfaRequired: user.mfaRequired,
+        loading: false,
+        error: undefined,
+        step,
+        tenantsLoading: true,
+        email: user.userEmail,
+        tenants: [],
+        allowRememberMfaDevice: isAllowedToRemember,
+        mfaDeviceExpiration,
+        isBreachedPassword: user.isBreachedPassword
+      })
+    };
+  };
+  return {
+    getMfaRequiredState
+  };
+};
+exports.default = _default;

package/node/auth/LoginState/actions/mfaWithAuthenticator.actions.js

@@ -0,0 +1,145 @@
+"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 _interfaces = require("../interfaces");
+var _helpers = require("../../../helpers");
+const _excluded = ["callback"];
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * @param tenants
+   * @param isAuthenticated
+   * @param isStepUp
+   * @returns additional update object for the afterAuthenticationStateUpdate saga as part of MFA auth with authenticator app
+   * @private
+   */
+  async function __buildPostAuthStateUpdate(tenants, isAuthenticated, isStepUp) {
+    const loginState = store.auth.loginState;
+    let additionalUpdate = {};
+    if (!isStepUp) {
+      const step = loginState.flow === _interfaces.LoginFlow.Login ? _interfaces.LoginStep.success : loginState.step;
+      additionalUpdate = {
+        loginState: {
+          flow: loginState.flow,
+          quickLoginToRegister: loginState.quickLoginToRegister,
+          loading: false,
+          step,
+          error: undefined,
+          tenants
+        }
+      };
+    }
+    return (0, _extends2.default)({}, additionalUpdate, {
+      isAuthenticated
+    });
+  }
+
+  /**
+   * Handle after MFA authentication with authenticator app for login
+   * @private
+   */
+  async function __postLoginMfaAuthenticator(isAuthenticated, callback) {
+    const loginState = store.auth.loginState;
+    if (loginState.flow !== _interfaces.LoginFlow.Login) return;
+    const [securityCenterLoginFlows] = await actions.getFeatureFlags(['security-center-show-login-flows']);
+    if (securityCenterLoginFlows && loginState.isBreachedPassword && !isAuthenticated) {
+      actions.setLoginState({
+        step: _interfaces.LoginStep.breachedPassword,
+        loading: false
+      });
+    } else {
+      const shouldShowPrompt = await actions.__shouldShowPromptPasskeys();
+      if (shouldShowPrompt) {
+        actions.setLoginState({
+          step: _interfaces.LoginStep.promptPasskeys,
+          loading: false
+        });
+      } else {
+        await actions.afterAuthNavigation();
+      }
+    }
+    callback == null ? void 0 : callback(true);
+  }
+
+  /**
+   * Handle after MFA authentication with authenticator app for step up
+   * @private
+   */
+  async function __postStepUpMfaAuthenticator(callback) {
+    await actions.afterStepUpAuthNavigation();
+    callback == null ? void 0 : callback(true);
+  }
+
+  /**
+   * Utility function to handle MFA authentication with authenticator app
+   * @param payload MFA with authenticator action payload
+   * @param setLoadingAction set loading action
+   * @param isStepUp true if this is a step-up authentication
+   * @returns
+   */
+  const mfaWithAuthenticator = async (_ref, setLoadingAction, isStepUp) => {
+    let {
+        callback
+      } = _ref,
+      loginWithMfaPayload = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+    setLoadingAction({
+      loading: true,
+      error: undefined
+    });
+    try {
+      const {
+        user,
+        tenants = [],
+        activeTenant
+      } = await api.auth.loginWithMfaV2(loginWithMfaPayload);
+      const isAuthenticated = !!user.accessToken;
+      const additionalUpdate = await __buildPostAuthStateUpdate(tenants, isAuthenticated, isStepUp);
+      await actions.__afterAuthenticationStateUpdate({
+        user,
+        tenants,
+        activeTenant
+      }, additionalUpdate);
+      if (user.id) {
+        localStorage.setItem('userId', user.id);
+      }
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      if (isStepUp) {
+        return await __postStepUpMfaAuthenticator(callback);
+      }
+      return await __postLoginMfaAuthenticator(isAuthenticated, callback);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    }
+  };
+
+  /**
+   * Login with MFA with authenticator app - external saga
+   * @param payload.mfaToken
+   * @param payload.mfaDevices
+   * @param payload.rememberDevice
+   * @param payload.invitationToken
+   * @param payload.callback - The callback function to be called after the request is done
+   */
+  const loginWithMfa = async payload => {
+    return await mfaWithAuthenticator(payload, actions.setLoginState, false);
+  };
+  return {
+    mfaWithAuthenticator,
+    loginWithMfa
+  };
+};
+exports.default = _default;

package/node/auth/LoginState/actions/mfaWithEmailCode.actions.js

@@ -0,0 +1,109 @@
+"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 _interfaces = require("../../MfaState/interfaces");
+var _helpers = require("../../../helpers");
+const _excluded = ["callback"],
+  _excluded2 = ["callback"];
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+  /**
+   * Shared logic for MFA Email code pre-verify step
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.mfaToken
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   */
+  const preVerifyMFAEmailCode = async (_ref, setLoadingAction) => {
+    var _setLoadingAction;
+    let {
+        callback
+      } = _ref,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+    setLoadingAction = (_setLoadingAction = setLoadingAction) != null ? _setLoadingAction : actions.setLoginState;
+    setLoadingAction({
+      loading: true,
+      error: undefined
+    });
+    try {
+      const data = await api.auth.preVerifyMFAEmailCode(payload);
+      actions.setMfaState({
+        otcToken: data.otcToken,
+        step: _interfaces.MFAStep.emailVerifyCode
+      });
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Shared logic for MFA Email code verify step
+   * @param payload.otcToken
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.code 6 digits code input by the user
+   */
+  const verifyMFAEmailCode = async (_ref2, setLoadingAction) => {
+    var _setLoadingAction2;
+    let {
+        callback
+      } = _ref2,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_ref2, _excluded2);
+    setLoadingAction = (_setLoadingAction2 = setLoadingAction) != null ? _setLoadingAction2 : actions.setLoginState;
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      const data = await api.auth.verifyMFAEmailCodeV2(payload);
+      await actions.handleVerifyMFAResponse(data);
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Pre verify step for MFA Email login
+   * @param payload.mfaToken
+   * @param payload.callback callback function to be called after the verification is done
+   */
+  const preVerifyMFAEmailCodeForLogin = async payload => {
+    return await preVerifyMFAEmailCode(payload, actions.setLoginState);
+  };
+
+  /**
+   * Verify step for MFA Email login
+   * @param payload.otcToken
+   * @param payload.callback callback function to be called after the verification is done with true for success, o.w false
+   * @param payload.code 6 digits code input by the user
+   */
+  const verifyMFAEmailCodeForLogin = async payload => {
+    return await verifyMFAEmailCode(payload, actions.setLoginState);
+  };
+  return {
+    preVerifyMFAEmailCode,
+    verifyMFAEmailCode,
+    preVerifyMFAEmailCodeForLogin,
+    verifyMFAEmailCodeForLogin
+  };
+};
+exports.default = _default;

package/node/auth/LoginState/actions/mfaWithSMS.actions.js

@@ -0,0 +1,116 @@
+"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 _interfaces = require("../../MfaState/interfaces");
+var _helpers = require("../../../helpers");
+const _excluded = ["callback", "deviceId"],
+  _excluded2 = ["callback", "deviceId"];
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Shared logic for MFA SMS pre-verify step
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   */
+  const preVerifyMFASMS = async (_ref, setLoadingAction) => {
+    let {
+        callback,
+        deviceId
+      } = _ref,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+    setLoadingAction({
+      loading: false,
+      error: undefined
+    });
+    try {
+      const data = await api.auth.preVerifyMFASMSForLogin(deviceId, payload);
+      actions.setMfaState({
+        otcToken: data.otcToken,
+        step: _interfaces.MFAStep.smsVerifyCode,
+        phoneNumber: data.phoneNumber
+      });
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Shared logic for MFA SMS verify step
+   * @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
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   * @param isStepUp true when it's step up flow
+   */
+  const verifyMFASMS = async (_ref2, setLoadingAction, isStepUp = false) => {
+    let {
+        callback,
+        deviceId
+      } = _ref2,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_ref2, _excluded2);
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      const data = await api.auth.verifyMFASMSForLoginV2(deviceId, payload);
+      await actions.handleVerifyMFAResponse(data, isStepUp);
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Pre verify step for MFA SMS login
+   * @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 preVerifyMFASMSForLogin = async payload => {
+    return await preVerifyMFASMS(payload, actions.setLoginState);
+  };
+
+  /**
+   * Verify step for MFA SMS login
+   * @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 verifyMFASMSForLogin = async payload => {
+    return await verifyMFASMS(payload, actions.setLoginState, false);
+  };
+  return {
+    preVerifyMFASMS,
+    verifyMFASMS,
+    preVerifyMFASMSForLogin,
+    verifyMFASMSForLogin
+  };
+};
+exports.default = _default;

package/node/auth/LoginState/actions/mfaWithWebAuthn.actions.js

@@ -0,0 +1,127 @@
+"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");
+const _excluded = ["callback", "deviceId"],
+  _excluded2 = ["callback", "deviceId"];
+var _default = (store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * Shared logic for MFA Webauthn pre-verify step
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   */
+  const preVerifyMFAWebAuthn = async (_ref, setLoadingAction) => {
+    let {
+        callback,
+        deviceId
+      } = _ref,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      var _data$options$allowCr;
+      const data = await api.auth.preVerifyMFAWebAuthnForLogin(deviceId, payload);
+      const options = (0, _extends2.default)({}, data.options, {
+        challenge: (0, _helpers.base64urlDecode)(data.options.challenge),
+        allowCredentials: (_data$options$allowCr = data.options.allowCredentials) == null ? void 0 : _data$options$allowCr.map(credentials => (0, _extends2.default)({}, credentials, {
+          id: (0, _helpers.base64urlDecode)(credentials.id)
+        }))
+      });
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback({
+        options,
+        webauthnToken: data.webauthnToken
+      });
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Shared logic for MFA Webauthn verify step
+   * @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
+   * @param setLoadingAction loading setter action (e.g. actions.setLoginState)
+   * @param isStepUp true when it's step up flow
+   */
+  const verifyMFAWebAuthn = async (_ref2, setLoadingAction, isStepUp) => {
+    let {
+        callback,
+        deviceId
+      } = _ref2,
+      payload = (0, _objectWithoutPropertiesLoose2.default)(_ref2, _excluded2);
+    setLoadingAction({
+      loading: true
+    });
+    try {
+      const publicKey = (0, _helpers.publicKeyCredentialToJSON)(payload.publicKey);
+      const data = await api.auth.verifyMFAWebAuthnForLoginV2(deviceId, (0, _extends2.default)({}, payload, {
+        options: publicKey
+      }));
+      await actions.handleVerifyMFAResponse(data, isStepUp);
+      setLoadingAction({
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setLoadingAction({
+        loading: false,
+        error: (0, _helpers.errorHandler)(e)
+      });
+      callback == null ? void 0 : callback(null);
+    }
+  };
+
+  /**
+   * Pre verify step for MFA Webauthn login
+   * @param payload.callback callback function to be called after the verification is done
+   * @param payload.deviceId
+   * @param payload.mfaToken
+   */
+  const preVerifyMFAWebAuthnForLogin = async payload => {
+    return await preVerifyMFAWebAuthn(payload, actions.setLoginState);
+  };
+
+  /**
+   * Verify step for MFA Webauthn login
+   * @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 verifyMFAWebAuthnForLogin = async payload => {
+    return await verifyMFAWebAuthn(payload, actions.setLoginState, false);
+  };
+  return {
+    preVerifyMFAWebAuthn,
+    verifyMFAWebAuthn,
+    preVerifyMFAWebAuthnForLogin,
+    verifyMFAWebAuthnForLogin
+  };
+};
+exports.default = _default;

package/node/auth/LoginState/consts.js

@@ -7,11 +7,10 @@ exports.defaultFronteggRoutes = exports.authStrategyLoginStepMap = void 0;
 var _restApi = require("@frontegg/rest-api");
 var _interfaces = require("./interfaces");
 /**
-  @notice these file is used inside next js middleware 
-  middleware file in next js runs inside edge runtime
-  using redux-toolkit is not allowed inside edge runtime and breaks the build because it is using eval
-  please don't import from redux or from other files that import from redux 
-*/
+ * @notice these file is used inside Next.js middleware  file in Next.js runs inside edge runtime
+ * using redux-toolkit is not allowed inside edge runtime and breaks the build because it is using eval
+ * please don't import from redux or from other files that import from redux
+ */
 
 const authStrategyLoginStepMap = {
   [_restApi.AuthStrategyEnum.Code]: _interfaces.LoginStep.loginWithOtc,
@@ -25,6 +24,7 @@ exports.authStrategyLoginStepMap = authStrategyLoginStepMap;
 const defaultFronteggRoutes = {
   authenticatedUrl: '/',
   loginUrl: '/account/login',
+  stepUpUrl: '/account/step-up',
   logoutUrl: '/account/logout',
   activateUrl: '/account/activate',
   impersonationUrl: '/account/impersonate',
@@ -37,6 +37,7 @@ const defaultFronteggRoutes = {
   oidcRedirectUrl: '/account/oidc/callback',
   samlCallbackUrl: '/account/saml/callback',
   magicLinkCallbackUrl: '/account/login/magic-link',
-  hostedLoginRedirectUrl: '/oauth/callback'
+  hostedLoginRedirectUrl: '/oauth/callback',
+  openAppUrl: '/account/redirect'
 };
 exports.defaultFronteggRoutes = defaultFronteggRoutes;