@frontegg/redux-store 5.61.0 → 6.0.1-alpha.2

package/auth/MfaState/index.d.ts

@@ -1,92 +1,92 @@
-import { IDisableMfa, ILoginWithMfa, IVerifyMfa } from '@frontegg/rest-api';
-import { MFAState } from './interfaces';
-import { WithCallback } from '../../interfaces';
-declare const mfaState: MFAState;
-declare const reducers: {
-    setMfaState: {
-        prepare: (payload: Partial<MFAState>) => {
-            payload: Partial<MFAState>;
-        };
-        reducer: (state: import("..").AuthState, { payload }: {
-            payload: Partial<MFAState>;
-            type: string;
-        }) => {
-            onRedirectTo: (path: string, opts?: import("@frontegg/rest-api").RedirectOptions | undefined) => void;
-            error?: any;
-            isAuthenticated: boolean;
-            isLoading: boolean;
-            keepSessionAlive?: boolean | undefined;
-            user?: import("..").User | null | undefined;
-            isSSOAuth: boolean;
-            ssoACS?: string | undefined;
-            loginState: import("..").LoginState;
-            activateState: import("..").ActivateAccountState;
-            acceptInvitationState: import("..").AcceptInvitationState;
-            forgotPasswordState: import("..").ForgotPasswordState;
-            resetPhoneNumberState: import("..").ResetPhoneNumberState;
-            ssoState: import("..").SSOState;
-            profileState: import("..").ProfileState;
-            mfaState: MFAState;
-            teamState: import("..").TeamState;
-            socialLoginState: import("..").SocialLoginState;
-            signUpState: import("..").SignUpState;
-            apiTokensState: import("..").ApiTokensState;
-            securityPolicyState: import("..").SecurityPolicyState;
-            accountSettingsState: import("..").AccountSettingsState;
-            tenantsState: import("..").TenantsState;
-            rolesState: import("..").RolesState;
-            routes: import("..").AuthPageRoutes;
-            header?: any;
-            loaderComponent?: any;
-        };
-    };
-    resetMfaState: (state: import("..").AuthState) => {
-        onRedirectTo: (path: string, opts?: import("@frontegg/rest-api").RedirectOptions | undefined) => void;
-        error?: any;
-        isAuthenticated: boolean;
-        isLoading: boolean;
-        keepSessionAlive?: boolean | undefined;
-        user?: import("..").User | null | undefined;
-        isSSOAuth: boolean;
-        ssoACS?: string | undefined;
-        loginState: import("..").LoginState;
-        activateState: import("..").ActivateAccountState;
-        acceptInvitationState: import("..").AcceptInvitationState;
-        forgotPasswordState: import("..").ForgotPasswordState;
-        resetPhoneNumberState: import("..").ResetPhoneNumberState;
-        ssoState: import("..").SSOState;
-        profileState: import("..").ProfileState;
-        mfaState: MFAState;
-        teamState: import("..").TeamState;
-        socialLoginState: import("..").SocialLoginState;
-        signUpState: import("..").SignUpState;
-        apiTokensState: import("..").ApiTokensState;
-        securityPolicyState: import("..").SecurityPolicyState;
-        accountSettingsState: import("..").AccountSettingsState;
-        tenantsState: import("..").TenantsState;
-        rolesState: import("..").RolesState;
-        routes: import("..").AuthPageRoutes;
-        header?: any;
-        loaderComponent?: any;
-    };
-};
-declare const actions: {
-    enrollMfa: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    verifyMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IVerifyMfa, string | undefined>], WithCallback<IVerifyMfa, string | undefined>, string, never, never>;
-    verifyMfaAfterForce: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ILoginWithMfa, string | undefined>], WithCallback<ILoginWithMfa, string | undefined>, string, never, never>;
-    disableMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IDisableMfa, boolean>], WithCallback<IDisableMfa, boolean>, string, never, never>;
-};
-/**
- *  To be used for actions types after dispatch, and should contains
- *  the reducers and actions as standalone function
- */
-declare type DispatchedActions = {
-    setMfaState: (state: Partial<MFAState>) => void;
-    resetMfaState: () => void;
-    enrollMfa: () => void;
-    verifyMfa: (payload: WithCallback<IVerifyMfa, string | undefined>) => void;
-    verifyMfaAfterForce: (payload: WithCallback<ILoginWithMfa, string | undefined>) => void;
-    disableMfa: (payload: WithCallback<IDisableMfa>) => void;
-};
-export declare type MfaActions = DispatchedActions;
-export { mfaState, reducers as mfaReducers, actions as mfaActions };
+import { IDisableMfa, ILoginWithMfa, IVerifyMfa } from '@frontegg/rest-api';
+import { MFAState } from './interfaces';
+import { WithCallback } from '../../interfaces';
+declare const mfaState: MFAState;
+declare const reducers: {
+    setMfaState: {
+        prepare: (payload: Partial<MFAState>) => {
+            payload: Partial<MFAState>;
+        };
+        reducer: (state: import("..").AuthState, { payload }: {
+            payload: Partial<MFAState>;
+            type: string;
+        }) => {
+            onRedirectTo: (path: string, opts?: import("@frontegg/rest-api").RedirectOptions | undefined) => void;
+            error?: any;
+            isAuthenticated: boolean;
+            isLoading: boolean;
+            keepSessionAlive?: boolean | undefined;
+            user?: import("..").User | null | undefined;
+            isSSOAuth: boolean;
+            ssoACS?: string | undefined;
+            loginState: import("..").LoginState;
+            activateState: import("..").ActivateAccountState;
+            acceptInvitationState: import("..").AcceptInvitationState;
+            forgotPasswordState: import("..").ForgotPasswordState;
+            resetPhoneNumberState: import("..").ResetPhoneNumberState;
+            ssoState: import("..").SSOState;
+            profileState: import("..").ProfileState;
+            mfaState: MFAState;
+            teamState: import("..").TeamState;
+            socialLoginState: import("..").SocialLoginState;
+            signUpState: import("..").SignUpState;
+            apiTokensState: import("..").ApiTokensState;
+            securityPolicyState: import("..").SecurityPolicyState;
+            accountSettingsState: import("..").AccountSettingsState;
+            tenantsState: import("..").TenantsState;
+            rolesState: import("..").RolesState;
+            routes: import("..").AuthPageRoutes;
+            header?: any;
+            loaderComponent?: any;
+        };
+    };
+    resetMfaState: (state: import("..").AuthState) => {
+        onRedirectTo: (path: string, opts?: import("@frontegg/rest-api").RedirectOptions | undefined) => void;
+        error?: any;
+        isAuthenticated: boolean;
+        isLoading: boolean;
+        keepSessionAlive?: boolean | undefined;
+        user?: import("..").User | null | undefined;
+        isSSOAuth: boolean;
+        ssoACS?: string | undefined;
+        loginState: import("..").LoginState;
+        activateState: import("..").ActivateAccountState;
+        acceptInvitationState: import("..").AcceptInvitationState;
+        forgotPasswordState: import("..").ForgotPasswordState;
+        resetPhoneNumberState: import("..").ResetPhoneNumberState;
+        ssoState: import("..").SSOState;
+        profileState: import("..").ProfileState;
+        mfaState: MFAState;
+        teamState: import("..").TeamState;
+        socialLoginState: import("..").SocialLoginState;
+        signUpState: import("..").SignUpState;
+        apiTokensState: import("..").ApiTokensState;
+        securityPolicyState: import("..").SecurityPolicyState;
+        accountSettingsState: import("..").AccountSettingsState;
+        tenantsState: import("..").TenantsState;
+        rolesState: import("..").RolesState;
+        routes: import("..").AuthPageRoutes;
+        header?: any;
+        loaderComponent?: any;
+    };
+};
+declare const actions: {
+    enrollMfa: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+    verifyMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IVerifyMfa, string | undefined>], WithCallback<IVerifyMfa, string | undefined>, string, never, never>;
+    verifyMfaAfterForce: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ILoginWithMfa, string | undefined>], WithCallback<ILoginWithMfa, string | undefined>, string, never, never>;
+    disableMfa: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<IDisableMfa, boolean>], WithCallback<IDisableMfa, boolean>, string, never, never>;
+};
+/**
+ *  To be used for actions types after dispatch, and should contains
+ *  the reducers and actions as standalone function
+ */
+declare type DispatchedActions = {
+    setMfaState: (state: Partial<MFAState>) => void;
+    resetMfaState: () => void;
+    enrollMfa: () => void;
+    verifyMfa: (payload: WithCallback<IVerifyMfa, string | undefined>) => void;
+    verifyMfaAfterForce: (payload: WithCallback<ILoginWithMfa, string | undefined>) => void;
+    disableMfa: (payload: WithCallback<IDisableMfa>) => void;
+};
+export declare type MfaActions = DispatchedActions;
+export { mfaState, reducers as mfaReducers, actions as mfaActions };

package/auth/MfaState/index.js

@@ -0,0 +1,28 @@
+import { createAction } from '@reduxjs/toolkit';
+import { MFAStep } from './interfaces';
+import { resetStateByKey, typeReducerForKey } from '../utils';
+import { authStoreName } from '../../constants';
+const mfaState = {
+  step: MFAStep.verify,
+  loading: false
+};
+const reducers = {
+  setMfaState: typeReducerForKey('mfaState'),
+  resetMfaState: resetStateByKey('mfaState', {
+    mfaState
+  })
+};
+const actions = {
+  enrollMfa: createAction(`${authStoreName}/enrollMfa`),
+  verifyMfa: createAction(`${authStoreName}/verifyMfa`, payload => ({
+    payload
+  })),
+  verifyMfaAfterForce: createAction(`${authStoreName}/verifyMfaAfterForce`, payload => ({
+    payload
+  })),
+  disableMfa: createAction(`${authStoreName}/disableMfa`, payload => ({
+    payload
+  }))
+};
+const Matcher = {};
+export { mfaState, reducers as mfaReducers, actions as mfaActions };

package/auth/MfaState/interfaces.d.ts

@@ -1,12 +1,12 @@
-export declare enum MFAStep {
-    'verify' = "verify",
-    'recoveryCode' = "recoveryCode"
-}
-export interface MFAState {
-    step: MFAStep;
-    loading: boolean;
-    error?: any;
-    recoveryCode?: string;
-    qrCode?: string | null;
-    mfaToken?: string;
-}
+export declare enum MFAStep {
+    'verify' = "verify",
+    'recoveryCode' = "recoveryCode"
+}
+export interface MFAState {
+    step: MFAStep;
+    loading: boolean;
+    error?: any;
+    recoveryCode?: string;
+    qrCode?: string | null;
+    mfaToken?: string;
+}

package/auth/MfaState/interfaces.js

@@ -0,0 +1,6 @@
+export let MFAStep;
+
+(function (MFAStep) {
+  MFAStep["verify"] = "verify";
+  MFAStep["recoveryCode"] = "recoveryCode";
+})(MFAStep || (MFAStep = {}));

package/auth/MfaState/saga.d.ts

@@ -1,2 +1,2 @@
-export declare function mfaSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
-export declare function mfaSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export declare function mfaSagas(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export declare function mfaSagasMock(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;

package/auth/MfaState/saga.js

@@ -0,0 +1,252 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+      _excluded2 = ["callback"],
+      _excluded3 = ["callback"];
+import { call, put, select, takeEvery } from 'redux-saga/effects';
+import { api } from '@frontegg/rest-api';
+import { actions } from '../reducer';
+import { MFAStep } from './interfaces';
+import { delay } from '../utils';
+import { userDemo } from '../dummy';
+
+function* enrollMfa() {
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+
+  try {
+    const {
+      qrCode
+    } = yield call(api.auth.enrollMfa);
+    yield put(actions.setMfaState({
+      loading: false,
+      error: undefined,
+      qrCode
+    }));
+  } catch (e) {
+    yield put(actions.setMfaState({
+      loading: false,
+      error: e.message
+    }));
+  }
+}
+
+function* verifyMfa(_ref) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref,
+      payload = _objectWithoutPropertiesLoose(_ref.payload, _excluded);
+
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+
+  try {
+    const user = yield select(state => state.auth.user);
+    const data = yield call(api.auth.verifyMfa, payload);
+    const mfaState = {
+      step: MFAStep.recoveryCode,
+      loading: false,
+      error: undefined
+    };
+
+    if (data != null && data.recoveryCode) {
+      mfaState.recoveryCode = data.recoveryCode;
+    }
+
+    yield put(actions.setMfaState(mfaState));
+    yield put(actions.setUser(_extends({}, user, {
+      mfaEnrolled: true
+    })));
+    callback == null ? void 0 : callback(mfaState.recoveryCode);
+  } catch (e) {
+    yield put(actions.setMfaState({
+      loading: false,
+      error: e.message
+    }));
+    callback == null ? void 0 : callback(null, e);
+  }
+}
+
+function* verifyMfaAfterForce(_ref2) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref2,
+      payload = _objectWithoutPropertiesLoose(_ref2.payload, _excluded2);
+
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+
+  try {
+    const user = yield call(api.auth.loginWithMfa, payload);
+    const mfaState = {
+      step: MFAStep.recoveryCode,
+      loading: false,
+      error: undefined
+    };
+
+    if (user != null && user.recoveryCode) {
+      mfaState.recoveryCode = user.recoveryCode;
+    }
+
+    yield put(actions.setMfaState(mfaState));
+    yield put(actions.setState({
+      user
+    }));
+    yield put(actions.loadTenants());
+    callback == null ? void 0 : callback(mfaState.recoveryCode);
+  } catch (e) {
+    yield put(actions.setMfaState({
+      loading: false,
+      error: e.message
+    }));
+    callback == null ? void 0 : callback(null, e);
+  }
+}
+
+function* disableMfa({
+  payload
+}) {
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+
+  try {
+    var _payload$callback;
+
+    const user = yield select(state => state.auth.user);
+    yield api.auth.disableMfa(payload);
+    yield put(actions.setMfaState({
+      loading: false,
+      error: undefined
+    }));
+    yield put(actions.setUser(_extends({}, user, {
+      mfaEnrolled: false
+    })));
+    (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+  } catch (e) {
+    var _payload$callback2;
+
+    yield put(actions.setMfaState({
+      loading: false,
+      error: e.message
+    }));
+    (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, false, e);
+  }
+}
+
+export function* mfaSagas() {
+  yield takeEvery(actions.enrollMfa, enrollMfa);
+  yield takeEvery(actions.verifyMfa, verifyMfa);
+  yield takeEvery(actions.disableMfa, disableMfa);
+  yield takeEvery(actions.verifyMfaAfterForce, verifyMfaAfterForce);
+}
+
+function* enrollMfaMock() {
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+  const qrCode = 'test';
+  yield put(actions.setMfaState({
+    loading: false,
+    error: undefined,
+    qrCode
+  }));
+}
+
+function* verifyMfaMock({
+  payload: {
+    callback
+  }
+}) {
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+  yield delay();
+  const data = {
+    token: 'token',
+    recoveryCode: 'recoveryCode'
+  };
+  const mfaState = {
+    step: MFAStep.recoveryCode,
+    loading: false,
+    error: undefined
+  };
+
+  if (data != null && data.recoveryCode) {
+    mfaState.recoveryCode = data.recoveryCode;
+  }
+
+  yield put(actions.setMfaState(mfaState));
+  yield put(actions.setUser(_extends({}, userDemo, {
+    mfaEnrolled: true
+  })));
+  callback == null ? void 0 : callback(mfaState.recoveryCode);
+}
+
+function* verifyMfaAfterForceMock(_ref3) {
+  let {
+    payload: {
+      callback
+    }
+  } = _ref3,
+      payload = _objectWithoutPropertiesLoose(_ref3.payload, _excluded3);
+
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+  yield delay();
+
+  const data = _extends({}, payload, {
+    recoveryCode: 'recoveryCode'
+  });
+
+  const mfaState = {
+    step: MFAStep.recoveryCode,
+    loading: false,
+    error: undefined
+  };
+
+  if (data != null && data.recoveryCode) {
+    mfaState.recoveryCode = data.recoveryCode;
+  }
+
+  yield put(actions.setMfaState(mfaState));
+  yield delay();
+  yield put(actions.setUser(_extends({}, userDemo, {
+    mfaEnrolled: true
+  })));
+  callback == null ? void 0 : callback(mfaState.recoveryCode);
+}
+
+function* disableMfaMock({
+  payload
+}) {
+  var _payload$callback3;
+
+  yield put(actions.setMfaState({
+    loading: true
+  }));
+  yield delay();
+  yield put(actions.setMfaState({
+    loading: false,
+    error: undefined
+  }));
+  yield put(actions.setUser(_extends({}, userDemo, {
+    mfaEnrolled: false
+  })));
+  (_payload$callback3 = payload.callback) == null ? void 0 : _payload$callback3.call(payload, true);
+}
+
+export function* mfaSagasMock() {
+  yield takeEvery(actions.enrollMfa, enrollMfaMock);
+  yield takeEvery(actions.verifyMfa, verifyMfaMock);
+  yield takeEvery(actions.disableMfa, disableMfaMock);
+  yield takeEvery(actions.verifyMfaAfterForce, verifyMfaAfterForceMock);
+}