@frontegg/redux-store 6.48.0 → 6.49.0-alpha.1

package/auth/LoginState/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { AuthStrategyEnum, IEnrollMFAWebAuthn, IPasswordlessPostLogin, ITenantsResponse, IVerifyMFAWebAuthn, IVerifyNewWebAuthnDevice, IWebAuthnPostLogin } from '@frontegg/rest-api';
+import { AuthStrategyEnum, IEnrollMFAWebAuthn, ILoginResponse, IPasswordlessPostLogin, ITenantsResponse, IVerifyMFAWebAuthn, IVerifyNewWebAuthnDevice, IWebAuthnPostLogin } from '@frontegg/rest-api';
 import { WithCallback } from '../../interfaces';
 import { CustomEventsOptions } from '../interfaces';
 export declare enum LoginStep {
@@ -53,6 +53,7 @@ export interface HostedLoginCallback {
 export interface FronteggNextJSSession {
     accessToken: string;
     refreshToken?: string;
+    user: ILoginResponse;
 }
 export interface IQuickSmsPasswordlessPreLoginPayload {
     userId: string;

package/auth/LoginState/saga.js

@@ -381,13 +381,11 @@ function* requestAuthorize({
   }));
 }
 
-function* refreshTokenSSR({
+function* isMFARequiredSSR({
   accessToken,
-  refreshToken
+  user
 }) {
   if (!accessToken) {
-    ContextHolder.setAccessToken(null);
-    ContextHolder.setUser(null);
     yield put(actions.setState({
       user: undefined,
       isAuthenticated: false
@@ -395,43 +393,17 @@ function* refreshTokenSSR({
     return;
   }
 
-  try {
-    const onRedirectTo = ContextHolder.onRedirectTo;
-    const {
-      routes
-    } = yield select(state => state.auth);
-    const {
-      user,
-      tenants
-    } = yield call(api.auth.generateLoginResponseV2, {
-      accessToken
-    });
+  const onRedirectTo = ContextHolder.onRedirectTo;
+  const {
+    routes
+  } = yield select(state => state.auth);
 
-    if (isMfaRequired(user)) {
-      const mfaRequiredState = yield getMfaRequiredState(user);
-      yield put(actions.setState(mfaRequiredState));
-      onRedirectTo(routes.loginUrl, {
-        preserveQueryParams: true
-      });
-    } else {
-      yield put(actions.setTenantsState({
-        tenants,
-        loading: false
-      }));
-      yield put(actions.setState({
-        user: _extends({}, user, {
-          refreshToken
-        }),
-        isAuthenticated: true
-      }));
-    }
-  } catch (e) {
-    ContextHolder.setAccessToken(null);
-    ContextHolder.setUser(null);
-    yield put(actions.setState({
-      user: undefined,
-      isAuthenticated: false
-    }));
+  if (isMfaRequired(user)) {
+    const mfaRequiredState = yield getMfaRequiredState(user);
+    yield put(actions.setState(mfaRequiredState));
+    onRedirectTo(routes.loginUrl, {
+      preserveQueryParams: true
+    });
   }
 }
 
@@ -439,19 +411,13 @@ function* requestAuthorizeSSR({
   payload
 }) {
   const calls = [];
-  yield put(actions.setState({
-    isLoading: true
-  }));
   yield put(actions.loadSocialLoginsConfigurationV2());
   calls.push(call(loadAllowSignUps));
   calls.push(call(loadSSOPublicConfigurationFunction));
   calls.push(call(loadVendorPublicInfo));
   calls.push(call(refreshMetadata));
-  calls.push(call(refreshTokenSSR, payload));
+  calls.push(call(isMFARequiredSSR, payload));
   yield all(calls);
-  yield put(actions.setState({
-    isLoading: false
-  }));
 }
 
 const getUri = urlStrategy => {
@@ -1361,7 +1327,8 @@ function* handleEnrollMFAResponse({
   const mfaState = {
     step: MFAStep.recoveryCode,
     loading: false,
-    error: undefined
+    error: undefined,
+    saving: false
   };
 
   if (user != null && user.recoveryCode) {
@@ -1689,9 +1656,6 @@ function* verifyMFAWebAuthnForLogin(_ref19) {
   }));
 
   try {
-    const {
-      loginState
-    } = yield select(state => state.auth);
     const publicKey = publicKeyCredentialToJSON(payload.publicKey);
     const data = yield call(api.auth.verifyMFAWebAuthnForLogin, deviceId, _extends({}, payload, {
       options: publicKey

package/auth/MfaState/index.d.ts

@@ -1,6 +1,7 @@
-import { IDisableMfa, ILoginWithMfa, IVerifyMfa } from '@frontegg/rest-api';
-import { MFAState } from './interfaces';
+import { IDisableMfa, IDisableMFASMS, ILoginWithMfa, IVerifyMfa } from '@frontegg/rest-api';
+import { IDisableMFAWebAuthnPayload, IUserEnrollMFASMSPayload, IUserEnrollMFAWebAuthnPayload, IUserPreEnrollMFASMSPayload, MFAState } from './interfaces';
 import { WithCallback } from '../../interfaces';
+import { IPreEnrollMFAWebAuthNForLoginResponse, IPreVerifyMFAWebAuthNForLoginResponse, WithDeviceId } from '../LoginState/interfaces';
 declare const mfaState: MFAState;
 declare const reducers: {
     setMfaState: {
@@ -20,7 +21,7 @@ declare const reducers: {
             user?: import("..").User | null | undefined;
             isSSOAuth: boolean;
             ssoACS?: string | undefined;
-            loginState: import("..").LoginState;
+            loginState: import("../LoginState/interfaces").LoginState;
             activateState: import("..").ActivateAccountState;
             acceptInvitationState: import("..").AcceptInvitationState;
             forgotPasswordState: import("..").ForgotPasswordState;
@@ -56,7 +57,7 @@ declare const reducers: {
         user?: import("..").User | null | undefined;
         isSSOAuth: boolean;
         ssoACS?: string | undefined;
-        loginState: import("..").LoginState;
+        loginState: import("../LoginState/interfaces").LoginState;
         activateState: import("..").ActivateAccountState;
         acceptInvitationState: import("..").AcceptInvitationState;
         forgotPasswordState: import("..").ForgotPasswordState;
@@ -84,9 +85,31 @@ declare const reducers: {
 };
 declare const actions: {
     enrollMfa: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    getMFADevices: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    getMFAStrategies: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
     verifyMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IVerifyMfa, string | undefined>], WithCallback<IVerifyMfa, string | undefined>, string, never, never>;
     verifyMfaAfterForce: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ILoginWithMfa, string | undefined>], WithCallback<ILoginWithMfa, string | undefined>, string, never, never>;
     disableMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IDisableMfa, boolean>], WithCallback<IDisableMfa, boolean>, string, never, never>;
+    preDisableMfaSms: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<{
+        deviceId: string;
+    }, boolean>], WithCallback<{
+        deviceId: string;
+    }, boolean>, string, never, never>;
+    disableMfaSms: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<WithDeviceId<IDisableMFASMS>, boolean>], WithCallback<WithDeviceId<IDisableMFASMS>, boolean>, string, never, never>;
+    preEnrollMfaSms: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<Pick<import("@frontegg/rest-api").IPreEnrollMFASMS, "mfaToken" | "phoneNumber">, boolean>], WithCallback<Pick<import("@frontegg/rest-api").IPreEnrollMFASMS, "mfaToken" | "phoneNumber">, boolean>, string, never, never>;
+    enrollMfaSms: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<Pick<import("@frontegg/rest-api").IEnrollMFASMS, "mfaToken" | "otcToken" | "code">, string | undefined>], WithCallback<Pick<import("@frontegg/rest-api").IEnrollMFASMS, "mfaToken" | "otcToken" | "code">, string | undefined>, string, never, never>;
+    preEnrollMfaWebAuthn: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[{
+        callback?: ((data: IPreEnrollMFAWebAuthNForLoginResponse | null, error?: string | undefined) => void) | undefined;
+    }], {
+        callback?: ((data: IPreEnrollMFAWebAuthNForLoginResponse | null, error?: string | undefined) => void) | undefined;
+    }, string, never, never>;
+    enrollMfaWebAuthn: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IUserEnrollMFAWebAuthnPayload], IUserEnrollMFAWebAuthnPayload, string, never, never>;
+    preDisableMfaWebAuthn: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<{
+        deviceId: string;
+    }, IPreVerifyMFAWebAuthNForLoginResponse>], WithCallback<{
+        deviceId: string;
+    }, IPreVerifyMFAWebAuthNForLoginResponse>, string, never, never>;
+    disableMfaWebAuthn: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IDisableMFAWebAuthnPayload], IDisableMFAWebAuthnPayload, string, never, never>;
 };
 /**
  *  To be used for actions types after dispatch, and should contains
@@ -96,9 +119,19 @@ declare type DispatchedActions = {
     setMfaState: (state: Partial<MFAState>) => void;
     resetMfaState: () => void;
     enrollMfa: () => void;
+    getMFADevices: () => void;
+    getMFAStrategies: () => void;
     verifyMfa: (payload: WithCallback<IVerifyMfa, string | undefined>) => void;
     verifyMfaAfterForce: (payload: WithCallback<ILoginWithMfa, string | undefined>) => void;
     disableMfa: (payload: WithCallback<IDisableMfa>) => void;
+    preDisableMfaSms: (payload: WithCallback<WithDeviceId<{}>>) => void;
+    disableMfaSms: (payload: WithCallback<WithDeviceId<IDisableMFASMS>>) => void;
+    preEnrollMfaSms: (payload: IUserPreEnrollMFASMSPayload) => void;
+    enrollMfaSms: (payload: IUserEnrollMFASMSPayload) => void;
+    preEnrollMfaWebAuthn: (payload: WithCallback<{}, IPreEnrollMFAWebAuthNForLoginResponse>) => void;
+    enrollMfaWebAuthn: (payload: IUserEnrollMFAWebAuthnPayload) => void;
+    preDisableMfaWebAuthn: (payload: WithCallback<WithDeviceId<{}>, IPreVerifyMFAWebAuthNForLoginResponse>) => void;
+    disableMfaWebAuthn: (payload: IDisableMFAWebAuthnPayload) => void;
 };
 export declare type MfaActions = DispatchedActions;
 export { mfaState, reducers as mfaReducers, actions as mfaActions };

package/auth/MfaState/index.js

@@ -4,7 +4,8 @@ import { resetStateByKey, typeReducerForKey } from '../utils';
 import { authStoreName } from '../../constants';
 const mfaState = {
   step: MFAStep.verify,
-  loading: false
+  loading: false,
+  saving: false
 };
 const reducers = {
   setMfaState: typeReducerForKey('mfaState'),
@@ -14,6 +15,8 @@ const reducers = {
 };
 const actions = {
   enrollMfa: createAction(`${authStoreName}/enrollMfa`),
+  getMFADevices: createAction(`${authStoreName}/getMFADevices`),
+  getMFAStrategies: createAction(`${authStoreName}/getMFAStrategies`),
   verifyMfa: createAction(`${authStoreName}/verifyMfa`, payload => ({
     payload
   })),
@@ -22,6 +25,30 @@ const actions = {
   })),
   disableMfa: createAction(`${authStoreName}/disableMfa`, payload => ({
     payload
+  })),
+  preDisableMfaSms: createAction(`${authStoreName}/preDisableMfaSms`, payload => ({
+    payload
+  })),
+  disableMfaSms: createAction(`${authStoreName}/disableMfaSms`, payload => ({
+    payload
+  })),
+  preEnrollMfaSms: createAction(`${authStoreName}/preEnrollMfaSms`, payload => ({
+    payload
+  })),
+  enrollMfaSms: createAction(`${authStoreName}/enrollMfaSms`, payload => ({
+    payload
+  })),
+  preEnrollMfaWebAuthn: createAction(`${authStoreName}/preEnrollMfaWebAuthn`, payload => ({
+    payload
+  })),
+  enrollMfaWebAuthn: createAction(`${authStoreName}/enrollMfaWebAuthn`, payload => ({
+    payload
+  })),
+  preDisableMfaWebAuthn: createAction(`${authStoreName}/preDisableMfaWebAuthn`, payload => ({
+    payload
+  })),
+  disableMfaWebAuthn: createAction(`${authStoreName}/disableMfaWebAuthn`, payload => ({
+    payload
   }))
 };
 /**

package/auth/MfaState/interfaces.d.ts

@@ -1,4 +1,6 @@
-import { MFAStrategyEnum, UserMFADevicesResponse } from '@frontegg/rest-api';
+import { IEnrollMFASMS, IEnrollMFAWebAuthn, IPreEnrollMFASMS, MFAStrategyEnum, UserMFADevicesResponse } from '@frontegg/rest-api';
+import { WithCallback } from '../../interfaces';
+import { IVerifyMFAWebAuthnPayload } from '../LoginState/interfaces';
 export declare enum MFAStep {
     'verify' = "verify",
     'recoveryCode' = "recoveryCode",
@@ -9,6 +11,7 @@ export declare enum MFAStep {
 export interface MFAState {
     step: MFAStep;
     loading: boolean;
+    saving: boolean;
     error?: any;
     recoveryCode?: string;
     qrCode?: string | null;
@@ -18,3 +21,11 @@ export interface MFAState {
     mfaStrategies?: MFAStrategyEnum[];
     mfaDevices?: UserMFADevicesResponse;
 }
+export declare type IUserPreEnrollMFASMSPayload = WithCallback<Omit<IPreEnrollMFASMS, 'maToken' | 'rememberDevice'>>;
+export declare type IUserEnrollMFASMSPayload = WithCallback<Omit<IEnrollMFASMS, 'maToken' | 'rememberDevice'>, string | undefined>;
+export declare type IUserEnrollMFAWebAuthnPayload = WithCallback<Omit<IEnrollMFAWebAuthn, 'options' | 'mfaToken' | 'rememberDevice'>, string | undefined> & {
+    publicKey: Credential;
+};
+export declare type IDisableMFAWebAuthnPayload = WithCallback<Omit<IVerifyMFAWebAuthnPayload, 'options' | 'mfaToken' | 'rememberDevice'>> & {
+    publicKey: Credential;
+};