@frontegg/redux-store 6.155.0-alpha.1 → 6.155.0-alpha.3

package/auth/LoginState/sagas/afterAuthNavigation.saga.js

@@ -0,0 +1,115 @@
+import { ContextHolder } from '@frontegg/rest-api';
+import { delay, put, select, call } from 'redux-saga/effects';
+import { loadCustomLoginRoutes } from '../../CustomLoginState/saga';
+import { actions } from '../../reducer';
+import { getPathAndSearchParamsFromUrl, getRedirectUrl } from '../utils';
+import { FRONTEGG_AFTER_AUTH_REDIRECT_URL } from '../../../constants';
+import { isSteppedUp } from '../../StepUpState';
+import { SHOULD_STEP_UP_KEY } from '../../StepUpState/consts';
+
+/**
+ * @param customLoginAuthenticatedUrl custom login authenticated url if exists
+ * @returns the authenticated url to redirect to after auth navigation
+ */
+function* getUrlForAfterAuthNavigation(customLoginAuthenticatedUrl) {
+  const {
+    routes,
+    includeQueryParam,
+    enforceRedirectToSameSite = false,
+    allowedRedirectOrigins = []
+  } = yield select(state => state.auth);
+  if (customLoginAuthenticatedUrl) {
+    return getPathAndSearchParamsFromUrl(customLoginAuthenticatedUrl);
+  }
+  const {
+    authenticatedUrl,
+    loginUrl,
+    logoutUrl,
+    socialLoginCallbackUrl,
+    activateUrl
+  } = routes;
+  let finalUrl = window.localStorage.getItem(FRONTEGG_AFTER_AUTH_REDIRECT_URL);
+  if (!finalUrl || [loginUrl, logoutUrl, socialLoginCallbackUrl, activateUrl].includes(finalUrl)) {
+    finalUrl = authenticatedUrl;
+  }
+  return getRedirectUrl({
+    authenticatedUrl: finalUrl,
+    includeQueryParam,
+    enforceRedirectToSameSite,
+    allowedRedirectOrigins
+  });
+}
+/**
+ * Utility to share after auth navigation flow between login and step up
+ * @param resetStateAction reset state action
+ * @param customLoginAuthenticatedUrl custom login authenticated url if exists
+ */
+export function* afterAuthNavigationUtil(resetStateAction, {
+  customLoginAuthenticatedUrl,
+  forceStepUpUrl
+} = {}) {
+  const onRedirectTo = ContextHolder.onRedirectTo;
+  let redirectUrl;
+  if (forceStepUpUrl) {
+    // scenario to get to here: invalid max age, try to step up -> logout, login with magic code/link -> redirect to step up page for email code as the second factor
+    // we don't want to remove the FRONTEGG_AFTER_AUTH_REDIRECT_URL when we are in the step up flow
+    redirectUrl = forceStepUpUrl;
+  } else {
+    var _window;
+    redirectUrl = yield call(getUrlForAfterAuthNavigation, customLoginAuthenticatedUrl);
+    (_window = window) == null ? void 0 : _window.localStorage.removeItem(FRONTEGG_AFTER_AUTH_REDIRECT_URL);
+  }
+  yield delay(200);
+  put(resetStateAction());
+  onRedirectTo(redirectUrl, {
+    refresh: redirectUrl.startsWith('http')
+  });
+}
+
+/**
+ * After auth navigation for login flow
+ * Handling also step up scenario when user silently logout to continue to step up
+ */
+export function* afterAuthNavigation() {
+  var _window2;
+  const {
+    routes: {
+      customLoginAuthenticatedUrl,
+      stepUpUrl
+    }
+  } = yield select(state => state.auth);
+
+  // login with magic code, try to step up, no other mfa, invalid max age, force_enroll -> logout, login with first factor, not-stepped up jwt -> navigate to step up
+  const shouldStepUp = (_window2 = window) == null ? void 0 : _window2.localStorage.getItem(SHOULD_STEP_UP_KEY);
+  const user = yield select(({
+    auth
+  }) => auth.user);
+  if (shouldStepUp) {
+    var _window3;
+    (_window3 = window) == null ? void 0 : _window3.localStorage.removeItem(SHOULD_STEP_UP_KEY);
+  }
+  if (stepUpUrl && shouldStepUp && !isSteppedUp(user)) {
+    yield call(afterAuthNavigationUtil, actions.resetLoginState, {
+      forceStepUpUrl: stepUpUrl
+    });
+    return;
+  }
+  let customLoginURL = customLoginAuthenticatedUrl;
+  if (!customLoginAuthenticatedUrl) {
+    yield call(loadCustomLoginRoutes);
+    customLoginURL = yield select(state => {
+      var _state$auth$routes;
+      return (_state$auth$routes = state.auth.routes) == null ? void 0 : _state$auth$routes.customLoginAuthenticatedUrl;
+    });
+  }
+  yield call(afterAuthNavigationUtil, actions.resetLoginState, {
+    customLoginAuthenticatedUrl: customLoginURL
+  });
+}
+
+/**
+ * After auth navigation for step up flow
+ */
+export function* afterStepUpAuthNavigation() {
+  yield call(afterAuthNavigationUtil, actions.resetStepUpState);
+}

package/auth/LoginState/sagas/handleVerifyMFAResponse.saga.d.ts

@@ -0,0 +1,54 @@
+import { ILoginResponseV3 } from '@frontegg/rest-api';
+import { AuthState } from '../../interfaces';
+/**
+ * Additional steps for after MFA authentication with authenticator app handler for step up flow
+ */
+export declare function postHandleVerifyMFAResponseForStepUp(): Generator<import("redux-saga/effects").CallEffect<void>, void, unknown>;
+/**
+ * Additional steps for after MFA authentication with authenticator app handler for login flow
+ * @param isAuthenticated
+ */
+export declare function postHandleVerifyMFAResponseForLogin(isAuthenticated: boolean): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<boolean[]> | Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<void>, void, {
+    routes: {
+        customLoginAuthenticatedUrl: any;
+        stepUpUrl: any;
+    };
+} & import("../../interfaces").User & string> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../interfaces").LoginState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<boolean>, void, (AuthState & {
+    step: any;
+} & boolean[] & false) | (AuthState & {
+    step: any;
+} & boolean[] & true)>;
+/**
+ * Handle after MFA authentication with authenticator app
+ * @param payload.user
+ * @param payload.tenants
+ * @param payload.activeTenant
+ * @param isStepUp
+ *
+ * When using this saga, you should wrap it with try/catch block and handle according to your logic
+ */
+export declare function handleVerifyMFAResponse({ user, tenants, activeTenant }: ILoginResponseV3, isStepUp?: boolean): Generator<import("redux-saga/effects").PutEffect<{
+    payload: Partial<AuthState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+    payload: import("../../interfaces").User;
+    type: string;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../..").TenantsState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<boolean[]> | Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<void>, void, {
+    routes: {
+        customLoginAuthenticatedUrl: any;
+        stepUpUrl: any;
+    };
+} & import("../../interfaces").User & string> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../interfaces").LoginState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<boolean>, void, (AuthState & {
+    step: any;
+} & boolean[] & false) | (AuthState & {
+    step: any;
+} & boolean[] & true)>>, void, unknown>;

package/auth/LoginState/sagas/handleVerifyMFAResponse.saga.js

@@ -0,0 +1,80 @@
+import { select, put, call } from 'redux-saga/effects';
+import { MFAStep } from '../../MfaState/interfaces';
+import { actions } from '../../reducer';
+import { LoginFlow, LoginStep } from '../interfaces';
+import { shouldShowPromptPasskeys } from '../saga.utils';
+import { afterStepUpAuthNavigation, afterAuthNavigation } from './afterAuthNavigation.saga';
+import { getFeatureFlags } from '../../../helpers';
+
+/**
+ * Additional steps for after MFA authentication with authenticator app handler for step up flow
+ */
+export function* postHandleVerifyMFAResponseForStepUp() {
+  yield call(afterStepUpAuthNavigation);
+}
+
+/**
+ * Additional steps for after MFA authentication with authenticator app handler for login flow
+ * @param isAuthenticated
+ */
+export function* postHandleVerifyMFAResponseForLogin(isAuthenticated) {
+  const {
+    loginState
+  } = yield select(state => state.auth);
+  const {
+    step: mfaStep
+  } = yield select(state => state.auth.mfaState);
+  const [securityCenterLoginFlows] = yield call(getFeatureFlags, ['security-center-show-login-flows']);
+  if (loginState.flow === LoginFlow.Login) {
+    if (securityCenterLoginFlows && loginState.isBreachedPassword && !isAuthenticated) {
+      yield put(actions.setLoginState({
+        step: LoginStep.breachedPassword,
+        loading: false
+      }));
+    } else {
+      const shouldShowPrompt = yield call(shouldShowPromptPasskeys);
+      if (mfaStep === MFAStep.smsVerifyCode && shouldShowPrompt) {
+        yield put(actions.setLoginState({
+          step: LoginStep.promptPasskeys,
+          loading: false
+        }));
+      } else {
+        yield afterAuthNavigation();
+      }
+    }
+  }
+}
+
+/**
+ * Handle after MFA authentication with authenticator app
+ * @param payload.user
+ * @param payload.tenants
+ * @param payload.activeTenant
+ * @param isStepUp
+ *
+ * When using this saga, you should wrap it with try/catch block and handle according to your logic
+ */
+export function* handleVerifyMFAResponse({
+  user,
+  tenants,
+  activeTenant
+}, isStepUp = false) {
+  yield put(actions.setUser(user));
+  yield put(actions.setTenantsState({
+    tenants,
+    activeTenant,
+    loading: false
+  }));
+  if (user.id) {
+    localStorage.setItem('userId', user.id);
+  }
+  const isAuthenticated = !!user.accessToken;
+  yield put(actions.setState({
+    isAuthenticated
+  }));
+  if (isStepUp) {
+    yield call(postHandleVerifyMFAResponseForStepUp);
+    return;
+  }
+  yield call(postHandleVerifyMFAResponseForLogin, isAuthenticated);
+}

package/auth/LoginState/sagas/index.d.ts

@@ -0,0 +1,7 @@
+export * from './afterAuthNavigation.saga';
+export * from './handleVerifyMFAResponse.saga';
+export * from './mfaWithSMS.saga';
+export * from './mfaRequiredState.saga';
+export * from './mfaWithAuthenticator.saga';
+export * from './mfaWithEmailCode.saga';
+export * from './mfaWithWebAuthn.saga';

package/auth/LoginState/sagas/index.js

@@ -0,0 +1,7 @@
+export * from './afterAuthNavigation.saga';
+export * from './handleVerifyMFAResponse.saga';
+export * from './mfaWithSMS.saga';
+export * from './mfaRequiredState.saga';
+export * from './mfaWithAuthenticator.saga';
+export * from './mfaWithEmailCode.saga';
+export * from './mfaWithWebAuthn.saga';

package/auth/LoginState/{mfaRequiredState.saga.d.ts → sagas/mfaRequiredState.saga.d.ts}

@@ -1,6 +1,6 @@
-import { LoginStep, QuickLoginStrategy, LoginFlow } from './interfaces';
-import { MFAState } from '../MfaState/interfaces';
-import { AuthState } from '../interfaces';
+import { LoginStep, QuickLoginStrategy, LoginFlow } from '../interfaces';
+import { MFAState } from '../../MfaState/interfaces';
+import { AuthState } from '../../interfaces';
 export declare function getMfaRequiredState(user: any): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<import("@frontegg/rest-api").IAllowedToRememberMfaDevice>, {
     user: undefined;
     isAuthenticated: boolean;

package/auth/LoginState/{mfaRequiredState.saga.js → sagas/mfaRequiredState.saga.js}

@@ -1,9 +1,9 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { call, select } from 'redux-saga/effects';
 import { api } from '@frontegg/rest-api';
-import { getMfaStepForEnrolledUsers, getMfaStepForNotEnrolledUsers } from './utils';
-import { LoginStep, LoginFlow } from './interfaces';
-// Separated file due to circular dependency
+import { getMfaStepForEnrolledUsers, getMfaStepForNotEnrolledUsers } from '../utils';
+import { LoginStep, LoginFlow } from '../interfaces';
+// Separated folder due to circular dependency
 
 export function* getMfaRequiredState(user) {
   let step = LoginStep.loginWithTwoFactor;

package/auth/LoginState/sagas/mfaWithAuthenticator.saga.d.ts

@@ -0,0 +1,42 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { ILoginWithMfa, ILoginResponseV3 } from '@frontegg/rest-api';
+import { AuthState } from '../../interfaces';
+import { SetLoadingAction } from '../interfaces';
+import { WithCallback } from '../../../interfaces';
+/**
+ * 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
+ */
+export declare function mfaWithAuthenticator({ callback, ...loginWithMfaPayload }: WithCallback<ILoginWithMfa>, setLoadingAction: SetLoadingAction, isStepUp: boolean): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<ILoginResponseV3> | import("redux-saga/effects").PutEffect<import("redux").Action<any>> | import("redux-saga/effects").CallEffect<{
+    isAuthenticated: boolean;
+}> | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<boolean[]> | Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<void>, void, {
+    routes: {
+        customLoginAuthenticatedUrl: any;
+        stepUpUrl: any;
+    };
+} & import("../../interfaces").User & string> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../interfaces").LoginState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<boolean>, void, (AuthState & boolean[] & false) | (AuthState & boolean[] & true)>>, void, ILoginResponseV3 & Partial<AuthState>>;
+/**
+ * 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
+ */
+export declare function loginWithMfa({ payload }: PayloadAction<WithCallback<ILoginWithMfa>>): Generator<Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<ILoginResponseV3> | import("redux-saga/effects").PutEffect<import("redux").Action<any>> | import("redux-saga/effects").CallEffect<{
+    isAuthenticated: boolean;
+}> | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<boolean[]> | Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<void>, void, {
+    routes: {
+        customLoginAuthenticatedUrl: any;
+        stepUpUrl: any;
+    };
+} & import("../../interfaces").User & string> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../interfaces").LoginState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<boolean>, void, (AuthState & boolean[] & false) | (AuthState & boolean[] & true)>>, void, ILoginResponseV3 & Partial<AuthState>>, void, unknown>;

package/auth/LoginState/sagas/mfaWithAuthenticator.saga.js

@@ -0,0 +1,140 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["callback"];
+import { select, put, call } from 'redux-saga/effects';
+import { api } from '@frontegg/rest-api';
+import { actions } from '../../reducer';
+import { LoginFlow, LoginStep } from '../interfaces';
+import { shouldShowPromptPasskeys, afterAuthenticationStateUpdate } from '../saga.utils';
+import { afterAuthNavigation, afterStepUpAuthNavigation } from './afterAuthNavigation.saga';
+import { getFeatureFlags } from '../../../helpers';
+import { errorHandler } from '../../../utils';
+
+/**
+ * @param tenants
+ * @param isAuthenticated
+ * @param isStepUp
+ * @returns additional update object for the afterAuthenticationStateUpdate saga as part of MFA auth with authenticator app
+ */
+function* buildPostAuthStateUpdate(tenants, isAuthenticated, isStepUp) {
+  const {
+    loginState
+  } = yield select(state => state.auth);
+  let additionalUpdate = {};
+  if (!isStepUp) {
+    const step = loginState.flow === LoginFlow.Login ? LoginStep.success : loginState.step;
+    additionalUpdate = {
+      loginState: {
+        flow: loginState.flow,
+        quickLoginToRegister: loginState.quickLoginToRegister,
+        loading: false,
+        step,
+        error: undefined,
+        tenants
+      }
+    };
+  }
+  return _extends({}, additionalUpdate, {
+    isAuthenticated
+  });
+}
+
+/**
+ * Handle after MFA authentication with authenticator app for login
+ */
+function* postLoginMfaAuthenticator(isAuthenticated, callback) {
+  const {
+    loginState
+  } = yield select(state => state.auth);
+  if (loginState.flow !== LoginFlow.Login) return;
+  const [securityCenterLoginFlows] = yield call(getFeatureFlags, ['security-center-show-login-flows']);
+  if (securityCenterLoginFlows && loginState.isBreachedPassword && !isAuthenticated) {
+    yield put(actions.setLoginState({
+      step: LoginStep.breachedPassword,
+      loading: false
+    }));
+  } else {
+    const shouldShowPrompt = yield call(shouldShowPromptPasskeys);
+    if (shouldShowPrompt) {
+      yield put(actions.setLoginState({
+        step: LoginStep.promptPasskeys,
+        loading: false
+      }));
+    } else {
+      yield afterAuthNavigation();
+    }
+  }
+  callback == null ? void 0 : callback(true);
+}
+
+/**
+ * Handle after MFA authentication with authenticator app for step up
+ */
+function* postStepUpMfaAuthenticator(callback) {
+  yield 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
+ */
+export function* mfaWithAuthenticator(_ref, setLoadingAction, isStepUp) {
+  let {
+      callback
+    } = _ref,
+    loginWithMfaPayload = _objectWithoutPropertiesLoose(_ref, _excluded);
+  yield put(setLoadingAction({
+    loading: true,
+    error: undefined
+  }));
+  try {
+    const {
+      user,
+      tenants = [],
+      activeTenant
+    } = yield call(api.auth.loginWithMfaV2, loginWithMfaPayload);
+    const isAuthenticated = !!user.accessToken;
+    const additionalUpdate = yield call(buildPostAuthStateUpdate, tenants, isAuthenticated, isStepUp);
+    yield call(afterAuthenticationStateUpdate, {
+      user,
+      tenants,
+      activeTenant
+    }, additionalUpdate);
+    if (user.id) {
+      localStorage.setItem('userId', user.id);
+    }
+    yield put(setLoadingAction({
+      loading: false,
+      error: undefined
+    }));
+    if (isStepUp) {
+      yield call(postStepUpMfaAuthenticator, callback);
+      return;
+    }
+    yield call(postLoginMfaAuthenticator, isAuthenticated, callback);
+  } catch (e) {
+    yield put(setLoadingAction({
+      loading: false,
+      error: 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
+ */
+export function* loginWithMfa({
+  payload
+}) {
+  yield mfaWithAuthenticator(payload, actions.setLoginState, false);
+}

package/auth/LoginState/sagas/mfaWithEmailCode.saga.d.ts

@@ -0,0 +1,73 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IPreVerifyMFA, IPreVerifyMFAEmailCodeResponse, IVerifyMFAEmailCode, ILoginResponseV3 } from '@frontegg/rest-api';
+import { WithCallback } from '../../../interfaces';
+import { SetLoadingAction } from '../interfaces';
+/**
+ * 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)
+ */
+export declare function preVerifyMFAEmailCode({ callback, ...payload }: WithCallback<IPreVerifyMFA>, setLoadingAction: SetLoadingAction): Generator<import("redux-saga/effects").PutEffect<import("redux").Action<any>> | import("redux-saga/effects").CallEffect<IPreVerifyMFAEmailCodeResponse>, void, IPreVerifyMFAEmailCodeResponse>;
+/**
+ * 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
+ */
+export declare function verifyMFAEmailCode({ callback, ...payload }: WithCallback<IVerifyMFAEmailCode>, setLoadingAction: SetLoadingAction): Generator<import("redux-saga/effects").CallEffect<ILoginResponseV3> | import("redux-saga/effects").PutEffect<import("redux").Action<any>> | Generator<import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../..").AuthState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+    payload: import("../..").User;
+    type: string;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../..").TenantsState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<boolean[]> | Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<void>, void, {
+    routes: {
+        customLoginAuthenticatedUrl: any;
+        stepUpUrl: any;
+    };
+} & import("../..").User & string> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../interfaces").LoginState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<boolean>, void, (import("../..").AuthState & {
+    step: any;
+} & boolean[] & false) | (import("../..").AuthState & {
+    step: any;
+} & boolean[] & true)>>, void, unknown>, void, ILoginResponseV3>;
+/**
+ * Pre verify step for MFA Email login
+ * @param payload.mfaToken
+ * @param payload.callback callback function to be called after the verification is done
+ */
+export declare function preVerifyMFAEmailCodeForLogin({ payload }: PayloadAction<WithCallback<IPreVerifyMFA>>): Generator<Generator<import("redux-saga/effects").PutEffect<import("redux").Action<any>> | import("redux-saga/effects").CallEffect<IPreVerifyMFAEmailCodeResponse>, void, IPreVerifyMFAEmailCodeResponse>, void, unknown>;
+/**
+ * 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
+ */
+export declare function verifyMFAEmailCodeForLogin({ payload }: PayloadAction<WithCallback<IVerifyMFAEmailCode>>): Generator<Generator<import("redux-saga/effects").CallEffect<ILoginResponseV3> | import("redux-saga/effects").PutEffect<import("redux").Action<any>> | Generator<import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../..").AuthState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+    payload: import("../..").User;
+    type: string;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../..").TenantsState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<boolean[]> | Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").CallEffect<void>, void, {
+    routes: {
+        customLoginAuthenticatedUrl: any;
+        stepUpUrl: any;
+    };
+} & import("../..").User & string> | import("redux-saga/effects").PutEffect<{
+    payload: Partial<import("../interfaces").LoginState>;
+    type: string;
+}> | import("redux-saga/effects").CallEffect<boolean>, void, (import("../..").AuthState & {
+    step: any;
+} & boolean[] & false) | (import("../..").AuthState & {
+    step: any;
+} & boolean[] & true)>>, void, unknown>, void, ILoginResponseV3>, void, unknown>;

package/auth/LoginState/sagas/mfaWithEmailCode.saga.js

@@ -0,0 +1,96 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"];
+import { call, put } from 'redux-saga/effects';
+import { api } from '@frontegg/rest-api';
+import { errorHandler } from '../../../utils';
+import { MFAStep } from '../../MfaState/interfaces';
+import { actions } from '../../reducer';
+import { handleVerifyMFAResponse } from './handleVerifyMFAResponse.saga';
+/**
+ * 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)
+ */
+export function* preVerifyMFAEmailCode(_ref, setLoadingAction) {
+  let {
+      callback
+    } = _ref,
+    payload = _objectWithoutPropertiesLoose(_ref, _excluded);
+  yield put(setLoadingAction({
+    loading: true,
+    error: undefined
+  }));
+  try {
+    const data = yield call(api.auth.preVerifyMFAEmailCode, payload);
+    yield put(actions.setMfaState({
+      otcToken: data.otcToken,
+      step: MFAStep.emailVerifyCode
+    }));
+    yield put(setLoadingAction({
+      loading: false,
+      error: undefined
+    }));
+    callback == null ? void 0 : callback(true);
+  } catch (e) {
+    yield put(setLoadingAction({
+      error: 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
+ */
+export function* verifyMFAEmailCode(_ref2, setLoadingAction) {
+  let {
+      callback
+    } = _ref2,
+    payload = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+  yield put(setLoadingAction({
+    loading: true
+  }));
+  try {
+    const data = yield call(api.auth.verifyMFAEmailCodeV2, payload);
+    yield handleVerifyMFAResponse(data);
+    yield put(setLoadingAction({
+      loading: false,
+      error: undefined
+    }));
+    callback == null ? void 0 : callback(true);
+  } catch (e) {
+    yield put(setLoadingAction({
+      loading: false,
+      error: 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
+ */
+export function* preVerifyMFAEmailCodeForLogin({
+  payload
+}) {
+  yield 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
+ */
+export function* verifyMFAEmailCodeForLogin({
+  payload
+}) {
+  yield verifyMFAEmailCode(payload, actions.setLoginState);
+}