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

package/mocks/auth-mocks/mfaActions.mocks.js

@@ -0,0 +1,220 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback"],
+  _excluded2 = ["callback"];
+import { MFAStep } from '../../auth';
+import { delay, errorHandler } from '../../helpers';
+import { buildMfaActions } from '../../auth/MfaState';
+import { userDemo } from '../dummy';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const originalActions = buildMfaActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setMfaState', 'resetMfaState']);
+  mockedActions.enrollMfa = async () => {
+    mockedActions.setMfaState({
+      saving: true
+    });
+    const qrCode = 'test';
+    mockedActions.setMfaState({
+      saving: false,
+      error: undefined,
+      qrCode
+    });
+  };
+  mockedActions.verifyMfa = async _payload => {
+    const {
+        callback
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded);
+    const {
+      mfaDevices = {
+        webauthn: [],
+        phones: [],
+        authenticators: [],
+        emails: []
+      }
+    } = store.auth.mfaState;
+    mockedActions.setMfaState({
+      saving: true
+    });
+    await delay();
+    const data = {
+      token: 'token',
+      recoveryCode: 'recoveryCode'
+    };
+    const mfaState = {
+      step: MFAStep.recoveryCode,
+      loading: false,
+      error: undefined,
+      saving: false,
+      mfaDevices: _extends({}, mfaDevices, {
+        authenticators: [{
+          id: 'authenticator-id'
+        }]
+      })
+    };
+    if (data != null && data.recoveryCode) {
+      mfaState.recoveryCode = data.recoveryCode;
+    }
+    mockedActions.setMfaState(mfaState);
+    actions.setUser(_extends({}, userDemo, {
+      mfaEnrolled: true
+    }));
+    callback == null ? void 0 : callback(mfaState.recoveryCode);
+  };
+  mockedActions.disableMfa = async payload => {
+    var _payload$callback;
+    const {
+      mfaDevices = {
+        webauthn: [],
+        phones: [],
+        authenticators: [],
+        emails: []
+      }
+    } = store.auth.mfaState;
+    mockedActions.setMfaState({
+      saving: true
+    });
+    await delay();
+    mockedActions.setMfaState({
+      saving: false,
+      error: undefined,
+      mfaDevices: _extends({}, mfaDevices, {
+        authenticators: []
+      })
+    });
+    actions.setUser(_extends({}, userDemo));
+    (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+  };
+  mockedActions.verifyMfaAfterForce = async _payload => {
+    const {
+        callback
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded2);
+    mockedActions.setMfaState({
+      loading: true
+    });
+    await delay();
+    const data = _extends({}, payload, {
+      recoveryCode: 'recoveryCode'
+    });
+    const mfaState = {
+      step: MFAStep.recoveryCode,
+      loading: false,
+      error: undefined,
+      saving: false
+    };
+    if (data != null && data.recoveryCode) {
+      mfaState.recoveryCode = data.recoveryCode;
+    }
+    mockedActions.setMfaState(mfaState);
+    await delay();
+    actions.setUser(_extends({}, userDemo, {
+      mfaEnrolled: true
+    }));
+    callback == null ? void 0 : callback(mfaState.recoveryCode);
+  };
+  mockedActions.preDisableMfaSms = async payload => {
+    mockedActions.setMfaState({
+      saving: true
+    });
+    try {
+      var _payload$callback2;
+      mockedActions.setMfaState({
+        saving: false,
+        error: undefined,
+        otcToken: 'otc-token',
+        phoneNumber: '+972504589346'
+      });
+      (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, true);
+    } catch (e) {
+      var _payload$callback3;
+      mockedActions.setMfaState({
+        saving: false,
+        error: errorHandler(e)
+      });
+      (_payload$callback3 = payload.callback) == null ? void 0 : _payload$callback3.call(payload, false, e);
+    }
+  };
+  mockedActions.disableMfaSms = async payload => {
+    var _payload$callback4;
+    const {
+      mfaDevices = {
+        webauthn: [],
+        phones: [],
+        authenticators: [],
+        emails: []
+      }
+    } = store.auth.mfaState;
+    mockedActions.setMfaState({
+      saving: true
+    });
+    await delay();
+    mockedActions.setMfaState({
+      loading: false,
+      error: undefined,
+      mfaDevices: _extends({}, mfaDevices, {
+        phones: []
+      })
+    });
+    actions.setUser(_extends({}, userDemo));
+    (_payload$callback4 = payload.callback) == null ? void 0 : _payload$callback4.call(payload, true);
+  };
+  mockedActions.preEnrollMfaSms = async payload => {
+    var _payload$callback5;
+    mockedActions.setMfaState({
+      saving: true
+    });
+    await delay();
+    mockedActions.setMfaState({
+      saving: false,
+      error: undefined,
+      otcToken: 'otc-token',
+      phoneNumber: '+972504589346'
+    });
+    (_payload$callback5 = payload.callback) == null ? void 0 : _payload$callback5.call(payload, true);
+  };
+  mockedActions.enrollMfaSms = async _payload => {
+    const {
+      callback
+    } = _payload;
+    const {
+      mfaDevices = {
+        webauthn: [],
+        phones: [],
+        authenticators: [],
+        emails: []
+      }
+    } = store.auth.mfaState;
+    mockedActions.setMfaState({
+      saving: true
+    });
+    await delay();
+    const data = {
+      token: 'token',
+      recoveryCode: 'recoveryCode'
+    };
+    const mfaState = {
+      step: MFAStep.recoveryCode,
+      loading: false,
+      error: undefined,
+      saving: false,
+      mfaDevices: _extends({}, mfaDevices, {
+        phones: [{
+          id: 'phone-id',
+          phoneNumber: '+972504589346'
+        }]
+      })
+    };
+    if (data != null && data.recoveryCode) {
+      mfaState.recoveryCode = data.recoveryCode;
+    }
+    mockedActions.setMfaState(mfaState);
+    actions.setUser(_extends({}, userDemo, {
+      mfaEnrolled: true
+    }));
+    callback == null ? void 0 : callback(mfaState.recoveryCode);
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/passkeysActions.mocks.d.ts

@@ -0,0 +1,11 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setPasskeysState: (payload: Partial<import("../..").PasskeysState>) => void;
+    resetPasskeysState: () => void;
+    loadWebAuthnDevices: () => Promise<void>;
+    deleteWebAuthnDevice: (_payload: import("../../interfaces").WithCallback<{
+        deviceId: string;
+    }, boolean>) => Promise<void>;
+    __shouldShowPromptPasskeys: () => Promise<boolean>;
+};
+export default _default;

package/mocks/auth-mocks/passkeysActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildPasskeysActions } from '../../auth/PasskeysState';
+export default ((store, api, actions) => {
+  const originalActions = buildPasskeysActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setPasskeysState', 'resetPasskeysState']);
+});

package/mocks/auth-mocks/profileActions.mocks.d.ts

@@ -0,0 +1,10 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { IChangePassword } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setProfileState: (state: Partial<import("../../auth").ProfileState>) => void;
+    resetProfileState: () => void;
+    loadProfile: () => Promise<void>;
+    saveProfile: (_payload: Partial<WithCallback<import("@frontegg/rest-api").IGetUsersV2Response, import("@frontegg/rest-api").IGetUsersV2Response>>) => Promise<void>;
+    changePassword: (payload: WithCallback<IChangePassword, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/profileActions.mocks.js

@@ -0,0 +1,67 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["callback", "profilePictureUrl"];
+import { buildProfileActions } from '../../auth/ProfileState';
+import { delay } from '../../helpers';
+import { profileStateDemo, userDemo, userProfileDemo } from '../dummy';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildProfileActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setProfileState', 'resetProfileState']);
+  mockedActions.loadProfile = async () => {
+    mockedActions.setProfileState({
+      loading: true
+    });
+    await delay();
+    actions.setUser(_extends({}, userDemo, userProfileDemo));
+    mockedActions.setProfileState({
+      loading: false,
+      profile: userProfileDemo
+    });
+  };
+  mockedActions.saveProfile = async _payload => {
+    const {
+        callback,
+        profilePictureUrl
+      } = _payload,
+      payload = _objectWithoutPropertiesLoose(_payload, _excluded);
+    mockedActions.setProfileState({
+      saving: true,
+      error: null
+    });
+    const oldProfileData = profileStateDemo;
+    let newProfilePictureUrl = oldProfileData.profile.profilePictureUrl;
+    if (profilePictureUrl !== oldProfileData.profile.profilePictureUrl && profilePictureUrl) {
+      const matchResult = (profilePictureUrl || '').match(/^data:image\/([A-Za-z-+\/]+);base64,(.+)$/);
+      if (matchResult) {
+        newProfilePictureUrl = profilePictureUrl;
+      }
+    }
+    const newProfileData = _extends({}, oldProfileData.profile, payload, {
+      profilePictureUrl: newProfilePictureUrl
+    });
+    const currentUser = userDemo;
+    await delay();
+    actions.setUser(_extends({}, currentUser, newProfileData));
+    mockedActions.setProfileState({
+      loading: false,
+      error: null,
+      saving: false,
+      profile: newProfileData
+    });
+    callback == null ? void 0 : callback(newProfileData);
+  };
+  mockedActions.changePassword = async payload => {
+    var _payload$callback;
+    mockedActions.setProfileState({
+      loading: true
+    });
+    await delay();
+    mockedActions.setProfileState({
+      loading: false,
+      error: undefined
+    });
+    (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/provisioningActions.mocks.d.ts

@@ -0,0 +1,19 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setProvisioningState: (state: Partial<import("../..").ProvisioningState>) => void;
+    resetProvisioningState: () => void;
+    __loadCountForConnection: (connection: import("@frontegg/rest-api").Scim2ConnectionConfigResponse) => Promise<{
+        count: number;
+        id: string;
+        connectionName: string;
+        source: import("@frontegg/rest-api").ScimConnectionSource;
+        syncToUserManagement: boolean;
+        createdAt: Date;
+        lastSync?: Date | null | undefined;
+    }>;
+    loadProvisionConnections: () => Promise<void>;
+    createProvisionConnection: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").Scim2CreateConnectionConfigRequest, import("@frontegg/rest-api").Scim2CreateConnectionConfigResponse>) => Promise<void>;
+    deleteProvisionConnection: (payload: import("../../interfaces").WithCallback<import("../../interfaces").WithId<object>, boolean>) => Promise<void>;
+    updateProvisionConnection: (payload: import("../../interfaces").WithId<import("@frontegg/rest-api").Scim2PatchConnectionConfigRequest>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/provisioningActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildProvisioningActions } from '../../auth/ProvisioningState';
+export default ((store, api, actions) => {
+  const originalActions = buildProvisioningActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setProvisioningState', 'resetProvisioningState']);
+});

package/mocks/auth-mocks/resetPhoneNumberActions.mocks.d.ts

@@ -0,0 +1,12 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setResetPhoneNumberState: (state: Partial<import("../..").ResetPhoneNumberState>) => void;
+    resetResetPhoneNumberState: () => void;
+    resetPhoneNumber: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IResetPhoneNumber, boolean>) => Promise<void>;
+    verifyResetPhoneNumber: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IVerifyResetPhoneNumber, boolean>) => Promise<void>;
+    changePhoneNumber: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IChangePhoneNumber & {
+        recaptchaToken?: string | undefined;
+        email: string;
+    }, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/resetPhoneNumberActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildResetPhoneNumberActions } from '../../auth/ResetPhoneNumberState';
+export default ((store, api, actions) => {
+  const originalActions = buildResetPhoneNumberActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setResetPhoneNumberState', 'resetResetPhoneNumberState']);
+});

package/mocks/auth-mocks/rolesActions.mocks.d.ts

@@ -0,0 +1,17 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setRolesState: (state: Partial<import("../../auth").RolesState>) => void;
+    setRolesStateLoader: (payload: import("../../auth").RolesStateIndicator) => void;
+    setRolesStateError: (payload: import("../../auth").RolesStateIndicator) => void;
+    resetRolesState: () => void;
+    loadRolesAndPermissions: (payload?: {
+        silentLoading?: boolean | undefined;
+    } | undefined) => Promise<void>;
+    addRole: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IAddRole, import("@frontegg/rest-api").IRole>) => Promise<void>;
+    addRoleV2: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IAddRoleV2, import("@frontegg/rest-api").IRole>) => Promise<void>;
+    updateRole: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IUpdateRole, import("@frontegg/rest-api").IRole>) => Promise<void>;
+    deleteRole: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IDeleteRole, boolean>) => Promise<void>;
+    attachPermissionsToRole: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IAttachPermissionsToRole, import("@frontegg/rest-api").IRole>) => Promise<void>;
+    attachPermissionToRoles: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IAttachPermissionToRoles, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/rolesActions.mocks.js

@@ -0,0 +1,33 @@
+import { RolesStateKeys } from '../../auth';
+import { errorHandler } from '../../helpers';
+import { buildRolesActions } from '../../auth/RolesState';
+import { rolesAdminViewerDemo } from '../dummy';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildRolesActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setRolesState', 'setRolesStateError', 'setRolesStateLoader', 'resetRolesState']);
+  mockedActions.loadRolesAndPermissions = async payload => {
+    var _payload$silentLoadin;
+    const key = RolesStateKeys.LOAD_ROLES;
+    mockedActions.setRolesStateLoader({
+      key,
+      value: !((_payload$silentLoadin = payload == null ? void 0 : payload.silentLoading) != null ? _payload$silentLoadin : false)
+    });
+    try {
+      mockedActions.setRolesState({
+        roles: rolesAdminViewerDemo
+      });
+    } catch (e) {
+      mockedActions.setRolesStateError({
+        key,
+        value: errorHandler(e)
+      });
+    } finally {
+      mockedActions.setRolesStateLoader({
+        key,
+        value: false
+      });
+    }
+  };
+  return mockedActions;
+});

package/mocks/auth-mocks/security/restrictionsActions.mocks.d.ts

@@ -0,0 +1,23 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../../interfaces';
+import { CreateIpRestriction, IPRestrictionsConfig } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setRestrictionsState: (state: Partial<import("../../../auth").RestrictionsState>) => void;
+    setIpRestrictionsState: (state: Partial<import("../../../auth").IPRestrictionsState>) => void;
+    setEmailDomainRestrictionsState: (state: Partial<import("../../../auth").EmailDomainRestrictionsState>) => void;
+    __securityCenterSagaWrapper: <T>(action: T) => T;
+    loadIpRestrictions: () => Promise<void>;
+    saveIpRestriction: (payload: WithCallback<CreateIpRestriction, boolean>) => Promise<void>;
+    saveIpRestrictionsConfig: (payload: WithCallback<IPRestrictionsConfig, boolean>) => Promise<void>;
+    deleteIpRestriction: (payload: WithCallback<{
+        id: string;
+    }, boolean>) => Promise<void>;
+    checkIfUserIpValid: () => Promise<void>;
+    addCurrentUserIpAndActivate: (payload: WithCallback<object, boolean>) => Promise<void>;
+    loadEmailDomainRestrictions: () => Promise<void>;
+    saveEmailDomainRestriction: (payload: WithCallback<import("@frontegg/rest-api").CreateDomainRestriction, boolean>) => Promise<void>;
+    saveEmailDomainRestrictionsConfig: (payload: WithCallback<import("@frontegg/rest-api").UpdateDomainRestrictionsConfig, boolean>) => Promise<void>;
+    deleteEmailDomainRestriction: (payload: {
+        id: string;
+    }) => Promise<void>;
+};
+export default _default;