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

package/mocks/auth-mocks/sessionsActions.mocks.js

@@ -0,0 +1,44 @@
+import { sessionsMock } from '../dummy';
+import { buildSessionsActions } from '../../auth/SessionsState';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildSessionsActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setSessionsState', 'resetSessionsState']);
+  mockedActions.loadUserSessions = async () => {
+    mockedActions.setSessionsState({
+      loading: true,
+      error: null
+    });
+    mockedActions.setSessionsState({
+      sessions: sessionsMock,
+      loading: false
+    });
+  };
+  mockedActions.deleteUserSession = async payload => {
+    const {
+      id
+    } = payload;
+    mockedActions.setSessionsState({
+      loading: true,
+      error: null
+    });
+    const currentSessions = store.auth.sessionsState.sessions;
+    const newSessions = currentSessions.filter(s => s.id !== id);
+    mockedActions.setSessionsState({
+      sessions: newSessions,
+      loading: false
+    });
+  };
+  mockedActions.deleteAllUserSessions = async () => {
+    mockedActions.setSessionsState({
+      loading: true,
+      error: null
+    });
+    const newSessions = sessionsMock.filter(s => s.current);
+    mockedActions.setSessionsState({
+      sessions: newSessions,
+      loading: false
+    });
+  };
+  return mockedActions;
+});

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

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

package/mocks/auth-mocks/signUpActions.mocks.js

@@ -0,0 +1,6 @@
+import { mockActionsExpect } from '../helpers';
+import { buildSignUpActions } from '../../auth/SignUpState';
+export default ((store, api, actions) => {
+  const originalActions = buildSignUpActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setSignUpState', 'resetSignUpState', 'resetSignUpStateSoft']);
+});

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

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

package/mocks/auth-mocks/smsActions.mocks.js

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

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

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

package/mocks/auth-mocks/socialLoginActions.mocks.js

@@ -0,0 +1,6 @@
+import { buildSocialLoginActions } from '../../auth/SocialLoginState';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildSocialLoginActions(store, api, actions);
+  return mockActionsExpect(originalActions, ['setSocialLoginsState', 'resetSocialLoginsState', 'setSocialLoginError']);
+});

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

@@ -0,0 +1,77 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { SSOState } from '../../auth';
+import { ISamlConfiguration } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    loadSSOConfigurationsV2: () => Promise<void>;
+    saveSSOConfigurationV2: (payload: WithCallback<Partial<Pick<import("@frontegg/rest-api").ISSOConfiguration, "roleIds" | "type" | "groups" | "generatedVerification" | "enabled" | "ssoEndpoint" | "publicCertificate" | "signRequest" | "acsUrl" | "spEntityId" | "oidcClientId" | "oidcSecret" | "skipEmailDomainValidation">>, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    updateSSOConfiguration: (payload: WithCallback<Partial<Pick<import("@frontegg/rest-api").ISSOConfiguration, "roleIds" | "type" | "groups" | "generatedVerification" | "enabled" | "ssoEndpoint" | "publicCertificate" | "signRequest" | "acsUrl" | "spEntityId" | "oidcClientId" | "oidcSecret" | "skipEmailDomainValidation">> & {
+        ssoConfigId: string;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    deleteSSOConfiguration: (payload: WithCallback<{
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    saveSSODomain: (payload: WithCallback<import("@frontegg/rest-api").ICreateSSODomain & {
+        ssoConfigId: string;
+    }, import("@frontegg/rest-api").ISSODomain>) => Promise<void>;
+    deleteSSODomain: (payload: WithCallback<{
+        domainId: string;
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    validateSSODomainV2: (payload: WithCallback<{
+        domainId: string;
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    setSSOGroups: (payload: WithCallback<{
+        ssoConfigId: string;
+        groupsToAdd: import("@frontegg/rest-api").ICreateSamlGroup[];
+        groupsToDelete: string[];
+    }, boolean>) => Promise<void>;
+    updateSSOGroups: (payload: WithCallback<{
+        ssoConfigId: string;
+        changedGroups: import("@frontegg/rest-api").IUpdateSamlGroup[];
+    }, boolean>) => Promise<void>;
+    setSSODefaultRoles: (payload: WithCallback<{
+        roleIds: string[];
+        ssoConfigId: string;
+    }, boolean>) => Promise<void>;
+    saveSSOConfigurationByMetadata: (payload: WithCallback<{
+        configFile: File;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    updateSSOConfigurationByMetadata: (payload: WithCallback<{
+        configFile: File;
+        ssoConfigId: string;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    saveSSOConfigurationByUrl: (payload: WithCallback<{
+        ssoConfigId?: string | undefined;
+        configMetadata?: Record<string, string> | undefined;
+        metadataUrl: string;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    saveSSOConfigurationByData: (payload: WithCallback<Partial<import("@frontegg/rest-api").ISSOConfiguration> & {
+        ssoConfigId?: string | undefined;
+        configMetadata?: Record<string, string> | undefined;
+    }, import("@frontegg/rest-api").ISSOConfiguration>) => Promise<void>;
+    setSSOState: (state: Partial<SSOState>) => void;
+    resetSSOState: () => void;
+    setSSOLoader: (payload: import("../../auth").SSOStateIndicator) => void;
+    setSSOError: (payload: import("../../auth").SSOStateIndicator) => void;
+    loadSSOConfigurations: () => Promise<void>;
+    saveSSOConfigurations: (payload: WithCallback<Partial<Pick<ISamlConfiguration, "type" | "enabled" | "domain" | "ssoEndpoint" | "publicCertificate" | "signRequest" | "acsUrl" | "spEntityId" | "isSamlActive" | "oidcClientId" | "oidcSecret"> & {
+        samlVendor: import("../../auth").SamlVendors;
+    }>, boolean>) => Promise<void>;
+    saveSSOConfigurationsFile: (configFile: File[]) => Promise<void>;
+    saveSSOConfigurationsFileWithCallback: (payload: WithCallback<{
+        configFile: File;
+    }, boolean>) => Promise<void>;
+    validateSSODomain: (payload?: WithCallback<object, boolean> | undefined) => Promise<void>;
+    loadSSOAuthorizationRoles: () => Promise<void>;
+    updateSSOAuthorizationRoles: (payload: WithCallback<{
+        authorizationRoles: string[];
+        groups?: import("@frontegg/rest-api").ISamlRolesGroup[] | undefined;
+    }, boolean>) => Promise<void>;
+    deleteSamlGroup: (payload: WithCallback<{
+        id: string;
+    }, boolean>) => Promise<void>;
+    createSamlGroup: (payload: WithCallback<import("@frontegg/rest-api").ICreateSamlGroup, boolean>) => Promise<void>;
+    oidcPostlogin: (payload: import("@frontegg/rest-api").IOidcPostLogin) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/ssoActions.mocks.js

@@ -0,0 +1,128 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["callback", "samlVendor"];
+import { delay, omitProps } from '../../helpers';
+import { samlConfigurationDemo, samlMetadataDemo, ssoStateDemo } from '../dummy';
+import { buildSSOActions } from '../../auth/SSOState';
+import { mockActionsExpect } from '../helpers';
+export default ((store, api, actions) => {
+  const originalActions = buildSSOActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setSSOState', 'resetSSOState']);
+  mockedActions.loadSSOConfigurations = async () => {
+    mockedActions.setSSOState({
+      loading: true
+    });
+    await delay();
+    mockedActions.setSSOState({
+      samlConfiguration: samlConfigurationDemo,
+      loading: false,
+      firstLoad: false
+    });
+  };
+  mockedActions.saveSSOConfigurations = async payload => {
+    var _samlMetadataDemo$con, _samlMetadataDemo$con2;
+    const {
+        callback,
+        samlVendor
+      } = payload,
+      newSamlConfiguration = _objectWithoutPropertiesLoose(payload, _excluded);
+    const oldSamlConfiguration = ssoStateDemo.samlConfiguration;
+    const samlConfiguration = _extends({}, oldSamlConfiguration, newSamlConfiguration);
+    let loaderKey = 'saving';
+    if ((samlConfiguration == null ? void 0 : samlConfiguration.enabled) !== oldSamlConfiguration.enabled) {
+      loaderKey = 'loading';
+    }
+    const firstTimeConfigure = !(samlConfiguration != null && samlConfiguration.domain);
+    if (firstTimeConfigure) {
+      mockedActions.setSSOState({
+        samlConfiguration: _extends({}, oldSamlConfiguration, samlConfiguration)
+      });
+      return;
+    } else {
+      mockedActions.setSSOState({
+        error: undefined,
+        [loaderKey]: true
+      });
+    }
+    await delay();
+    samlConfiguration.acsUrl = samlMetadataDemo == null ? void 0 : (_samlMetadataDemo$con = samlMetadataDemo.configuration) == null ? void 0 : _samlMetadataDemo$con.acsUrl;
+    samlConfiguration.spEntityId = samlMetadataDemo == null ? void 0 : (_samlMetadataDemo$con2 = samlMetadataDemo.configuration) == null ? void 0 : _samlMetadataDemo$con2.spEntityId;
+    const updateSamlConfiguration = omitProps(samlConfiguration, ['validated', 'generatedVerification', 'createdAt', 'updatedAt']);
+    if ((oldSamlConfiguration == null ? void 0 : oldSamlConfiguration.domain) !== (updateSamlConfiguration == null ? void 0 : updateSamlConfiguration.domain)) {
+      updateSamlConfiguration.ssoEndpoint = '';
+      updateSamlConfiguration.publicCertificate = '';
+      updateSamlConfiguration.signRequest = false;
+    }
+    updateSamlConfiguration.type = samlVendor == null ? void 0 : samlVendor.toLowerCase();
+    await delay();
+    mockedActions.setSSOState({
+      samlConfiguration: updateSamlConfiguration,
+      error: undefined,
+      [loaderKey]: false
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  mockedActions.saveSSOConfigurationsFile = async configFile => {
+    const loaderKey = 'saving';
+    mockedActions.setSSOState({
+      error: undefined,
+      [loaderKey]: true
+    });
+    const oldSamlConfiguration = store.auth.ssoState.samlConfiguration;
+    const newSamlConfiguration = _extends({}, oldSamlConfiguration, {
+      enabled: true
+    }, configFile[0]);
+    mockedActions.setSSOState({
+      samlConfiguration: newSamlConfiguration,
+      error: undefined,
+      [loaderKey]: false
+    });
+  };
+  mockedActions.validateSSODomain = async payload => {
+    const {
+      callback
+    } = payload != null ? payload : {};
+    const samlConfiguration = ssoStateDemo.samlConfiguration;
+    mockedActions.setSSOState({
+      error: undefined,
+      saving: true
+    });
+    await delay();
+    mockedActions.setSSOState({
+      samlConfiguration: _extends({}, samlConfiguration, {
+        validated: true
+      }),
+      error: undefined,
+      saving: false
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  mockedActions.loadSSOAuthorizationRoles = async () => {
+    await delay();
+    const data = {
+      roleIds: ['1', '2', '3']
+    };
+    mockedActions.setSSOState({
+      authorizationRoles: data.roleIds,
+      error: undefined
+    });
+  };
+  mockedActions.updateSSOAuthorizationRoles = async payload => {
+    const {
+      callback,
+      authorizationRoles
+    } = payload;
+    mockedActions.setSSOState({
+      error: undefined,
+      saving: true
+    });
+    await delay();
+    mockedActions.setSSOState({
+      authorizationRoles,
+      error: undefined,
+      saving: false
+    });
+    callback == null ? void 0 : callback(true);
+  };
+  return mockedActions;
+});

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

@@ -0,0 +1,15 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    stepUpHostedLogin: (payload: import("../..").IStepUpHostedLogin) => Promise<void>;
+    generateStepUpSession: (payload: import("../../interfaces").WithCallback<import("../..").IGenerateStepUpSession, boolean>) => Promise<void>;
+    setStepUpState: (state: Partial<import("../..").StepUpState>) => void;
+    resetStepUpState: () => void;
+    stepUpWithAuthenticator: (payload: import("../../interfaces").WithCallback<import("../..").IStepUpWithAuthenticator, boolean>) => Promise<void>;
+    preVerifyMFASMSForStepUp: (payload: import("../../interfaces").WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, boolean>) => Promise<void>;
+    verifyMFASMSForStepUp: (payload: import("../../interfaces").WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IVerifyMFASMS>, boolean>) => Promise<void>;
+    preVerifyMFAWebAuthnForStepUp: (payload: import("../../interfaces").WithCallback<import("../..").WithDeviceId<import("@frontegg/rest-api").IPreVerifyMFA>, import("../..").IPreVerifyMFAWebAuthNForLoginResponse>) => Promise<void>;
+    verifyMFAWebAuthnForStepUp: (payload: import("../..").IVerifyMFAWebAuthnPayload) => Promise<void>;
+    preVerifyMFAEmailCodeForStepUp: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IPreVerifyMFA, boolean>) => Promise<void>;
+    verifyMFAEmailCodeForStepUp: (payload: import("../../interfaces").WithCallback<import("@frontegg/rest-api").IVerifyMFAEmailCode, boolean>) => Promise<void>;
+};
+export default _default;

package/mocks/auth-mocks/stepUpActions.mocks.js

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

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

@@ -0,0 +1,52 @@
+import { FronteggState, RestApi, SharedActions, WithCallback, WithSilentLoad } from '../../interfaces';
+import { IGetUsersV2Payload } from '../../auth';
+import { AddUserToSubTenantsRequest, IDeleteUser, ILoadAllUsers, IResendActivationLink, IResendInvitationEmail, IResendInvitationLink, ISubTenantUser, ITeamUser, IUpdateUserExpiration, RemoveUserFromSubTenantsRequest } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    getInvitationLink: () => Promise<void>;
+    createInvitationLink: (payload: WithCallback<import("@frontegg/rest-api").ICreateOrUpdateInviteUserLink, string>) => Promise<void>;
+    updateInvitationLink: (payload: WithCallback<import("@frontegg/rest-api").ICreateOrUpdateInviteUserLink, boolean>) => Promise<void>;
+    deleteInvitationLink: (payload?: {
+        callback?: import("../../interfaces").CallbackMethod<boolean> | undefined;
+    } | undefined) => Promise<void>;
+    resendActivationLink: (payload: WithCallback<IResendActivationLink, boolean>) => Promise<void>;
+    resendInvitationLink: (payload: WithCallback<IResendInvitationLink, boolean>) => Promise<void>;
+    resendInvitationEmail: (payload: WithCallback<IResendInvitationEmail, boolean>) => Promise<void>;
+    resendInvitationLinkToAllSubTenants: (payload: WithCallback<IResendInvitationLink, boolean>) => Promise<void>;
+    loadAllSubTenantsUsers: (payload: WithCallback<WithSilentLoad<Partial<ILoadAllUsers>>, ISubTenantUser[]>) => Promise<void>;
+    setUserRolesForSubTenants: (payload: WithCallback<import("@frontegg/rest-api").UpdateUserRolesForSubTenantsRequestDto & {
+        userId: string;
+    }, boolean>) => Promise<void>;
+    deleteUserFromSubTenants: (payload: WithCallback<RemoveUserFromSubTenantsRequest, boolean>) => Promise<void>;
+    addUserToSubTenants: (payload: WithCallback<AddUserToSubTenantsRequest, boolean>) => Promise<void>;
+    loadRoles: (payload?: {
+        callback?: import("../../interfaces").CallbackMethod<{
+            roles: import("@frontegg/rest-api").ITeamUserRole[];
+            permissions: import("@frontegg/rest-api").ITeamUserPermission[];
+        }> | undefined;
+    } | undefined) => Promise<void>;
+    loadUsers: (payload: WithCallback<WithSilentLoad<import("@frontegg/rest-api").ILoadUsers>, ITeamUser[]>) => Promise<void>;
+    loadUsersV2: (payload: WithCallback<WithSilentLoad<IGetUsersV2Payload>, ITeamUser[]>) => Promise<void>;
+    addUser: (payload: WithCallback<import("../../auth").AddUserPayload, ITeamUser>) => Promise<void>;
+    addUsersBulk: (payload: WithCallback<import("../../auth").IAddUsers, import("../../auth").BulkInvintationData>) => Promise<void>;
+    updateUser: (payload: WithCallback<Partial<ITeamUser>, ITeamUser>) => Promise<void>;
+    deleteUser: (payload: WithCallback<IDeleteUser, boolean>) => Promise<void>;
+    enableUser: (payload: WithCallback<{
+        userId: string;
+    }, boolean>) => Promise<void>;
+    disableUser: (payload: WithCallback<{
+        userId: string;
+    }, boolean>) => Promise<void>;
+    getTemporaryUsersConfig: () => Promise<void>;
+    updateUserExpirationTime: (payload: WithCallback<IUpdateUserExpiration, boolean>) => Promise<void>;
+    setUserAsPermanent: (payload: WithCallback<Pick<IUpdateUserExpiration, "userId">, boolean>) => Promise<void>;
+    setTeamLoader: (payload: import("../../auth").TeamStateIndicator) => void;
+    setTeamError: (payload: import("../../auth").TeamStateIndicator) => void;
+    setTeamState: (payload: Partial<import("../../auth").TeamState>) => void;
+    resetTeamState: () => void;
+    openAddUserDialog: (payload?: Pick<import("../../auth").AddUserDialogState, "onClose"> | undefined) => void;
+    closeAddUserDialog: (payload?: any) => void;
+    openDeleteUserDialog: (payload?: Pick<import("../../auth").DeleteUserDialogState, "userId" | "onClose" | "email"> | undefined) => void;
+    closeDeleteUserDialog: (payload?: any) => void;
+    lockUser: (payload: WithCallback<IDeleteUser, boolean>) => Promise<void>;
+};
+export default _default;