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

package/auth/LoginState/helpers.d.ts

@@ -0,0 +1,31 @@
+import { IEmailPasswordlessPreLogin, IPasswordlessPreLogin, MFAStrategyEnum, UserMFADevicesResponse } from '@frontegg/rest-api';
+import { MFAStep } from '../MfaState/interfaces';
+import { FronteggState } from '../../interfaces';
+export declare const isAbsoluteUrl: (path: string) => boolean;
+export declare const getRedirectUrl: ({ authenticatedUrl, enforceRedirectToSameSite, allowedRedirectOrigins, includeQueryParam, }: {
+    authenticatedUrl: string;
+    enforceRedirectToSameSite: boolean;
+    allowedRedirectOrigins: string[];
+    includeQueryParam: boolean;
+}) => string;
+export declare const getSearchParamsFromUrl: (url: string) => string | undefined;
+export declare const getPathAndSearchParamsFromUrl: (url: string) => string;
+/**
+ *
+ * @param key
+ * @returns the value of the param as string or undefined if it does not exist
+ */
+export declare const getSearchParam: (key: string) => string | undefined;
+export declare const TENANT_ID_PARAM_KEY = "tenantId";
+export declare const getNumberOfMfaDevices: (mfaDevices: UserMFADevicesResponse) => {
+    numberOfWebAuthnDevices: number;
+    numberOfPhoneDevices: number;
+    numberOfAuthenticators: number;
+    numberOfEmails: number;
+    totalDevices: number;
+};
+export declare const getMfaStepForEnrolledUsers: (mfaDevices: UserMFADevicesResponse) => MFAStep.verify | MFAStep.authenticatorApp | MFAStep.smsVerifyCode | MFAStep.emailVerifyCode;
+export declare const getMfaStepForNotEnrolledUsers: (mfaStrategies: MFAStrategyEnum[]) => MFAStep.verify | MFAStep.authenticatorApp | MFAStep.smsSetPhoneNumber | MFAStep.emailVerifyCode;
+export declare const isOauthCallbackRoute: (activeUri: string) => boolean;
+export declare function isEmailPayload(payload: IPasswordlessPreLogin): payload is IEmailPasswordlessPreLogin;
+export declare const getBaseNameWithoutSlashSuffix: (state: FronteggState) => string | null;

package/auth/LoginState/helpers.js

@@ -0,0 +1,131 @@
+import { ContextHolder, MFAStrategyEnum } from '@frontegg/rest-api';
+import { MFAStep } from '../MfaState/interfaces';
+export const isAbsoluteUrl = path => {
+  try {
+    new URL(path);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+const isValidRedirectUrl = (redirectUrl, allowedRedirectOrigins) => {
+  const currentUrl = new URL(window.location.href);
+  const redirectURL = new URL(redirectUrl);
+  const isSameSite = redirectURL.origin === currentUrl.origin;
+  const isOriginInWhiteList = allowedRedirectOrigins.includes(redirectURL.origin);
+  return isOriginInWhiteList || isSameSite;
+};
+export const getRedirectUrl = ({
+  authenticatedUrl,
+  enforceRedirectToSameSite,
+  allowedRedirectOrigins,
+  includeQueryParam
+}) => {
+  const currentUrl = new URL(window.location.href);
+  let redirectUrl = authenticatedUrl;
+  const redirectUrlQueryParam = currentUrl.searchParams.get('redirectUrl');
+  if (redirectUrlQueryParam) {
+    if (!enforceRedirectToSameSite || !isAbsoluteUrl(redirectUrlQueryParam)) {
+      redirectUrl = redirectUrlQueryParam;
+    } else {
+      if (isValidRedirectUrl(redirectUrlQueryParam, allowedRedirectOrigins)) {
+        redirectUrl = redirectUrlQueryParam;
+      } else {
+        console.warn('The redirect url param is not valid, the origin is a different site');
+      }
+    }
+  } else if (includeQueryParam) {
+    redirectUrl += window.location.search;
+  }
+  return redirectUrl;
+};
+export const getSearchParamsFromUrl = url => {
+  const {
+    searchParams
+  } = new URL(url);
+  const stringifySearchParam = searchParams.toString();
+  if (stringifySearchParam) {
+    return `?${stringifySearchParam}`;
+  }
+  return undefined;
+};
+export const getPathAndSearchParamsFromUrl = url => {
+  const {
+    pathname
+  } = new URL(url);
+  const searchParams = getSearchParamsFromUrl(url);
+  if (searchParams) {
+    return pathname + searchParams;
+  }
+  return pathname;
+};
+
+/**
+ *
+ * @param key
+ * @returns the value of the param as string or undefined if it does not exist
+ */
+export const getSearchParam = key => {
+  const params = new URLSearchParams(window.location.search);
+  const param = params.get(key);
+  return param != null ? param : undefined;
+};
+export const TENANT_ID_PARAM_KEY = 'tenantId';
+export const getNumberOfMfaDevices = mfaDevices => {
+  const numberOfWebAuthnDevices = +Boolean(mfaDevices.webauthn.length);
+  const numberOfPhoneDevices = +Boolean(mfaDevices.phones.length);
+  const numberOfAuthenticators = +Boolean(mfaDevices.authenticators.length);
+  const numberOfEmails = +Boolean(mfaDevices.emails.length);
+  const totalDevices = numberOfWebAuthnDevices + numberOfPhoneDevices + numberOfAuthenticators + numberOfEmails;
+  return {
+    numberOfWebAuthnDevices,
+    numberOfPhoneDevices,
+    numberOfAuthenticators,
+    numberOfEmails,
+    totalDevices
+  };
+};
+export const getMfaStepForEnrolledUsers = mfaDevices => {
+  const {
+    numberOfPhoneDevices,
+    numberOfAuthenticators,
+    numberOfEmails,
+    totalDevices
+  } = getNumberOfMfaDevices(mfaDevices);
+  if (totalDevices === 1) {
+    if (numberOfAuthenticators) {
+      return MFAStep.authenticatorApp;
+    } else if (numberOfPhoneDevices) {
+      return MFAStep.smsVerifyCode;
+    } else if (numberOfEmails) {
+      return MFAStep.emailVerifyCode;
+    }
+  }
+  return MFAStep.verify;
+};
+export const getMfaStepForNotEnrolledUsers = mfaStrategies => {
+  if (mfaStrategies.length === 1) {
+    const [strategy] = mfaStrategies;
+    if (strategy === MFAStrategyEnum.AuthenticatorApp) {
+      return MFAStep.authenticatorApp;
+    } else if (strategy === MFAStrategyEnum.SMS) {
+      return MFAStep.smsSetPhoneNumber;
+    } else if (strategy === MFAStrategyEnum.EmailCode) {
+      return MFAStep.emailVerifyCode;
+    }
+  }
+  return MFAStep.verify;
+};
+export const isOauthCallbackRoute = activeUri => {
+  return activeUri === '/oauth/callback';
+};
+export function isEmailPayload(payload) {
+  return 'email' in payload;
+}
+export const getBaseNameWithoutSlashSuffix = state => {
+  const basename = ContextHolder.for(state.root.appName).getBasename();
+  if (basename != null && basename.endsWith('/')) {
+    return basename.slice(0, -1);
+  }
+  return basename;
+};

package/auth/LoginState/index.d.ts

@@ -1,233 +1,3 @@
-import { IChangePhoneNumberWithVerification, ICreateNewDeviceSessionResponse, IEmailPasswordlessPreLogin, IEnrollMFAAuthenticatorApp, IEnrollMFASMS, IForgotPassword, ILogin, ILoginWithMfa, IPostLogin, IPreEnrollMFA, IPreEnrollMFASMS, IPreLogin, IPreVerifyMFA, IVerifyChangePhoneNumber, IVerifyMFAEmailCode, IVerifyMFASMS, IWebAuthnPreLogin, IWebAuthnPreLoginResponse } from '@frontegg/rest-api';
-import { FronteggNextJSSession, HostedLoginCallback, IEnrollMFAWebAuthnPayload, IPasswordlessPostLoginPayload, IPreEnrollMFAWebAuthNForLoginResponse, IPreVerifyMFAWebAuthNForLoginResponse, IQuickSmsPasswordlessPreLoginPayload, IRecoverMFATokenPayload, IVerifyMFAWebAuthnPayload, IVerifyNewWebAuthnDevicePayload, IWebAuthnPostLoginPayload, LoginState, WithDeviceId } from './interfaces';
-import { WithCallback } from '../../interfaces';
-import { IVerifyInviteToken } from '@frontegg/rest-api';
-declare const loginState: LoginState;
-declare const reducers: {
-    setLoginState: {
-        prepare: (payload: Partial<LoginState>) => {
-            payload: Partial<LoginState>;
-        };
-        reducer: (state: import("..").AuthState, { payload }: {
-            payload: Partial<LoginState>;
-            type: string;
-        }) => {
-            onRedirectTo: (path: string, opts?: import("@frontegg/rest-api").RedirectOptions | undefined) => void;
-            error?: any;
-            isAuthenticated: boolean;
-            userIp?: string | undefined;
-            isLoading: boolean;
-            keepSessionAlive?: boolean | undefined;
-            user?: import("..").User | null | undefined;
-            isSSOAuth: boolean;
-            ssoACS?: string | undefined;
-            includeQueryParam?: boolean | undefined;
-            loginState: LoginState;
-            activateState: import("..").ActivateAccountState;
-            acceptInvitationState: import("..").AcceptInvitationState;
-            forgotPasswordState: import("..").ForgotPasswordState;
-            resetPhoneNumberState: import("..").ResetPhoneNumberState;
-            ssoState: import("..").SSOState;
-            profileState: import("..").ProfileState;
-            mfaState: import("..").MFAState;
-            teamState: import("..").TeamState;
-            groupsState: import("..").GroupsState;
-            groupsDialogsState: import("..").GroupsDialogsState;
-            socialLoginState: import("..").SocialLoginState;
-            signUpState: import("..").SignUpState;
-            apiTokensState: import("..").ApiTokensState;
-            securityPolicyState: import("..").SecurityPolicyState;
-            restrictionsState: import("..").RestrictionsState;
-            provisioningState: import("..").ProvisioningState;
-            accountSettingsState: import("..").AccountSettingsState;
-            tenantsState: import("..").TenantsState;
-            rolesState: import("..").RolesState;
-            sessionsState: import("..").SessionsState;
-            hostedLoginBox?: boolean | undefined;
-            disableSilentRefresh?: boolean | undefined;
-            sessionsPolicyState: import("..").SessionsPolicyState;
-            impersonateState?: import("..").ImpersonateState | undefined;
-            passkeysState?: import("..").PasskeysState | undefined;
-            customLoginState?: import("..").CustomLoginState | undefined;
-            allAccountsState?: import("..").IAllAccountsState | undefined;
-            allAccountsDialogsState?: import("..").IAllAccountsDialogsState | undefined;
-            securityCenterState?: import("..").SecurityCenterState | undefined;
-            routes: import("..").AuthPageRoutes;
-            header?: any;
-            loaderComponent?: any;
-        };
-    };
-    resetLoginState: (state: import("..").AuthState) => {
-        onRedirectTo: (path: string, opts?: import("@frontegg/rest-api").RedirectOptions | undefined) => void;
-        error?: any;
-        isAuthenticated: boolean;
-        userIp?: string | undefined;
-        isLoading: boolean;
-        keepSessionAlive?: boolean | undefined;
-        user?: import("..").User | null | undefined;
-        isSSOAuth: boolean;
-        ssoACS?: string | undefined;
-        includeQueryParam?: boolean | undefined;
-        loginState: LoginState;
-        activateState: import("..").ActivateAccountState;
-        acceptInvitationState: import("..").AcceptInvitationState;
-        forgotPasswordState: import("..").ForgotPasswordState;
-        resetPhoneNumberState: import("..").ResetPhoneNumberState;
-        ssoState: import("..").SSOState;
-        profileState: import("..").ProfileState;
-        mfaState: import("..").MFAState;
-        teamState: import("..").TeamState;
-        groupsState: import("..").GroupsState;
-        groupsDialogsState: import("..").GroupsDialogsState;
-        socialLoginState: import("..").SocialLoginState;
-        signUpState: import("..").SignUpState;
-        apiTokensState: import("..").ApiTokensState;
-        securityPolicyState: import("..").SecurityPolicyState;
-        restrictionsState: import("..").RestrictionsState;
-        provisioningState: import("..").ProvisioningState;
-        accountSettingsState: import("..").AccountSettingsState;
-        tenantsState: import("..").TenantsState;
-        rolesState: import("..").RolesState;
-        sessionsState: import("..").SessionsState;
-        hostedLoginBox?: boolean | undefined;
-        disableSilentRefresh?: boolean | undefined;
-        sessionsPolicyState: import("..").SessionsPolicyState;
-        impersonateState?: import("..").ImpersonateState | undefined;
-        passkeysState?: import("..").PasskeysState | undefined;
-        customLoginState?: import("..").CustomLoginState | undefined;
-        allAccountsState?: import("..").IAllAccountsState | undefined;
-        allAccountsDialogsState?: import("..").IAllAccountsDialogsState | undefined;
-        securityCenterState?: import("..").SecurityCenterState | undefined;
-        routes: import("..").AuthPageRoutes;
-        header?: any;
-        loaderComponent?: any;
-    };
-};
-declare const actions: {
-    requestAuthorize: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[(boolean | undefined)?], boolean, string, never, never>;
-    requestAuthorizeSSR: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[FronteggNextJSSession], FronteggNextJSSession, string, never, never>;
-    requestHostedLoginAuthorize: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[(Record<string, string> | undefined)?], Record<string, string> | undefined, string, never, never>;
-    requestHostedLoginAuthorizeV2: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[({
-        additionalParams?: Record<string, string> | undefined;
-        shouldRedirectToLogin?: boolean | undefined;
-        firstTime?: boolean | undefined;
-    } | undefined)?], {
-        additionalParams?: Record<string, string> | undefined;
-        shouldRedirectToLogin?: boolean | undefined;
-        firstTime?: boolean | undefined;
-    } | undefined, string, never, never>;
-    handleHostedLoginCallback: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[HostedLoginCallback], HostedLoginCallback, string, never, never>;
-    afterAuthNavigation: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    preLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IPreLogin & {
-        recaptchaToken?: string | undefined;
-        invitationToken?: string | undefined;
-    }, void>], WithCallback<IPreLogin & {
-        recaptchaToken?: string | undefined;
-        invitationToken?: string | undefined;
-    }, void>, string, never, never>;
-    postLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IPostLogin], IPostLogin, string, never, never>;
-    login: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ILogin, boolean>], WithCallback<ILogin, boolean>, string, never, never>;
-    loginWithMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ILoginWithMfa, boolean>], WithCallback<ILoginWithMfa, boolean>, string, never, never>;
-    recoverMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IRecoverMFATokenPayload], IRecoverMFATokenPayload, string, never, never>;
-    logout: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[((() => void) | undefined)?], (() => void) | undefined, string, never, never>;
-    silentLogout: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[(WithCallback<{
-        callbackTimeout?: number | undefined;
-    }, boolean> | undefined)?], WithCallback<{
-        callbackTimeout?: number | undefined;
-    }, boolean> | undefined, string, never, never>;
-    checkIfAllowToRememberMfaDevice: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[{
-        mfaToken: string;
-    }], {
-        mfaToken: string;
-    }, string, never, never>;
-    changePhoneNumberWithVerification: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IChangePhoneNumberWithVerification, boolean>], WithCallback<IChangePhoneNumberWithVerification, boolean>, string, never, never>;
-    verifyChangePhoneNumber: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IVerifyChangePhoneNumber, boolean>], WithCallback<IVerifyChangePhoneNumber, boolean>, string, never, never>;
-    quickSmsPasswordlessPreLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IQuickSmsPasswordlessPreLoginPayload, boolean>], WithCallback<IQuickSmsPasswordlessPreLoginPayload, boolean>, string, never, never>;
-    passwordlessPreLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IEmailPasswordlessPreLogin, void>], WithCallback<IEmailPasswordlessPreLogin, void>, string, never, never>;
-    passwordlessPostLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IPasswordlessPostLoginPayload, boolean>], WithCallback<IPasswordlessPostLoginPayload, boolean>, string, never, never>;
-    verifyInviteToken: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IVerifyInviteToken], IVerifyInviteToken, string, never, never>;
-    webAuthnPrelogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IWebAuthnPreLogin, IWebAuthnPreLoginResponse | null>], WithCallback<IWebAuthnPreLogin, IWebAuthnPreLoginResponse | null>, string, never, never>;
-    webAuthnPostLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IWebAuthnPostLoginPayload], IWebAuthnPostLoginPayload, string, never, never>;
-    webAuthnCreateNewDeviceSession: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[{
-        callback?: import("../../interfaces").CallbackMethod<ICreateNewDeviceSessionResponse | null> | undefined;
-    }], {
-        callback?: import("../../interfaces").CallbackMethod<ICreateNewDeviceSessionResponse | null> | undefined;
-    }, string, never, never>;
-    webAuthnVerifyNewDeviceSession: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IVerifyNewWebAuthnDevicePayload], IVerifyNewWebAuthnDevicePayload, string, never, never>;
-    getUserIP: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[{
-        callback?: import("../../interfaces").CallbackMethod<boolean> | undefined;
-    }], {
-        callback?: import("../../interfaces").CallbackMethod<boolean> | undefined;
-    }, string, never, never>;
-    preEnrollMFAWebAuthnForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IPreEnrollMFA, IPreEnrollMFAWebAuthNForLoginResponse>], WithCallback<IPreEnrollMFA, IPreEnrollMFAWebAuthNForLoginResponse>, string, never, never>;
-    enrollMFAWebAuthnForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IEnrollMFAWebAuthnPayload], IEnrollMFAWebAuthnPayload, string, never, never>;
-    enrollMFAAuthenticatorAppForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IEnrollMFAAuthenticatorApp, boolean>], WithCallback<IEnrollMFAAuthenticatorApp, boolean>, string, never, never>;
-    preEnrollMFASMSForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IPreEnrollMFASMS, boolean>], WithCallback<IPreEnrollMFASMS, boolean>, string, never, never>;
-    enrollMFASMSForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IEnrollMFASMS, boolean>], WithCallback<IEnrollMFASMS, boolean>, string, never, never>;
-    preVerifyMFAWebAuthnForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<WithDeviceId<IPreVerifyMFA>, IPreVerifyMFAWebAuthNForLoginResponse>], WithCallback<WithDeviceId<IPreVerifyMFA>, IPreVerifyMFAWebAuthNForLoginResponse>, string, never, never>;
-    verifyMFAWebAuthnForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IVerifyMFAWebAuthnPayload], IVerifyMFAWebAuthnPayload, string, never, never>;
-    preVerifyMFASMSForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<WithDeviceId<IPreVerifyMFA>, boolean>], WithCallback<WithDeviceId<IPreVerifyMFA>, boolean>, string, never, never>;
-    verifyMFASMSForLogin: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<WithDeviceId<IVerifyMFASMS>, boolean>], WithCallback<WithDeviceId<IVerifyMFASMS>, boolean>, string, never, never>;
-    preVerifyMFAEmailCode: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IPreVerifyMFA, boolean>], WithCallback<IPreVerifyMFA, boolean>, string, never, never>;
-    verifyMFAEmailCode: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IVerifyMFAEmailCode, boolean>], WithCallback<IVerifyMFAEmailCode, boolean>, string, never, never>;
-    resetBreachedPassword: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IForgotPassword], IForgotPassword, string, never, never>;
-};
-/**
- *  To be used for actions types after dispatch, and should contains
- *  the reducers and actions as standalone function
- */
-declare type DispatchedActions = {
-    setLoginState: (state: Partial<LoginState>) => void;
-    resetLoginState: () => void;
-    requestAuthorize: (payload?: boolean) => void;
-    requestAuthorizeSSR: (payload: FronteggNextJSSession) => void;
-    requestHostedLoginAuthorize: (payload?: Record<string, string>) => void;
-    requestHostedLoginAuthorizeV2: (payload?: {
-        additionalParams?: Record<string, string>;
-        shouldRedirectToLogin?: boolean;
-        firstTime?: boolean;
-    }) => void;
-    handleHostedLoginCallback: (payload: HostedLoginCallback) => void;
-    afterAuthNavigation: () => void;
-    preLogin: (payload: WithCallback<IPreLogin & {
-        recaptchaToken?: string;
-        invitationToken?: string;
-    }, void>) => void;
-    postLogin: (payload: IPostLogin) => void;
-    login: (payload: WithCallback<ILogin>) => void;
-    loginWithMfa: (payload: WithCallback<ILoginWithMfa>) => void;
-    recoverMfa: (payload: IRecoverMFATokenPayload) => void;
-    logout: (payload?: () => void) => void;
-    silentLogout: (payload?: WithCallback<{
-        callbackTimeout?: number;
-    }>) => void;
-    checkIfAllowToRememberMfaDevice: (payload: {
-        mfaToken: string;
-    }) => void;
-    changePhoneNumberWithVerification: (payload: WithCallback<IChangePhoneNumberWithVerification>) => void;
-    verifyChangePhoneNumber: (payload: WithCallback<IVerifyChangePhoneNumber>) => void;
-    quickSmsPasswordlessPreLogin: (payload: WithCallback<IQuickSmsPasswordlessPreLoginPayload>) => void;
-    passwordlessPreLogin: (payload: WithCallback<IEmailPasswordlessPreLogin, void>) => void;
-    passwordlessPostLogin: (payload: WithCallback<IPasswordlessPostLoginPayload>) => void;
-    verifyInviteToken: (payload: IVerifyInviteToken) => void;
-    webAuthnPrelogin: (payload: WithCallback<IWebAuthnPreLogin, IWebAuthnPreLoginResponse | null>) => void;
-    webAuthnPostLogin: (payload: IWebAuthnPostLoginPayload) => void;
-    webAuthnCreateNewDeviceSession: (payload: WithCallback<{}, ICreateNewDeviceSessionResponse | null>) => void;
-    webAuthnVerifyNewDeviceSession: (payload: IVerifyNewWebAuthnDevicePayload) => void;
-    getUserIP: (payload: WithCallback) => void;
-    preEnrollMFAWebAuthnForLogin: (payload: WithCallback<IPreEnrollMFA, IPreEnrollMFAWebAuthNForLoginResponse>) => void;
-    enrollMFAWebAuthnForLogin: (payload: IEnrollMFAWebAuthnPayload) => void;
-    enrollMFAAuthenticatorAppForLogin: (payload: WithCallback<IEnrollMFAAuthenticatorApp>) => void;
-    preEnrollMFASMSForLogin: (payload: WithCallback<IPreEnrollMFASMS>) => void;
-    enrollMFASMSForLogin: (payload: WithCallback<IEnrollMFASMS>) => void;
-    preVerifyMFAWebAuthnForLogin: (payload: WithCallback<WithDeviceId<IPreVerifyMFA>, IPreVerifyMFAWebAuthNForLoginResponse>) => void;
-    verifyMFAWebAuthnForLogin: (payload: IVerifyMFAWebAuthnPayload) => void;
-    preVerifyMFASMSForLogin: (payload: WithCallback<WithDeviceId<IPreVerifyMFA>>) => void;
-    verifyMFASMSForLogin: (payload: WithCallback<WithDeviceId<IVerifyMFASMS>>) => void;
-    preVerifyMFAEmailCode: (payload: WithCallback<IPreVerifyMFA>) => void;
-    verifyMFAEmailCode: (payload: WithCallback<IVerifyMFAEmailCode>) => void;
-    resetBreachedPassword: (payload: IForgotPassword) => void;
-};
-export declare type LoginActions = DispatchedActions;
-export { loginState, reducers as loginReducers, actions as loginActions };
-export { getRedirectUrl } from './utils';
+import createLoginState from './state';
+import buildLoginActions from './actions';
+export { createLoginState, buildLoginActions };

package/auth/LoginState/index.js

@@ -1,142 +1,3 @@
-import { createAction } from '@reduxjs/toolkit';
-import { LoginFlow, LoginStep } from './interfaces';
-import { resetStateByKey, typeReducerForKey } from '../utils';
-import { authStoreName } from '../../constants';
-const loginState = {
-  flow: LoginFlow.Login,
-  step: LoginStep.preLogin,
-  loading: false,
-  email: '',
-  tenants: []
-};
-const reducers = {
-  setLoginState: typeReducerForKey('loginState'),
-  resetLoginState: resetStateByKey('loginState', {
-    loginState
-  })
-};
-const actions = {
-  requestAuthorize: createAction(`${authStoreName}/requestAuthorize`, (payload = false) => ({
-    payload
-  })),
-  requestAuthorizeSSR: createAction(`${authStoreName}/requestAuthorizeSSR`, payload => ({
-    payload
-  })),
-  requestHostedLoginAuthorize: createAction(`${authStoreName}/requestHostedLoginAuthorize`, payload => ({
-    payload
-  })),
-  requestHostedLoginAuthorizeV2: createAction(`${authStoreName}/requestHostedLoginAuthorizeV2`, payload => ({
-    payload
-  })),
-  handleHostedLoginCallback: createAction(`${authStoreName}/handleHostedLoginCallback`, payload => ({
-    payload
-  })),
-  afterAuthNavigation: createAction(`${authStoreName}/afterAuthNavigation`),
-  preLogin: createAction(`${authStoreName}/preLogin`, payload => ({
-    payload
-  })),
-  postLogin: createAction(`${authStoreName}/postLogin`, payload => ({
-    payload
-  })),
-  login: createAction(`${authStoreName}/login`, payload => ({
-    payload
-  })),
-  loginWithMfa: createAction(`${authStoreName}/loginWithMfa`, payload => ({
-    payload
-  })),
-  recoverMfa: createAction(`${authStoreName}/recoverMfa`, payload => ({
-    payload
-  })),
-  logout: createAction(`${authStoreName}/logout`, payload => ({
-    payload
-  })),
-  silentLogout: createAction(`${authStoreName}/silentLogout`, payload => ({
-    payload
-  })),
-  checkIfAllowToRememberMfaDevice: createAction(`${authStoreName}/checkIfAllowToRememberMfaDevice`, payload => ({
-    payload
-  })),
-  changePhoneNumberWithVerification: createAction(`${authStoreName}/changePhoneNumberWithVerification`, payload => ({
-    payload
-  })),
-  verifyChangePhoneNumber: createAction(`${authStoreName}/verifyChangePhoneNumber`, payload => ({
-    payload
-  })),
-  quickSmsPasswordlessPreLogin: createAction(`${authStoreName}/quickSmsPasswordlessPreLogin`, payload => ({
-    payload
-  })),
-  passwordlessPreLogin: createAction(`${authStoreName}/passwordlessPreLogin`, payload => ({
-    payload
-  })),
-  passwordlessPostLogin: createAction(`${authStoreName}/passwordlessPostLogin`, payload => ({
-    payload
-  })),
-  verifyInviteToken: createAction(`${authStoreName}/verifyInviteToken`, payload => ({
-    payload
-  })),
-  webAuthnPrelogin: createAction(`${authStoreName}/webAuthnPrelogin`, payload => ({
-    payload
-  })),
-  webAuthnPostLogin: createAction(`${authStoreName}/webAuthnPostLogin`, payload => ({
-    payload
-  })),
-  webAuthnCreateNewDeviceSession: createAction(`${authStoreName}/webAuthnCreateNewDeviceSession`, payload => ({
-    payload
-  })),
-  webAuthnVerifyNewDeviceSession: createAction(`${authStoreName}/webAuthnVerifyNewDeviceSession`, payload => ({
-    payload
-  })),
-  getUserIP: createAction(`${authStoreName}/getUserIP`, payload => ({
-    payload
-  })),
-  preEnrollMFAWebAuthnForLogin: createAction(`${authStoreName}/preEnrollWebAuthNForLogin`, payload => ({
-    payload
-  })),
-  enrollMFAWebAuthnForLogin: createAction(`${authStoreName}/enrollWebAuthNForLogin`, payload => ({
-    payload
-  })),
-  enrollMFAAuthenticatorAppForLogin: createAction(`${authStoreName}/enrollMFAAuthenticatorAppForLogin`, payload => ({
-    payload
-  })),
-  preEnrollMFASMSForLogin: createAction(`${authStoreName}/preEnrollMFASMSForLogin`, payload => ({
-    payload
-  })),
-  enrollMFASMSForLogin: createAction(`${authStoreName}/enrollMFASMSForLogin`, payload => ({
-    payload
-  })),
-  preVerifyMFAWebAuthnForLogin: createAction(`${authStoreName}/preVerifyMFAWebAuthnForLogin`, payload => ({
-    payload
-  })),
-  verifyMFAWebAuthnForLogin: createAction(`${authStoreName}/verifyMFAWebAuthnForLogin`, payload => ({
-    payload
-  })),
-  preVerifyMFASMSForLogin: createAction(`${authStoreName}/preVerifyMFASMSForLogin`, payload => ({
-    payload
-  })),
-  verifyMFASMSForLogin: createAction(`${authStoreName}/verifyMFASMSForLogin`, payload => ({
-    payload
-  })),
-  preVerifyMFAEmailCode: createAction(`${authStoreName}/preVerifyMFAEmailCode`, payload => ({
-    payload
-  })),
-  verifyMFAEmailCode: createAction(`${authStoreName}/verifyMFAEmailCode`, payload => ({
-    payload
-  })),
-  resetBreachedPassword: createAction(`${authStoreName}/resetBreachedPassword`, payload => ({
-    payload
-  }))
-};
-
-/**
- *  To be used for actions types after dispatch, and should contains
- *  the reducers and actions as standalone function
- */
-
-// noinspection JSUnusedLocalSymbols
-/**
- *  if you see error in matcher that's mean the DispatchAction does not
- *  contains the same functions in reducers and actions
- */
-const Matcher = {};
-export { loginState, reducers as loginReducers, actions as loginActions };
-export { getRedirectUrl } from './utils';
+import createLoginState from './state';
+import buildLoginActions from './actions';
+export { createLoginState, buildLoginActions };

package/auth/LoginState/interfaces.d.ts

@@ -82,9 +82,12 @@ export interface IPreVerifyMFAWebAuthNForLoginResponse {
     webauthnToken: string;
     options: PublicKeyCredentialRequestOptions;
 }
-export declare type WithDeviceId<T> = T & {
+export declare type WithDeviceId<T = {}> = T & {
     deviceId: string;
 };
+export declare type WithPhoneId<T> = T & {
+    phoneId: string;
+};
 export declare type IEnrollMFAWebAuthnPayload = WithCallback<Omit<IEnrollMFAWebAuthn, 'options'>> & {
     publicKey: Credential;
 };
@@ -94,3 +97,28 @@ export declare type IVerifyMFAWebAuthnPayload = WithCallback<WithDeviceId<Omit<I
 export interface IRecoverMFATokenPayload extends WithCallback<IRecoverMFAToken> {
     recaptchaToken?: string;
 }
+/**
+ * Type for action to set the loading state
+ * @param options.loading - true if in loading state
+ * @param options.error - error if in error state
+ */
+export declare type SetLoadingAction = ({ loading, error }: {
+    loading?: boolean;
+    error?: unknown;
+}) => void;
+export declare enum LoginActionTypes {
+    'social-login' = "social-login",
+    'custom-social-login' = "custom-social-login",
+    'direct' = "direct"
+}
+export interface LoginDirectAction {
+    type: keyof typeof LoginActionTypes;
+    data: any;
+    additionalQueryParams?: Record<string, string>;
+}
+export interface AfterAuthNavigationUtilOptions {
+    customLoginAuthenticatedUrl?: string;
+    forceStepUpUrl?: string;
+    shouldStepUpDuringLogin?: boolean;
+    preventRedirectUrlOriginCleaning?: boolean;
+}

package/auth/LoginState/interfaces.js

@@ -29,4 +29,10 @@ export let QuickLoginStrategy;
   QuickLoginStrategy["Android"] = "android";
   QuickLoginStrategy["Sms"] = "sms";
 })(QuickLoginStrategy || (QuickLoginStrategy = {}));
-export { AuthStrategyEnum };
+export { AuthStrategyEnum };
+export let LoginActionTypes;
+(function (LoginActionTypes) {
+  LoginActionTypes["social-login"] = "social-login";
+  LoginActionTypes["custom-social-login"] = "custom-social-login";
+  LoginActionTypes["direct"] = "direct";
+})(LoginActionTypes || (LoginActionTypes = {}));

package/auth/LoginState/state.d.ts

@@ -0,0 +1,4 @@
+import { LoginState } from './interfaces';
+export declare const initialState: LoginState;
+declare const _default: (overrideState?: Partial<LoginState> | undefined) => LoginState;
+export default _default;

package/auth/LoginState/state.js

@@ -0,0 +1,10 @@
+import { LoginFlow, LoginStep } from './interfaces';
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  flow: LoginFlow.Login,
+  step: LoginStep.preLogin,
+  loading: false,
+  email: '',
+  tenants: []
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/MSP/actions.d.ts

@@ -0,0 +1,28 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { AllAccountsStateIndicator, IAllAccountsState, IAllAccountsStateActionsPayloads } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setAllAccountsLoader: (payload: AllAccountsStateIndicator) => void;
+    setAllAccountsError: (payload: AllAccountsStateIndicator) => void;
+    setAllAccountsState: (state: Partial<IAllAccountsState>) => void;
+    setSelectedAccountState: (payload: Partial<IAllAccountsState['selectedAccount']>) => void;
+    resetAllAccountsState: () => void;
+    clearSelectedAccount: () => void;
+    loadAccounts: (payload: IAllAccountsStateActionsPayloads['loadAccounts']) => Promise<void>;
+    searchAccounts: (payload: IAllAccountsStateActionsPayloads['searchAccounts']) => Promise<void>;
+    updateSubAccountAccessForUser: (payload: IAllAccountsStateActionsPayloads['updateSubAccountAccessForUser']) => Promise<void>;
+    createSubAccount: (payload: IAllAccountsStateActionsPayloads['createSubAccount']) => Promise<void>;
+    updateSubAccount: (payload: IAllAccountsStateActionsPayloads['updateSubAccount']) => Promise<void>;
+    deleteSubAccount: (payload: IAllAccountsStateActionsPayloads['deleteSubAccount']) => Promise<void>;
+    updateSubAccountSettings: (payload: IAllAccountsStateActionsPayloads['updateSubAccountSettings']) => Promise<void>;
+    updateSubAccountManagement: (payload: IAllAccountsStateActionsPayloads['updateSubAccountManagement']) => Promise<void>;
+    updateSubAccountHierarchySettings: (payload: IAllAccountsStateActionsPayloads['updateSubAccountHierarchySettings']) => Promise<void>;
+    addUsersToAccount: (payload: IAllAccountsStateActionsPayloads['addUsersToAccount']) => Promise<void>;
+    getAccountUsers: (payload: IAllAccountsStateActionsPayloads['getAccountUsers']) => Promise<void>;
+    deleteUsersFromAccount: (payload: IAllAccountsStateActionsPayloads['deleteUsersFromAccount']) => Promise<void>;
+    setUserRolesForSubAccount: (payload: IAllAccountsStateActionsPayloads['setUserRolesForSubAccount']) => Promise<void>;
+    getUserJwtForSubAccount: (payload: IAllAccountsStateActionsPayloads['getUserJwtForSubAccount']) => Promise<void>;
+    setRootAccountData: () => Promise<void>;
+    setSelectedSubAccountData: (payload: IAllAccountsStateActionsPayloads['setSelectedSubAccountData']) => Promise<void>;
+    loadNumberOfUsersForSelectedSubAccount: (payload: IAllAccountsStateActionsPayloads['loadNumberOfUsersForSelectedSubAccount']) => Promise<void>;
+};
+export default _default;