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

package/auth/SessionsState/index.js

@@ -1,37 +1,3 @@
-import { createAction } from '@reduxjs/toolkit';
-import { resetStateByKey, typeReducerForKey } from '../utils';
-import { authStoreName } from '../../constants';
-const sessionsState = {
-  loading: false,
-  sessions: []
-};
-const reducers = {
-  setSessionsState: typeReducerForKey('sessionsState'),
-  resetSessionsState: resetStateByKey('sessionsState', {
-    sessionsState
-  })
-};
-const actions = {
-  loadUserSessions: createAction(`${authStoreName}/loadUserSessions`),
-  loadCurrentUserSession: createAction(`${authStoreName}/loadCurrentUserSession`),
-  deleteUserSession: createAction(`${authStoreName}/deleteUserSession`, payload => ({
-    payload
-  })),
-  deleteAllUserSessions: createAction(`${authStoreName}/deleteAllUserSessions`),
-  revokeUserSessions: createAction(`${authStoreName}/revokeUserSessions`, 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 { sessionsState, reducers as sessionsReducers, actions as sessionsActions };
+import createSessionsState from './state';
+import buildSessionsActions from './actions';
+export { createSessionsState, buildSessionsActions };

package/auth/SessionsState/interfaces.d.ts

@@ -5,3 +5,4 @@ export interface SessionsState {
     currentSession?: ISessionResponse;
     sessions: ISessionResponse[];
 }
+export declare type ISession = ISessionResponse;

package/auth/SessionsState/state.d.ts

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

package/auth/SessionsState/state.js

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

package/auth/SignUpState/actions.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { ISignUpUserPayload, SignUpState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setSignUpState: (state: Partial<SignUpState>) => void;
+    resetSignUpState: () => void;
+    resetSignUpStateSoft: () => void;
+    signUpUser: (_payload: ISignUpUserPayload) => Promise<void>;
+    loadAllowSignUps: () => Promise<void>;
+};
+export default _default;

package/auth/SignUpState/actions.js

@@ -0,0 +1,146 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["events", "url"];
+import { SignUpStage } from './interfaces';
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+import { ContextHolder } from '@frontegg/rest-api';
+import { extractPhoneNumber, isMfaRequired } from '../helpers';
+import { AuthenticationTypes } from '../interfaces';
+import { GTMEventAction, reportGTMEvent } from '../../helpers/gtm';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const contextHolder = ContextHolder.for(store.root.appName);
+  const setSignUpState = state => {
+    Object.assign(store.auth.signUpState, state);
+  };
+  const resetSignUpState = () => {
+    store.auth.signUpState = deepClone(initialState);
+  };
+  const resetSignUpStateSoft = () => {
+    const {
+      allowSignUps,
+      allowNotVerifiedUsersLogin
+    } = store.auth.signUpState;
+    resetSignUpState();
+    setSignUpState({
+      allowSignUps,
+      allowNotVerifiedUsersLogin
+    });
+  };
+  const signUpUser = async _payload => {
+    const {
+        events,
+        url
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded);
+    setSignUpState({
+      loading: true
+    });
+    try {
+      const {
+        routes,
+        onRedirectTo
+      } = store.auth;
+      const {
+        shouldActivate,
+        user,
+        tenantId,
+        userId,
+        tenants = [],
+        activeTenant
+      } = await api.auth.signUpUser(
+      //Currently we are not supporting phone number in signup in the backend
+      //Remove this line when we will support it (also make sure when field is optional no empty string is sent)
+      extractPhoneNumber(payload));
+      if (!payload.invitationToken) {
+        var _events$signUpComplet;
+        const {
+          email,
+          name,
+          companyName,
+          phoneNumber
+        } = payload;
+        const signUpCompletePayload = {
+          email,
+          name,
+          companyName,
+          url,
+          phoneNumber: phoneNumber || undefined,
+          authenticationType: AuthenticationTypes.PASSWORD,
+          id: userId,
+          tenantId,
+          createdAt: new Date()
+        };
+        events == null ? void 0 : (_events$signUpComplet = events.signUpComplete) == null ? void 0 : _events$signUpComplet.call(events, signUpCompletePayload);
+        reportGTMEvent(GTMEventAction.SIGNUP_COMPLETED, signUpCompletePayload);
+      }
+      if (!shouldActivate && user && isMfaRequired(user, store.root.appName)) {
+        const mfaRequiredState = await actions.getMfaRequiredState(user);
+        actions.setAuthState(mfaRequiredState);
+        onRedirectTo(routes.loginUrl);
+      } else {
+        const tenantsState = store.auth.tenantsState;
+        setSignUpState({
+          loading: false,
+          shouldActivate,
+          stage: SignUpStage.SignUpSuccess
+        });
+        actions.setAuthState({
+          user,
+          isAuthenticated: !!(user != null && user.accessToken),
+          tenantsState: _extends({}, tenantsState, {
+            tenants,
+            activeTenant
+          })
+        });
+      }
+    } catch (e) {
+      contextHolder.setAccessToken(null);
+      contextHolder.setUser(null);
+      setSignUpState({
+        error: errorHandler(e)
+      });
+    } finally {
+      setSignUpState({
+        loading: false
+      });
+    }
+  };
+  const loadAllowSignUps = async () => {
+    setSignUpState({
+      loading: true
+    });
+    try {
+      const policy = await api.auth.getVendorConfig();
+      const policyWithCustomLoginAuthStrategy = await actions.__getSecurityPolicyPublicStateWithCustomLogin(policy);
+      const {
+        allowSignups: allowSignUps,
+        allowNotVerifiedUsersLogin
+      } = policy;
+      setSignUpState({
+        loading: false,
+        allowSignUps,
+        allowNotVerifiedUsersLogin,
+        firstLoad: false
+      });
+      actions.setSecurityPolicyPublicState({
+        policy: policyWithCustomLoginAuthStrategy,
+        loading: false
+      });
+    } catch (e) {
+      setSignUpState({
+        loading: false,
+        error: errorHandler(e),
+        firstLoad: false
+      });
+    }
+  };
+  return {
+    setSignUpState,
+    resetSignUpState,
+    resetSignUpStateSoft,
+    signUpUser,
+    loadAllowSignUps
+  };
+});

package/auth/SignUpState/index.d.ts

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

package/auth/SignUpState/index.js

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

package/auth/SignUpState/state.d.ts

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

package/auth/SignUpState/state.js

@@ -0,0 +1,10 @@
+import { SignUpStage } from './interfaces';
+import { createProxy } from '../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  allowSignUps: false,
+  allowNotVerifiedUsersLogin: false,
+  firstLoad: true,
+  stage: SignUpStage.SignUp
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/SmsState/actions.d.ts

@@ -0,0 +1,15 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { IPhoneId, SmsState } from './interfaces';
+import { IPreVerifyPhoneNumber, IUpdatePhoneNumber, IVerifyPhoneNumber } from '@frontegg/rest-api';
+import { WithPhoneId } from '../LoginState/interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setSmsState: (state: Partial<SmsState>) => void;
+    resetSmsState: () => void;
+    loadPhoneNumbers: () => Promise<void>;
+    setUpPhoneNumber: (_payload: WithCallback<IUpdatePhoneNumber>) => Promise<void>;
+    verifyPhoneNumber: (_payload: WithCallback<IVerifyPhoneNumber>) => Promise<void>;
+    deletePhoneNumber: (_payload: WithCallback<IPhoneId>) => Promise<void>;
+    verifyDeletePhoneNumber: (_payload: WithCallback<WithPhoneId<IVerifyPhoneNumber>>) => Promise<void>;
+    preVerifyPhoneNumber: (_payload: WithCallback<IPreVerifyPhoneNumber>) => Promise<void>;
+};
+export default _default;

package/auth/SmsState/actions.js

@@ -0,0 +1,181 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"],
+  _excluded3 = ["callback", "phoneId"],
+  _excluded4 = ["callback", "phoneId"],
+  _excluded5 = ["callback"];
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+export default ((store, api, sharedActions) => {
+  const setSmsState = state => {
+    Object.assign(store.auth.smsState, state);
+  };
+  const resetSmsState = () => {
+    store.auth.smsState = deepClone(initialState);
+  };
+  const loadPhoneNumbers = async () => {
+    setSmsState({
+      loading: true
+    });
+    const queryParams = {
+      _limit: 10,
+      _offset: 0
+    };
+    try {
+      const {
+        items
+      } = await api.userPhoneNumbers.getUserPhoneNumbers(queryParams);
+      setSmsState({
+        phoneNumbers: items
+      });
+    } catch (e) {
+      setSmsState({
+        error: errorHandler(e)
+      });
+    } finally {
+      setSmsState({
+        loading: false
+      });
+    }
+  };
+  const setUpPhoneNumber = async _payload => {
+    const {
+        callback
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded);
+    setSmsState({
+      loading: true
+    });
+    try {
+      const {
+        otcToken
+      } = await api.userPhoneNumbers.createPhoneNumber(payload);
+      setSmsState({
+        otcToken
+      });
+      await loadPhoneNumbers();
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setSmsState({
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    } finally {
+      setSmsState({
+        loading: false
+      });
+    }
+  };
+  const verifyPhoneNumber = async _payload => {
+    const {
+        callback
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded2);
+    setSmsState({
+      loading: true
+    });
+    try {
+      await api.userPhoneNumbers.verifyPhoneNumber(payload);
+      await loadPhoneNumbers();
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setSmsState({
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    } finally {
+      setSmsState({
+        loading: false
+      });
+    }
+  };
+  const deletePhoneNumber = async _payload => {
+    const {
+        callback,
+        phoneId
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded3);
+    setSmsState({
+      loading: true
+    });
+    try {
+      const {
+        otcToken
+      } = await api.userPhoneNumbers.deletePhoneNumber(phoneId);
+      setSmsState({
+        otcToken
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setSmsState({
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    } finally {
+      setSmsState({
+        loading: false
+      });
+    }
+  };
+  const verifyDeletePhoneNumber = async _payload => {
+    const {
+        callback,
+        phoneId
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded4);
+    setSmsState({
+      loading: true
+    });
+    try {
+      await api.userPhoneNumbers.verifyDeletePhoneNumber(phoneId, payload);
+      await loadPhoneNumbers();
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setSmsState({
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    } finally {
+      setSmsState({
+        loading: false
+      });
+    }
+  };
+  const preVerifyPhoneNumber = async _payload => {
+    const {
+        callback
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded5);
+    setSmsState({
+      loading: true
+    });
+    try {
+      const {
+        otcToken
+      } = await api.userPhoneNumbers.preVerifyPhoneNumber(payload);
+      setSmsState({
+        otcToken
+      });
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      setSmsState({
+        error: errorHandler(e)
+      });
+      callback == null ? void 0 : callback(false, e);
+    } finally {
+      setSmsState({
+        loading: false
+      });
+    }
+  };
+  return {
+    setSmsState,
+    resetSmsState,
+    loadPhoneNumbers,
+    setUpPhoneNumber,
+    verifyPhoneNumber,
+    deletePhoneNumber,
+    verifyDeletePhoneNumber,
+    preVerifyPhoneNumber
+  };
+});

package/auth/SmsState/index.d.ts

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

package/auth/SmsState/index.js

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

package/auth/SmsState/interfaces.d.ts

@@ -0,0 +1,10 @@
+import { IPhoneNumber } from '@frontegg/rest-api';
+export interface IPhoneId {
+    phoneId: string;
+}
+export interface SmsState {
+    loading: boolean;
+    error: string | null;
+    phoneNumbers?: IPhoneNumber[];
+    otcToken?: string;
+}

package/auth/SmsState/state.d.ts

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

package/auth/SmsState/state.js

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

package/auth/SocialLoginState/actions.d.ts

@@ -0,0 +1,14 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { ILoginViaSocialLoginPayload, SocialLoginState } from './interfaces';
+import { ISetSocialLoginError } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setSocialLoginsState: (state: Partial<SocialLoginState>) => void;
+    resetSocialLoginsState: () => void;
+    setSocialLoginError: (payload: ISetSocialLoginError) => void;
+    loadSocialLoginsConfiguration: () => Promise<void>;
+    loadSocialLoginsConfigurationV2: (payload?: {
+        callback?: import("../../interfaces").CallbackMethod<SocialLoginState> | undefined;
+    } | undefined) => Promise<void>;
+    loginViaSocialLogin: (_payload: ILoginViaSocialLoginPayload) => Promise<void>;
+};
+export default _default;

package/auth/SocialLoginState/actions.js

@@ -0,0 +1,163 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["authorizationUrl"],
+  _excluded2 = ["events", "url"];
+import { deepClone, errorHandler } from '../../helpers';
+import { initialState } from './state';
+import { AuthenticationTypes, UserVeirifedOriginTypes } from '../interfaces';
+import { GTMEventAction, reportGTMEvent } from '../../helpers/gtm';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+
+  /**
+   * @private
+   */
+  const __getSocialLoginsConfigurationsV2 = async () => {
+    const isAuthenticated = store.auth.isAuthenticated;
+    let socialLoginsConfigV2;
+    if (isAuthenticated) {
+      socialLoginsConfigV2 = await api.auth.getSocialLoginProvidersV2ForAuthenticatedUser();
+    } else {
+      socialLoginsConfigV2 = await api.auth.getSocialLoginProvidersV2();
+    }
+    return socialLoginsConfigV2;
+  };
+  const setSocialLoginsState = state => {
+    Object.assign(store.auth.socialLoginState, state);
+  };
+  const resetSocialLoginsState = () => {
+    store.auth.socialLoginState = deepClone(initialState);
+  };
+  const setSocialLoginError = payload => {
+    setSocialLoginsState({
+      error: payload.error,
+      loading: false,
+      firstLoad: false
+    });
+  };
+  const loadSocialLoginsConfiguration = async () => {
+    try {
+      setSocialLoginsState({
+        loading: true
+      });
+      const socialLoginsConfig = await api.auth.getSocialLoginProviders();
+      setSocialLoginsState({
+        socialLoginsConfig,
+        loading: false,
+        firstLoad: false
+      });
+    } catch (e) {
+      setSocialLoginsState({
+        error: errorHandler(e),
+        loading: false,
+        firstLoad: false
+      });
+    }
+  };
+  const loadSocialLoginsConfigurationV2 = async payload => {
+    try {
+      var _payload$callback;
+      const context = store.root.context;
+      setSocialLoginsState({
+        loading: true
+      });
+      const socialLoginsConfigV2 = await __getSocialLoginsConfigurationsV2();
+      const {
+        providers: customSocialLoginsConfig
+      } = await api.auth.getCustomSocialLoginProvidersV1();
+      const socialLoginsConfigWithFullUrl = socialLoginsConfigV2.map(_ref => {
+        let {
+            authorizationUrl
+          } = _ref,
+          config = _objectWithoutPropertiesLoose(_ref, _excluded);
+        const baseUrl = api.fetch.getBaseUrl(context, authorizationUrl != null ? authorizationUrl : '');
+        return _extends({}, config, {
+          authorizationUrl: authorizationUrl ? `${baseUrl}${authorizationUrl}` : null
+        });
+      });
+      const newState = {
+        socialLoginsConfigV2: socialLoginsConfigWithFullUrl,
+        customSocialLoginsConfig,
+        loading: false,
+        firstLoad: false
+      };
+      setSocialLoginsState(newState);
+      payload == null ? void 0 : (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, newState);
+    } catch (e) {
+      var _payload$callback2;
+      payload == null ? void 0 : (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, null, e);
+      setSocialLoginsState({
+        error: errorHandler(e),
+        loading: false,
+        firstLoad: false
+      });
+    }
+  };
+  const loginViaSocialLogin = async _payload => {
+    const {
+        events,
+        url
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded2);
+    try {
+      setSocialLoginsState({
+        loading: true
+      });
+      const {
+        email,
+        isNewUser,
+        userId,
+        tenantId,
+        name
+      } = await api.auth.loginViaSocialLogin(payload);
+      if (isNewUser) {
+        var _events$signUpComplet, _events$userVerified;
+        const basePayload = {
+          email,
+          url,
+          createdAt: new Date(),
+          id: userId,
+          tenantId
+        };
+        const signUpCompletePayload = _extends({}, basePayload, {
+          socialProvider: payload.provider,
+          authenticationType: AuthenticationTypes.SOCIAL_LOGIN
+        });
+        events == null ? void 0 : (_events$signUpComplet = events.signUpComplete) == null ? void 0 : _events$signUpComplet.call(events, signUpCompletePayload);
+        reportGTMEvent(GTMEventAction.SIGNUP_COMPLETED, signUpCompletePayload);
+        const userVerifiedPayload = _extends({}, basePayload, {
+          origin: UserVeirifedOriginTypes.SOCIAL_LOGIN,
+          name
+        });
+        events == null ? void 0 : (_events$userVerified = events.userVerified) == null ? void 0 : _events$userVerified.call(events, userVerifiedPayload);
+        reportGTMEvent(GTMEventAction.USER_VERIFIED, userVerifiedPayload);
+      }
+      if (userId) {
+        localStorage.setItem('userId', userId);
+      }
+      actions.setLoginState({
+        email,
+        isNewUser
+      });
+      actions.refreshTokenForSocialLogins();
+      localStorage.removeItem('register-quick-login');
+      setSocialLoginsState({
+        loading: false
+      });
+    } catch (e) {
+      setSocialLoginsState({
+        loading: false,
+        error: errorHandler(e, 'Failed to authenticate'),
+        firstLoad: false
+      });
+    }
+  };
+  return {
+    setSocialLoginsState,
+    resetSocialLoginsState,
+    setSocialLoginError,
+    loadSocialLoginsConfiguration,
+    loadSocialLoginsConfigurationV2,
+    loginViaSocialLogin
+  };
+});

package/auth/SocialLoginState/index.d.ts

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

package/auth/SocialLoginState/index.js

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

package/auth/SocialLoginState/state.d.ts

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

package/auth/SocialLoginState/state.js

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