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

package/auth/AccountSettingsState/actions.js

@@ -0,0 +1,93 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["activeTenant", "tenants"];
+import { snapshot } from 'valtio/vanilla';
+import { initialState } from './state';
+import { errorHandler, deepClone } from '../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setAccountSettingsState = state => {
+    Object.assign(store.auth.accountSettingsState, state);
+    return snapshot(store.auth.accountSettingsState);
+  };
+  const resetAccountSettingsState = () => {
+    store.auth.accountSettingsState = deepClone(initialState);
+  };
+  const updateTenantState = ({
+    newSettingValues
+  }) => {
+    const _store$auth$tenantsSt = store.auth.tenantsState,
+      {
+        activeTenant,
+        tenants
+      } = _store$auth$tenantsSt,
+      rest = _objectWithoutPropertiesLoose(_store$auth$tenantsSt, _excluded);
+    const updatedTenants = tenants.map(tenant => tenant.id !== (activeTenant == null ? void 0 : activeTenant.id) ? tenant : _extends({}, tenant, newSettingValues));
+    const updatedActiveTenant = _extends({}, activeTenant, newSettingValues);
+    sharedActions.setTenantsState(_extends({}, rest, {
+      tenants: updatedTenants,
+      activeTenant: updatedActiveTenant
+    }));
+  };
+  const saveAccountSettings = async payload => {
+    try {
+      var _payload$callback;
+      setAccountSettingsState({
+        loading: true
+      });
+      const {
+        address,
+        timezone,
+        dateFormat,
+        timeFormat,
+        currency,
+        logo
+      } = store.auth.accountSettingsState;
+      const body = await api.accountSettings.updateSettings(_extends({
+        address,
+        timezone,
+        dateFormat,
+        timeFormat,
+        currency,
+        logo
+      }, payload));
+      updateTenantState({
+        newSettingValues: body
+      });
+      setAccountSettingsState(_extends({}, body, {
+        loading: false
+      }));
+      (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, body);
+    } catch (e) {
+      var _payload$callback2;
+      setAccountSettingsState({
+        loading: false,
+        error: errorHandler(e)
+      });
+      (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, null, e);
+    }
+  };
+  const loadAccountSettings = async payload => {
+    setAccountSettingsState({
+      loading: !(payload != null && payload.silentLoading),
+      error: null
+    });
+    try {
+      const body = await api.accountSettings.getSettings();
+      setAccountSettingsState(_extends({}, body, {
+        loading: false
+      }));
+    } catch (e) {
+      setAccountSettingsState({
+        loading: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  return {
+    setAccountSettingsState,
+    resetAccountSettingsState,
+    saveAccountSettings,
+    loadAccountSettings
+  };
+});

package/auth/AccountSettingsState/index.d.ts

@@ -1,124 +1,3 @@
-import { ISettingsResponse } from '@frontegg/rest-api';
-import { AccountSettingsState } from './interfaces';
-import { WithCallback, WithSilentLoad } from '../../interfaces';
-declare const accountSettingsState: AccountSettingsState;
-declare const reducers: {
-    setAccountSettingsState: {
-        prepare: (payload: Partial<AccountSettingsState>) => {
-            payload: Partial<AccountSettingsState>;
-        };
-        reducer: (state: import("..").AuthState, { payload }: {
-            payload: Partial<AccountSettingsState>;
-            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: import("..").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: 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;
-        };
-    };
-    resetAccountSettingsState: (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: import("..").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: 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: {
-    loadAccountSettings: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[(WithCallback<{
-        silentLoading?: boolean | undefined;
-    }, boolean> | undefined)?], WithCallback<{
-        silentLoading?: boolean | undefined;
-    }, boolean> | undefined, string, never, never>;
-    saveAccountSettings: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ISettingsResponse, ISettingsResponse>], WithCallback<ISettingsResponse, ISettingsResponse>, string, never, never>;
-};
-/**
- *  To be used for actions types after dispatch, and should contains
- *  the reducers and actions as standalone function
- */
-declare type DispatchedActions = {
-    setAccountSettingsState: (state: Partial<AccountSettingsState>) => void;
-    resetAccountSettingsState: () => void;
-    loadAccountSettings: (payload?: WithCallback<WithSilentLoad<{}>>) => void;
-    saveAccountSettings: (payload: WithCallback<ISettingsResponse, ISettingsResponse>) => void;
-};
-export declare type AccountSettingsActions = DispatchedActions;
-export { accountSettingsState, reducers as accountSettingsReducers, actions as accountSettingsActions };
+import createAccountSettingsState from './state';
+import buildAccountSettingsActions from './actions';
+export { createAccountSettingsState, buildAccountSettingsActions };

package/auth/AccountSettingsState/index.js

@@ -1,33 +1,3 @@
-import { createAction } from '@reduxjs/toolkit';
-import { resetStateByKey, typeReducerForKey } from '../utils';
-import { authStoreName } from '../../constants';
-const accountSettingsState = {
-  loading: false
-};
-const reducers = {
-  setAccountSettingsState: typeReducerForKey('accountSettingsState'),
-  resetAccountSettingsState: resetStateByKey('accountSettingsState', {
-    accountSettingsState
-  })
-};
-const actions = {
-  loadAccountSettings: createAction(`${authStoreName}/loadAccountSettings`, payload => ({
-    payload
-  })),
-  saveAccountSettings: createAction(`${authStoreName}/saveAccountSettings`, 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 { accountSettingsState, reducers as accountSettingsReducers, actions as accountSettingsActions };
+import createAccountSettingsState from './state';
+import buildAccountSettingsActions from './actions';
+export { createAccountSettingsState, buildAccountSettingsActions };

package/auth/AccountSettingsState/state.d.ts

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

package/auth/AccountSettingsState/state.js

@@ -0,0 +1,5 @@
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: false
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/ActivateAccountState/actions.d.ts

@@ -0,0 +1,26 @@
+import { FronteggState, WithCallback, SharedActions, RestApi } from '../../interfaces';
+import { IGetActivateAccountStrategy, IGetActivateAccountStrategyResponse, IResendActivationEmail } from '@frontegg/rest-api';
+import { ActivateAccountState, ActivateAccountStep, IActivateAccountPayload, IPreActivateAccount } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setActivateState: (state: Partial<ActivateAccountState>) => {
+        readonly loading: boolean;
+        readonly error?: any;
+        readonly step: ActivateAccountStep;
+        readonly resentEmail: boolean;
+        readonly activationStrategy: {
+            readonly loading: boolean;
+            readonly error?: any;
+            readonly saving?: boolean | undefined;
+            readonly strategy?: {
+                readonly shouldSetPassword: boolean;
+            } | undefined;
+        };
+    };
+    resetActivateState: () => void;
+    setActivateStrategyState: (state: Partial<ActivateAccountState['activationStrategy']>) => void;
+    activateAccount: (_payload: WithCallback<IActivateAccountPayload>) => Promise<void>;
+    preActivateAccount: (payload: IPreActivateAccount) => Promise<void>;
+    getActivateAccountStrategy: (payload: WithCallback<IGetActivateAccountStrategy, IGetActivateAccountStrategyResponse>) => Promise<void>;
+    resendActivationEmail: (payload: WithCallback<IResendActivationEmail>) => Promise<void>;
+};
+export default _default;

package/auth/ActivateAccountState/actions.js

@@ -0,0 +1,192 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback", "events"],
+  _excluded2 = ["user"],
+  _excluded3 = ["callback"],
+  _excluded4 = ["callback"];
+import { snapshot } from 'valtio/vanilla';
+import { initialState } from './state';
+import { ContextHolder } from '@frontegg/rest-api';
+import { errorHandler, deepClone, delay } from '../../helpers';
+import { ActivateAccountStep } from './interfaces';
+import { UserVeirifedOriginTypes } from '../interfaces';
+import { GTMEventAction, reportGTMEvent } from '../../helpers/gtm';
+import { isMfaRequired } from '../helpers';
+import { TeamStateKeys } from '../TeamState/interfaces';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setActivateState = state => {
+    Object.assign(store.auth.activateAccountState, state);
+    return snapshot(store.auth.activateAccountState);
+  };
+  const resetActivateState = () => {
+    store.auth.activateAccountState = deepClone(initialState);
+  };
+  const setActivateStrategyState = state => {
+    Object.assign(store.auth.activateAccountState.activationStrategy, state);
+  };
+  const preActivateAccount = async payload => {
+    const {
+      userId,
+      token
+    } = payload;
+    setActivateState({
+      loading: true,
+      step: ActivateAccountStep.activating
+    });
+    try {
+      const isAuthenticated = store.auth.isAuthenticated;
+      if (isAuthenticated) {
+        await actions.silentLogout();
+      }
+      const strategy = await api.auth.getActivateAccountStrategy({
+        userId,
+        token
+      });
+      setActivateStrategyState({
+        strategy,
+        loading: false,
+        error: undefined
+      });
+      if (strategy.shouldSetPassword) {
+        setActivateState({
+          loading: false,
+          step: ActivateAccountStep.activatingForm
+        });
+      }
+    } catch (e) {
+      setActivateState({
+        loading: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  const activateAccount = async _payload => {
+    const {
+        callback,
+        events
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded);
+    setActivateState({
+      loading: true
+    });
+    try {
+      const onRedirectTo = ContextHolder.for(store.root.appName).onRedirectTo;
+      const routes = store.auth.routes;
+      const _await$api$auth$activ = await api.auth.activateAccountV2(payload),
+        {
+          user
+        } = _await$api$auth$activ,
+        rest = _objectWithoutPropertiesLoose(_await$api$auth$activ, _excluded2);
+      if (user.redirectLocation) {
+        window.location.href = user.redirectLocation;
+        return;
+      }
+      if (isMfaRequired(user, store.root.appName)) {
+        setActivateState({
+          step: ActivateAccountStep.success
+        });
+        const mfaRequiredState = await actions.getMfaRequiredState(user);
+        actions.setAuthState(mfaRequiredState);
+        await delay(1000);
+        onRedirectTo(routes.loginUrl, {
+          preserveQueryParams: true
+        });
+      } else {
+        var _events$userVerified;
+        setActivateState({
+          step: ActivateAccountStep.success
+        });
+        const userVerifiedPayload = {
+          email: user.email,
+          origin: UserVeirifedOriginTypes.ACTIVATION_LINK,
+          id: user.id,
+          tenantId: user.tenantId,
+          name: user.name,
+          createdAt: new Date()
+        };
+        events == null ? void 0 : (_events$userVerified = events.userVerified) == null ? void 0 : _events$userVerified.call(events, userVerifiedPayload);
+        reportGTMEvent(GTMEventAction.USER_VERIFIED, userVerifiedPayload);
+        await actions.__afterAuthenticationStateUpdate(_extends({
+          user
+        }, rest), {
+          isAuthenticated: true
+        });
+        await delay(1000);
+        await actions.afterAuthNavigation();
+        resetActivateState();
+      }
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setActivateState({
+        loading: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  const getActivateAccountStrategy = async payload => {
+    const {
+        callback
+      } = payload,
+      params = _objectWithoutPropertiesLoose(payload, _excluded3);
+    setActivateStrategyState({
+      loading: true
+    });
+    try {
+      const strategy = await api.auth.getActivateAccountStrategy(params);
+      setActivateStrategyState({
+        strategy,
+        loading: false,
+        error: undefined
+      });
+      callback == null ? void 0 : callback(strategy);
+    } catch (e) {
+      setActivateStrategyState({
+        loading: false,
+        error: errorHandler(e)
+      });
+    }
+  };
+  const resendActivationEmail = async payload => {
+    const {
+        callback
+      } = payload,
+      body = _objectWithoutPropertiesLoose(payload, _excluded4);
+    actions.setTeamLoader({
+      key: TeamStateKeys.RESEND_ACTIVATE_LINK,
+      value: body.email
+    });
+    setActivateState({
+      loading: true
+    });
+    try {
+      await api.auth.resendActivationEmail(body);
+      setActivateState({
+        loading: false,
+        error: undefined,
+        resentEmail: true
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setActivateState({
+        loading: false,
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(null, e);
+    } finally {
+      actions.setTeamLoader({
+        key: TeamStateKeys.RESEND_ACTIVATE_LINK,
+        value: false
+      });
+    }
+  };
+  return {
+    setActivateState,
+    resetActivateState,
+    setActivateStrategyState,
+    activateAccount,
+    preActivateAccount,
+    getActivateAccountStrategy,
+    resendActivationEmail
+  };
+});

package/auth/ActivateAccountState/index.d.ts

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

package/auth/ActivateAccountState/index.js

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

package/auth/ActivateAccountState/state.d.ts

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

package/auth/ActivateAccountState/state.js

@@ -0,0 +1,11 @@
+import { ActivateAccountStep } from './interfaces';
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  step: ActivateAccountStep.activating,
+  loading: false,
+  resentEmail: false,
+  activationStrategy: {
+    loading: false
+  }
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/ApiTokensState/actions.d.ts

@@ -0,0 +1,16 @@
+import { FronteggState, WithCallback, SharedActions, RestApi, WithSilentLoad } from '../../interfaces';
+import { AddTenantApiTokenPayload, AddUserApiTokenPayload, ApiStateIndicator, ApiTokensState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setApiTokensLoader: (payload: ApiStateIndicator) => void;
+    setApiTokensError: (payload: ApiStateIndicator) => void;
+    setApiTokensState: (state: Partial<ApiTokensState>) => void;
+    resetApiTokensState: () => void;
+    loadApiTokens: (payload?: WithSilentLoad<WithCallback<object, boolean>> | undefined) => Promise<void>;
+    loadUserApiTokens: (payload?: WithSilentLoad<WithCallback<object, boolean>> | undefined) => Promise<void>;
+    loadTenantApiTokens: (payload?: WithSilentLoad<WithCallback<object, boolean>> | undefined) => Promise<void>;
+    addTenantApiToken: (payload: AddTenantApiTokenPayload) => Promise<void>;
+    addUserApiToken: (payload: AddUserApiTokenPayload) => Promise<void>;
+    deleteUserApiToken: (payload: string) => Promise<void>;
+    deleteTenantApiToken: (payload: string) => Promise<void>;
+};
+export default _default;