@frontegg/redux-store 7.0.0-alpha.2 → 7.0.0-alpha.3

package/auth/ApplicationsState/actions.d.ts

@@ -0,0 +1,25 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { ApplicationsState, UserAppsAssignmentPayload } from './interfaces';
+import { IApplicationsResponse, ITeamUser } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setApplicationsState: (payload: Partial<ApplicationsState>) => void;
+    resetApplicationsState: () => void;
+    loadUserApplications: () => Promise<void>;
+    loadAccountApplications: () => Promise<void>;
+    loadMultipleUsersApplications: ({ userIds }: {
+        userIds: string[];
+    }) => Promise<Record<string, IApplicationsResponse[]> | undefined>;
+    assignUserToApps: (payload: WithCallback<UserAppsAssignmentPayload>) => Promise<void>;
+    unassignUserFromApps: (payload: WithCallback<UserAppsAssignmentPayload>) => Promise<void>;
+    assignNewUserToApps: ({ appIds, user }: {
+        appIds?: string[] | undefined;
+        user: ITeamUser;
+    }) => Promise<((IApplicationsResponse & {
+        userIds?: string[] | undefined;
+    }) | never[])[] | undefined>;
+    mapUsersWithApplicationData: ({ shouldLoadApps, users, }: {
+        shouldLoadApps?: boolean | undefined;
+        users: ITeamUser[];
+    }) => Promise<ITeamUser[]>;
+};
+export default _default;

package/auth/ApplicationsState/actions.js

@@ -0,0 +1,221 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { ApplicationAccessType } from '@frontegg/rest-api';
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+import { getFlattenAppIds } from './helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setApplicationsState = payload => {
+    Object.assign(store.auth.applicationsState, payload);
+  };
+  const resetApplicationsState = () => {
+    store.auth.applicationsState = deepClone(initialState);
+  };
+  const loadUserApplications = async () => {
+    setApplicationsState({
+      loading: true,
+      fetching: true
+    });
+    try {
+      var _store$auth$user$id, _store$auth$user;
+      const userId = (_store$auth$user$id = (_store$auth$user = store.auth.user) == null ? void 0 : _store$auth$user.id) != null ? _store$auth$user$id : '';
+      const appIds = await api.applications.getUserApplicationsId({
+        userId
+      });
+      const userApplications = await api.applications.getApplicationsData({
+        appIds
+      });
+      setApplicationsState({
+        userApplications,
+        fetching: false,
+        loading: false
+      });
+    } catch (e) {
+      setApplicationsState({
+        loading: false,
+        fetching: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  const loadAccountApplications = async () => {
+    setApplicationsState({
+      loading: true,
+      fetching: true
+    });
+    try {
+      const tenantAppIds = await api.applications.getTenantsApplications();
+      const appIds = getFlattenAppIds(tenantAppIds);
+      const accountApplications = await api.applications.getApplicationsData({
+        appIds
+      });
+      const usersOfApplications = await api.applications.getUsersOfApplications({
+        appIds
+      });
+      const accountApplicationsWithUsers = accountApplications.map(app => {
+        var _usersOfApplications$;
+        return _extends({}, app, {
+          userIds: (_usersOfApplications$ = usersOfApplications.find(u => u.appId === app.id)) == null ? void 0 : _usersOfApplications$.userIds
+        });
+      });
+      setApplicationsState({
+        accountApplications: accountApplicationsWithUsers,
+        fetching: false,
+        loading: false
+      });
+    } catch (e) {
+      setApplicationsState({
+        loading: false,
+        fetching: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  const loadMultipleUsersApplications = async ({
+    userIds
+  }) => {
+    try {
+      const usersAppIds = await api.applications.getUsersApplicationsId({
+        userIds
+      });
+      const appIds = getFlattenAppIds(usersAppIds);
+      const accountApplications = await api.applications.getApplicationsData({
+        appIds
+      });
+      return userIds.reduce((acc, userId) => {
+        var _usersAppIds$find, _userAppIds$map$filte, _userAppIds$map;
+        const userAppIds = (_usersAppIds$find = usersAppIds.find(app => app.userId == userId)) == null ? void 0 : _usersAppIds$find.appIds;
+        acc[userId] = [...accountApplications.filter(app => app.accessType === ApplicationAccessType.FREE_ACCESS), ...((_userAppIds$map$filte = userAppIds == null ? void 0 : (_userAppIds$map = userAppIds.map(appId => accountApplications.find(app => appId === app.id))) == null ? void 0 : _userAppIds$map.filter(app => !!app)) != null ? _userAppIds$map$filte : [])];
+        return acc;
+      }, {});
+    } catch (e) {
+      setApplicationsState({
+        error: errorHandler(e)
+      });
+    }
+  };
+  const ASSIGNMENT_DEFAULT_ERROR_MESSAGE = 'Assignment action failed. Try again or contact support.';
+  const assignUserToApps = async payload => {
+    const {
+      userId,
+      appIds,
+      callback
+    } = payload;
+    try {
+      var _store$auth$user$tena, _store$auth, _store$auth$user2, _store$auth2, _store$auth2$applicat, _store$auth$teamState, _store$auth3, _store$auth3$teamStat, _accountApps$filter;
+      const tenantId = (_store$auth$user$tena = (_store$auth = store.auth) == null ? void 0 : (_store$auth$user2 = _store$auth.user) == null ? void 0 : _store$auth$user2.tenantId) != null ? _store$auth$user$tena : '';
+      await api.applications.assignUserToApplications({
+        userId,
+        appIds,
+        tenantId
+      });
+      const accountApps = (_store$auth2 = store.auth) == null ? void 0 : (_store$auth2$applicat = _store$auth2.applicationsState) == null ? void 0 : _store$auth2$applicat.accountApplications;
+      const users = (_store$auth$teamState = (_store$auth3 = store.auth) == null ? void 0 : (_store$auth3$teamStat = _store$auth3.teamState) == null ? void 0 : _store$auth3$teamStat.users) != null ? _store$auth$teamState : [];
+      const newApps = (_accountApps$filter = accountApps == null ? void 0 : accountApps.filter(app => appIds.includes(app.id))) != null ? _accountApps$filter : [];
+      if (newApps != null && newApps.length) {
+        sharedActions.setTeamState({
+          users: users.map(user => {
+            var _user$applications;
+            return user.id === userId ? _extends({}, user, {
+              applications: [...((_user$applications = user.applications) != null ? _user$applications : []), ...newApps]
+            }) : user;
+          })
+        });
+      }
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setApplicationsState({
+        error: errorHandler(e, ASSIGNMENT_DEFAULT_ERROR_MESSAGE)
+      });
+      callback == null ? void 0 : callback(false);
+    }
+  };
+  const unassignUserFromApps = async payload => {
+    const {
+      userId,
+      appIds,
+      callback
+    } = payload;
+    try {
+      var _store$auth$user$tena2, _store$auth4, _store$auth4$user, _store$auth$teamState2, _store$auth5, _store$auth5$teamStat, _users$find;
+      const tenantId = (_store$auth$user$tena2 = (_store$auth4 = store.auth) == null ? void 0 : (_store$auth4$user = _store$auth4.user) == null ? void 0 : _store$auth4$user.tenantId) != null ? _store$auth$user$tena2 : '';
+      await api.applications.unassignUserFromApplications({
+        userId,
+        appIds,
+        tenantId
+      });
+      const users = (_store$auth$teamState2 = (_store$auth5 = store.auth) == null ? void 0 : (_store$auth5$teamStat = _store$auth5.teamState) == null ? void 0 : _store$auth5$teamStat.users) != null ? _store$auth$teamState2 : [];
+      const userApps = (_users$find = users.find(user => user.id === userId)) == null ? void 0 : _users$find.applications;
+      if (userApps != null && userApps.length && appIds.length) {
+        sharedActions.setTeamState({
+          users: users.map(user => user.id === userId ? _extends({}, user, {
+            applications: userApps.filter(app => !appIds.includes(app.id))
+          }) : user)
+        });
+      }
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setApplicationsState({
+        error: errorHandler(e, ASSIGNMENT_DEFAULT_ERROR_MESSAGE)
+      });
+      callback == null ? void 0 : callback(false);
+    }
+  };
+  const assignNewUserToApps = async ({
+    appIds,
+    user
+  }) => {
+    var _store$auth6, _store$auth6$applicat, _apps$filter;
+    const [multiAppsFlag] = sharedActions.__getFeatureFlags(['multi-apps-admin-portal']);
+    if (!multiAppsFlag) {
+      return;
+    }
+    const apps = (_store$auth6 = store.auth) == null ? void 0 : (_store$auth6$applicat = _store$auth6.applicationsState) == null ? void 0 : _store$auth6$applicat.accountApplications;
+    const defaultApps = (_apps$filter = apps == null ? void 0 : apps.filter(app => app.accessType === ApplicationAccessType.FREE_ACCESS)) != null ? _apps$filter : [];
+    if (appIds != null && appIds.length) {
+      var _store$auth$user$tena3, _store$auth7, _store$auth7$user;
+      const tenantId = (_store$auth$user$tena3 = (_store$auth7 = store.auth) == null ? void 0 : (_store$auth7$user = _store$auth7.user) == null ? void 0 : _store$auth7$user.tenantId) != null ? _store$auth$user$tena3 : '';
+      await api.applications.assignUserToApplications({
+        userId: user.id,
+        appIds,
+        tenantId
+      });
+      return appIds.map(appId => {
+        var _apps$find;
+        return (_apps$find = apps == null ? void 0 : apps.find(app => app.id === appId)) != null ? _apps$find : [];
+      }).concat(defaultApps);
+    } else {
+      return defaultApps;
+    }
+  };
+  const mapUsersWithApplicationData = async ({
+    shouldLoadApps,
+    users
+  }) => {
+    const [multiAppsFlag] = sharedActions.__getFeatureFlags(['multi-apps-admin-portal']);
+    if (!multiAppsFlag || !shouldLoadApps) {
+      return users;
+    }
+    const userIds = users.map(user => user.id);
+    const userApps = await loadMultipleUsersApplications({
+      userIds
+    });
+    if (!userApps) {
+      return users;
+    }
+    return users.map(user => userApps != null && userApps[user.id] ? _extends({}, user, {
+      applications: userApps[user.id]
+    }) : user);
+  };
+  return {
+    setApplicationsState,
+    resetApplicationsState,
+    loadUserApplications,
+    loadAccountApplications,
+    loadMultipleUsersApplications,
+    assignUserToApps,
+    unassignUserFromApps,
+    assignNewUserToApps,
+    mapUsersWithApplicationData
+  };
+});

package/auth/ApplicationsState/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare const getFlattenAppIds: <T extends {
+    appIds?: string[] | undefined;
+}>(listWithAppIds: T[]) => string[];

package/auth/ApplicationsState/helpers.js

@@ -0,0 +1,13 @@
+export const getFlattenAppIds = listWithAppIds => {
+  var _listWithAppIds$map$r;
+  return (_listWithAppIds$map$r = listWithAppIds.map(({
+    appIds
+  }) => appIds).reduce((allAppIds, currentAppIds) => {
+    currentAppIds == null ? void 0 : currentAppIds.forEach(item => {
+      if (allAppIds && !allAppIds.includes(item)) {
+        allAppIds.push(item);
+      }
+    });
+    return allAppIds;
+  }, [])) != null ? _listWithAppIds$map$r : [];
+};

package/auth/ApplicationsState/index.d.ts

@@ -0,0 +1,3 @@
+import createApplicationsState from './state';
+import buildApplicationsActions from './actions';
+export { createApplicationsState, buildApplicationsActions };

package/auth/ApplicationsState/index.js

@@ -0,0 +1,3 @@
+import createApplicationsState from './state';
+import buildApplicationsActions from './actions';
+export { createApplicationsState, buildApplicationsActions };

package/auth/ApplicationsState/interfaces.d.ts

@@ -0,0 +1,12 @@
+import { IApplicationsResponse, IAssignUserToApplicationsBody } from '@frontegg/rest-api';
+export interface ApplicationsState {
+    error?: string | null;
+    fetching?: boolean;
+    loading?: boolean;
+    saving?: boolean;
+    userApplications?: IApplicationsResponse[];
+    accountApplications?: (IApplicationsResponse & {
+        userIds?: string[];
+    })[];
+}
+export declare type UserAppsAssignmentPayload = Pick<IAssignUserToApplicationsBody, 'userId' | 'appIds'>;

package/auth/ApplicationsState/interfaces.js

@@ -0,0 +1 @@
+export {};

package/auth/ApplicationsState/state.d.ts

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

package/auth/ApplicationsState/state.js

@@ -0,0 +1,9 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: true,
+  fetching: true,
+  error: null,
+  userApplications: [],
+  accountApplications: []
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/Entitlements/actions.js

@@ -1,5 +1,4 @@
 import { isEntitlementsDeeplyEqual } from './helpers';
-import { USE_ENTITLEMENTS_V2_ENDPOINT_FF } from '@frontegg/rest-api';
 export default ((store, api, sharedActions) => {
   const actions = sharedActions;
   const setEntitlements = entitlements => {
@@ -25,10 +24,8 @@ export default ((store, api, sharedActions) => {
    */
   const loadEntitlements = async payload => {
     const callback = payload == null ? void 0 : payload.callback;
-    const [useEntitlementsV2] = await actions.__getFeatureFlags([USE_ENTITLEMENTS_V2_ENDPOINT_FF]);
     try {
-      // @ts-ignore // TODO: fix type UserEntitlementsResponseV2
-      const entitlements = await (useEntitlementsV2 ? api.entitlements.loadEntitlementsV2() : api.entitlements.loadEntitlements());
+      const entitlements = await api.entitlements.loadEntitlementsV2();
       handleFetchedEntitlements(entitlements);
       callback == null ? void 0 : callback(true);
     } catch (e) {

package/auth/Entitlements/helpers.d.ts

@@ -1,34 +1,33 @@
-import { UserEntitlementsResponse } from '@frontegg/rest-api';
 import { EntitledToOptions, Entitlement } from './interfaces';
 import type { UserEntitlementsContext as UserEntitlementsResponseV2 } from '@frontegg/entitlements-javascript-commons';
 import type { Attributes } from '@frontegg/entitlements-javascript-commons';
 /**
- @param entitlements
- @param key permission key
- @param attributes entitlements query attributes including comnsumer and frontegg attributes
- @param isV2 true when need to use entitlements API V2
- @returns if the user is entitled to the given permission. Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
+  @param entitlements
+  @param key permission key
+  @param attributes entitlements query attributes including consumer and frontegg attributes
+  @param isV2 not in use. should be removed after removing from frontegg-vue
+  @returns if the user is entitled to the given permission. Attaching the justification if not
+  @throws when entitlement is not enabled via frontegg options
  */
-export declare const getPermissionEntitlements: (entitlements: UserEntitlementsResponseV2 | UserEntitlementsResponse | undefined, key: string, attributes?: Attributes | undefined, isV2?: boolean | undefined) => Entitlement;
+export declare const getPermissionEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, key: string, attributes?: Attributes | undefined, isV2?: boolean | undefined) => Entitlement;
 /**
- @param entitlements
- @param key feature key
- @param attributes entitlements query attributes including comnsumer and frontegg attributes
- @param isV2 true when need to use entitlements API V2
- @returns if the user is entitled to the given feature. Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
+  @param entitlements
+  @param key feature key
+  @param attributes entitlements query attributes including consumer and frontegg attributes
+  @param isV2 not in use. should be removed after removing from frontegg-vue
+  @returns if the user is entitled to the given feature. Attaching the justification if not
+  @throws when entitlement is not enabled via frontegg options
  */
-export declare const getFeatureEntitlements: (entitlements: UserEntitlementsResponseV2 | UserEntitlementsResponse | undefined, key: string, attributes?: Attributes | undefined, isV2?: boolean | undefined) => Entitlement;
+export declare const getFeatureEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, key: string, attributes?: Attributes | undefined, isV2?: boolean | undefined) => Entitlement;
 /**
- @param entitlements
- @param options including permission or feature
- @param attributes entitlements query attributes including comnsumer and frontegg attributes
- @param isV2 true when need to use entitlements API V2
- @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
+  @param entitlements
+  @param options including permission or feature
+  @param attributes entitlements query attributes including consumer and frontegg attributes
+  @param isV2 not in use. should be removed after removing from frontegg-vue
+  @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
+  @throws when entitlement is not enabled via frontegg options
  */
-export declare const getEntitlements: (entitlements: UserEntitlementsResponseV2 | UserEntitlementsResponse | undefined, options: EntitledToOptions, attributes?: Attributes | undefined, isV2?: boolean | undefined) => Entitlement;
+export declare const getEntitlements: (entitlements: UserEntitlementsResponseV2 | undefined, options: EntitledToOptions, attributes?: Attributes | undefined, isV2?: boolean | undefined) => Entitlement;
 /**
  * @param oldEntitlements
  * @param newEntitlements

package/auth/Entitlements/helpers.js

@@ -1,17 +1,6 @@
-import { NotEntitledJustification, ContextHolder } from '@frontegg/rest-api';
+import { ContextHolder } from '@frontegg/rest-api';
 import isEqual from 'fast-deep-equal';
 import { evaluateIsEntitledToFeature, evaluateIsEntitledToPermissions } from '@frontegg/entitlements-javascript-commons';
-/**
- * NOTE: This file including the usage of user entitlements API V1 and V2. The BE API response is diffrent.
- * V1 is the initial implementation.
- * V2 is using the entitlenents package for Rule Based entitlements.
- *
- * V1 is still supported with feature flag but it's depracated.
- *
- * The entitlements query functions supports both APIs by an optional argument of [isV2] to decide what version to choose.
- * The function returns the same type.
- */
-
 const ENTITLEMENTS_NOT_ENABLED_EXCEPTION_TEXT = 'You must first enable entitlements via Frontegg options to use this function';
 
 /**
@@ -24,78 +13,44 @@ const guardEntitlementsUsage = () => {
 };
 
 /**
- For user entitlements API V1
-
- @param keyEntitlements permission or feature data object
- @param missingKeyEnum missing key for scenario that the key does not exist in entitlementsValuePerKeys
- @returns if the user is entitled to the given key. Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
- */
-const getEntitlementsHelperV1 = (keyEntitlements, missingKeyEnum) => {
-  if (!keyEntitlements) {
-    return {
-      isEntitled: false,
-      justification: missingKeyEnum
-    };
-  }
-  if (keyEntitlements.isEntitled) {
-    return {
-      isEntitled: true
-    };
-  }
-  return {
-    isEntitled: false,
-    justification: keyEntitlements.justification
-  };
-};
-
-/**
- @param entitlements
- @param key permission key
- @param attributes entitlements query attributes including comnsumer and frontegg attributes
- @param isV2 true when need to use entitlements API V2
- @returns if the user is entitled to the given permission. Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
+  @param entitlements
+  @param key permission key
+  @param attributes entitlements query attributes including consumer and frontegg attributes
+  @param isV2 not in use. should be removed after removing from frontegg-vue
+  @returns if the user is entitled to the given permission. Attaching the justification if not
+  @throws when entitlement is not enabled via frontegg options
  */
 export const getPermissionEntitlements = (entitlements, key, attributes, isV2) => {
-  var _permissions;
   guardEntitlementsUsage();
-  if (isV2) {
-    return evaluateIsEntitledToPermissions(key, entitlements, attributes);
-  }
-  return getEntitlementsHelperV1(entitlements == null ? void 0 : (_permissions = entitlements.permissions) == null ? void 0 : _permissions[key], NotEntitledJustification.MISSING_PERMISSION);
+  return evaluateIsEntitledToPermissions(key, entitlements, attributes);
 };
 
 /**
- @param entitlements
- @param key feature key
- @param attributes entitlements query attributes including comnsumer and frontegg attributes
- @param isV2 true when need to use entitlements API V2
- @returns if the user is entitled to the given feature. Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
+  @param entitlements
+  @param key feature key
+  @param attributes entitlements query attributes including consumer and frontegg attributes
+  @param isV2 not in use. should be removed after removing from frontegg-vue
+  @returns if the user is entitled to the given feature. Attaching the justification if not
+  @throws when entitlement is not enabled via frontegg options
  */
 export const getFeatureEntitlements = (entitlements, key, attributes, isV2) => {
-  var _features;
   guardEntitlementsUsage();
-  if (isV2) {
-    return evaluateIsEntitledToFeature(key, entitlements, attributes);
-  }
-  return getEntitlementsHelperV1(entitlements == null ? void 0 : (_features = entitlements.features) == null ? void 0 : _features[key], NotEntitledJustification.MISSING_FEATURE);
+  return evaluateIsEntitledToFeature(key, entitlements, attributes);
 };
 
 /**
- @param entitlements
- @param options including permission or feature
- @param attributes entitlements query attributes including comnsumer and frontegg attributes
- @param isV2 true when need to use entitlements API V2
- @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
- @throws when entitlement is not enabled via frontegg options
+  @param entitlements
+  @param options including permission or feature
+  @param attributes entitlements query attributes including consumer and frontegg attributes
+  @param isV2 not in use. should be removed after removing from frontegg-vue
+  @returns if the user is entitled to the given feature or permission (check only one). Attaching the justification if not
+  @throws when entitlement is not enabled via frontegg options
  */
 export const getEntitlements = (entitlements, options, attributes, isV2) => {
   if ('permissionKey' in options) {
-    return getPermissionEntitlements(entitlements, options.permissionKey, attributes, isV2);
+    return getPermissionEntitlements(entitlements, options.permissionKey, attributes);
   }
-  return getFeatureEntitlements(entitlements, options.featureKey, attributes, isV2);
+  return getFeatureEntitlements(entitlements, options.featureKey, attributes);
 };
 
 /**

package/auth/ImpersonateState/actions.js

@@ -28,7 +28,13 @@ export default ((store, api, sharedActions) => {
         step: ImpersonateStep.success
       });
       await delay(1000);
-      await actions.afterAuthNavigation();
+      /**
+       * We want to avoid cleaning the origin of the redirect URL
+       * because we want to refresh the page and redirect to the same origin on embedded mode
+       */
+      await actions.afterAuthNavigation({
+        preventRedirectUrlOriginCleaning: true
+      });
       resetImpersonateState();
       callback == null ? void 0 : callback(true);
     } catch (e) {

package/auth/LoginState/actions/afterAuthNavigation.actions.d.ts

@@ -4,7 +4,7 @@ import { AfterAuthNavigationUtilOptions } from '../interfaces';
 import { AuthState } from '../../interfaces';
 declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
     afterAuthNavigationUtil: (resetStateAction: (() => void) | (() => Promise<void>), options?: AfterAuthNavigationUtilOptions) => Promise<void>;
-    afterAuthNavigation: () => Promise<void>;
+    afterAuthNavigation: (payload?: Pick<AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning"> | undefined) => Promise<void>;
     afterStepUpAuthNavigation: () => Promise<void>;
     __afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: ILoginResponseV3, additionalUpdate?: Partial<AuthState>) => Promise<void>;
 };

package/auth/LoginState/actions/afterAuthNavigation.actions.js

@@ -10,9 +10,11 @@ export default ((store, api, sharedActions) => {
   /**
    * @param url
    * @returns url without the origin if it's the same origin as the current window origin
-   * @private
+   * @deprecated
+   * Don't use this unless you must
+   * In case the url is equal to the window.location.origin, it will return an empty string
    */
-  function __cleanUrlIfSameOrigin(url) {
+  function cleanUrlIfSameOrigin(url) {
     var _window, _window2;
     if (!url.startsWith((_window = window) == null ? void 0 : _window.location.origin)) {
       return url;
@@ -48,7 +50,10 @@ export default ((store, api, sharedActions) => {
    * @param customLoginAuthenticatedUrl custom login authenticated url if exists
    * @returns the authenticated url to redirect to after auth navigation
    */
-  async function __getUrlForAfterAuthNavigation(customLoginAuthenticatedUrl) {
+  async function __getUrlForAfterAuthNavigation({
+    customLoginAuthenticatedUrl,
+    preventRedirectUrlOriginCleaning
+  }) {
     const {
       routes,
       includeQueryParam = false,
@@ -75,9 +80,11 @@ export default ((store, api, sharedActions) => {
       enforceRedirectToSameSite,
       allowedRedirectOrigins
     });
-
+    if (preventRedirectUrlOriginCleaning) {
+      return redirectUrl;
+    }
     // clean origin if it's the same origin as the current window origin to avoid refresh in afterAuthNavigationUtil
-    return __cleanUrlIfSameOrigin(redirectUrl);
+    return cleanUrlIfSameOrigin(redirectUrl);
   }
 
   /**
@@ -89,7 +96,8 @@ export default ((store, api, sharedActions) => {
     const {
       customLoginAuthenticatedUrl,
       forceStepUpUrl,
-      shouldStepUpDuringLogin
+      shouldStepUpDuringLogin,
+      preventRedirectUrlOriginCleaning = false
     } = options;
 
     // TODO: change to store.root.onRedirectTo
@@ -110,7 +118,10 @@ export default ((store, api, sharedActions) => {
         }
       }
       if (!redirectUrl) {
-        redirectUrl = await __getUrlForAfterAuthNavigation(customLoginAuthenticatedUrl);
+        redirectUrl = await __getUrlForAfterAuthNavigation({
+          customLoginAuthenticatedUrl,
+          preventRedirectUrlOriginCleaning
+        });
       }
       (_window3 = window) == null ? void 0 : _window3.localStorage.removeItem(FRONTEGG_AFTER_AUTH_REDIRECT_URL);
     }
@@ -125,8 +136,8 @@ export default ((store, api, sharedActions) => {
    * After auth navigation for login flow
    * Handling also step up scenario when user silently logout to continue to step up
    */
-  const afterAuthNavigation = async () => {
-    var _window4;
+  const afterAuthNavigation = async payload => {
+    var _window4, _payload$preventRedir;
     const {
       customLoginAuthenticatedUrl,
       stepUpUrl
@@ -152,7 +163,8 @@ export default ((store, api, sharedActions) => {
     }
     return afterAuthNavigationUtil(actions.resetLoginState, {
       customLoginAuthenticatedUrl: customLoginURL,
-      shouldStepUpDuringLogin: !!shouldStepUp
+      shouldStepUpDuringLogin: !!shouldStepUp,
+      preventRedirectUrlOriginCleaning: (_payload$preventRedir = payload == null ? void 0 : payload.preventRedirectUrlOriginCleaning) != null ? _payload$preventRedir : false
     });
   };
 

package/auth/LoginState/actions/hostedLoginAuthorize.actions.d.ts

@@ -8,6 +8,7 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
         firstTime?: boolean | undefined;
         loginDirectAction?: LoginDirectAction | undefined;
     } | undefined) => Promise<void>;
+    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
     __requestHostedLoginSilentAuthorize: () => Promise<void>;
     handleHostedLoginCallback: (payload: HostedLoginCallback) => Promise<void>;
 };

package/auth/LoginState/actions/hostedLoginAuthorize.actions.js

@@ -194,6 +194,7 @@ export default ((store, api, sharedActions) => {
   return {
     requestHostedLoginAuthorize: refreshOrRequestHostedLoginAuthorize,
     requestHostedLoginAuthorizeV2: refreshOrRequestHostedLoginAuthorizeV2,
+    __requestHostedLoginAuthorize: requestHostedLoginAuthorize,
     __requestHostedLoginSilentAuthorize,
     handleHostedLoginCallback
   };

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

@@ -27,7 +27,7 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
     handleVerifyMFAResponse: (payload: ILoginResponseV3, isStepUp?: boolean) => Promise<void>;
     __getFeatureFlags: (flags: string[]) => Promise<boolean[]>;
     afterAuthNavigationUtil: (resetStateAction: (() => void) | (() => Promise<void>), options?: import("../interfaces").AfterAuthNavigationUtilOptions) => Promise<void>;
-    afterAuthNavigation: () => Promise<void>;
+    afterAuthNavigation: (payload?: Pick<import("../interfaces").AfterAuthNavigationUtilOptions, "preventRedirectUrlOriginCleaning"> | undefined) => Promise<void>;
     afterStepUpAuthNavigation: () => Promise<void>;
     __afterAuthenticationStateUpdate: ({ user, tenants, activeTenant }: ILoginResponseV3, additionalUpdate?: Partial<AuthState>) => Promise<void>;
     requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
@@ -37,6 +37,7 @@ declare const _default: (store: FronteggState, api: RestApi, sharedActions: Shar
         firstTime?: boolean | undefined;
         loginDirectAction?: import("../interfaces").LoginDirectAction | undefined;
     } | undefined) => Promise<void>;
+    __requestHostedLoginAuthorize: (additionalParams?: Record<string, string> | undefined) => Promise<void>;
     __requestHostedLoginSilentAuthorize: () => Promise<void>;
     handleHostedLoginCallback: (payload: import("../interfaces").HostedLoginCallback) => Promise<void>;
     setLoginState: (state: Partial<LoginState>) => void;