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

package/audits-backward-compatibility/actions.js

@@ -0,0 +1,256 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export const defaultItemsPerPage = 20;
+
+/** @deprecated use auditLogs instead of audits */
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setContext = payload => {
+    store.audits.context = payload;
+  };
+  const startLoading = () => {
+    store.audits.isLoading = true;
+  };
+  const setVirtualScroll = payload => {
+    store.audits.virtualScroll = payload;
+  };
+  const startRefresh = () => {
+    store.audits.isLoading = true;
+  };
+  const startFetching = () => {
+    store.audits.isFetchMore = true;
+  };
+  const finishLoading = () => {
+    store.audits.isLoading = false;
+  };
+  const startDownloadingCsv = () => {
+    store.audits.isDownloadingCsv = true;
+  };
+  const stopDownloadingCsv = () => {
+    store.audits.isDownloadingCsv = false;
+  };
+  const loadStatsSuccess = payload => {
+    store.audits.error = undefined;
+    store.audits.totalToday = payload.totalToday;
+    store.audits.severeThisWeek = payload.severeThisWeek;
+  };
+  const loadItemFailedAction = payload => {
+    var _store$audits$error;
+    store.audits.error = (_store$audits$error = store.audits.error) != null ? _store$audits$error : {};
+    Object.assign(store.audits.error, {
+      [payload.name]: payload.error
+    });
+  };
+  const loadMetadataSuccess = payload => {
+    store.audits.error = {};
+    store.audits.headerProps = payload.properties;
+    store.audits.themeAudits = payload.theme ? payload.theme.styles : {};
+  };
+  const loadAuditsSuccess = payload => {
+    store.audits.error = {};
+    store.audits.rowsData = payload.rowsData;
+    store.audits.lastUpdated = new Date();
+    store.audits.total = payload.total;
+  };
+  const fetchMoreSuccess = payload => {
+    store.audits.error = {};
+    store.audits.offset = payload.offset;
+    store.audits.currentPage = payload.currentPage;
+    store.audits.isFetchMore = false;
+  };
+  const setFilterData = payload => {
+    store.audits.filters = payload;
+    store.audits.currentPage = 0;
+    store.audits.offset = 0;
+    store.audits.isLoading = true;
+  };
+  const textSearch = payload => {
+    store.audits.filter = payload;
+    store.audits.currentPage = 0;
+    store.audits.offset = 0;
+    store.audits.isLoading = true;
+  };
+  const onPageChange = payload => {
+    store.audits.currentPage = payload - 1;
+    store.audits.offset = store.audits.currentPage * defaultItemsPerPage;
+    store.audits.isLoading = true;
+  };
+  const setDataSorting = payload => {
+    store.audits.sortBy = payload.sortBy;
+    store.audits.currentPage = 0;
+    store.audits.sortDirection = payload.sortDirection === 'asc' ? 'desc' : 'asc';
+    store.audits.offset = 0;
+    store.audits.isLoading = true;
+  };
+  const setPredefinedFilters = payload => {
+    store.audits.predefinedFilters = payload;
+    const filters = Object.keys(payload).map(key => ({
+      key,
+      value: payload[key]
+    }));
+    store.audits.filters = filters;
+  };
+  const __loadStats = async () => {
+    const {
+      sortBy,
+      sortDirection
+    } = store.audits;
+    try {
+      const stats = await api.audits.getAuditsStats({
+        sortBy,
+        sortDirection,
+        count: defaultItemsPerPage
+      });
+      loadStatsSuccess(stats);
+    } catch (e) {
+      const errorMessage = {
+        name: 'stats',
+        error: e
+      };
+      console.error('failed to load stats - ', e);
+      loadItemFailedAction(errorMessage);
+    }
+  };
+  const __loadMetadata = async () => {
+    try {
+      const result = await api.metadata.getAuditsMetadata();
+      loadMetadataSuccess(result);
+    } catch (e) {
+      const errorMessage = {
+        name: 'metadata',
+        error: e
+      };
+      console.error('failed to load metadata - ', e);
+      loadItemFailedAction(errorMessage);
+    }
+  };
+  const __filterToObject = arr => arr.reduce((res, curr) => {
+    res[curr.key] = curr.value;
+    return res;
+  }, {});
+
+  /** @deprecated use auditLogs instead of audits */
+  const loadAudits = async payload => {
+    const {
+      filters,
+      sortBy,
+      sortDirection,
+      filter,
+      offset,
+      virtualScroll
+    } = store.audits;
+    const {
+      appendMode = virtualScroll,
+      onlyOneLoad = true,
+      offset: incomeOffset = 0
+    } = payload || {};
+    const {
+      rowsData
+    } = appendMode ? store.audits : {
+      rowsData: []
+    };
+    try {
+      const f2o = __filterToObject(filters);
+      const {
+        data,
+        total
+      } = await api.audits.getAudits(_extends({}, virtualScroll && {
+        paginationMode: 'virtual'
+      }, {
+        sortDirection,
+        sortBy,
+        filter
+      }, f2o, {
+        // TODO: refactor once api become V2 with query field for virtual scroll
+        offset: virtualScroll ? rowsData.length + incomeOffset || rowsData.length + offset : incomeOffset || offset,
+        count: defaultItemsPerPage
+      }));
+      loadAuditsSuccess({
+        rowsData: [...rowsData, ...data],
+        total
+      });
+      if (onlyOneLoad) {
+        finishLoading();
+      }
+    } catch (e) {
+      const errorMessage = {
+        name: 'audits',
+        error: e
+      };
+      console.error('failed to load audits - ', e);
+      loadItemFailedAction(errorMessage);
+    }
+  };
+
+  /** @deprecated use auditLogs instead of audits */
+  const initData = async () => {
+    startLoading();
+    await Promise.all([__loadStats(), __loadMetadata(), loadAudits({
+      onlyOneLoad: false
+    })]);
+    finishLoading();
+  };
+
+  /** @deprecated use auditLogs instead of audits */
+  const removeFilter = async payload => {
+    const {
+      filters: allFilters
+    } = store.audits;
+    const removedFilterIndex = allFilters.findIndex(item => item.key === payload.key);
+    if (removedFilterIndex < 0) {
+      return;
+    }
+    const newFilters = [...allFilters.slice(0, removedFilterIndex), ...allFilters.slice(removedFilterIndex + 1)];
+    setFilterData(newFilters);
+  };
+
+  /** @deprecated use auditLogs instead of audits */
+  const filterData = async payload => {
+    const {
+      filters: allFilters
+    } = store.audits;
+    let filterIndex = allFilters.findIndex(item => item.key === payload.key);
+    if (filterIndex < 0) {
+      filterIndex = allFilters.length;
+    }
+    const newFilters = [...allFilters.slice(0, filterIndex), payload, ...allFilters.slice(filterIndex + 1)];
+    setFilterData(newFilters);
+  };
+
+  /** @deprecated use auditLogs instead of audits */
+  const exportCSV = async () => {
+    const {
+      filters,
+      sortBy,
+      sortDirection,
+      filter,
+      headerProps = []
+    } = store.audits;
+    const f2o = __filterToObject(filters);
+    startDownloadingCsv();
+    const outputFileName = `audits.csv`;
+    try {
+      await api.audits.exportAudits(_extends({
+        endpoint: 'csv/v2',
+        headerProps: headerProps,
+        sortDirection,
+        sortBy,
+        filter
+      }, f2o, {
+        offset: 0,
+        outputFileName
+      }));
+    } catch (e) {
+      console.error('failed to export audits - ', e);
+    } finally {
+      stopDownloadingCsv();
+    }
+  };
+  return {
+    initData,
+    loadAudits,
+    removeFilter,
+    filterData,
+    exportCSV
+    // deleteAudits, // not implemented
+  };
+});

package/audits-backward-compatibility/index.d.ts

@@ -0,0 +1,5 @@
+import createOldAuditsState from './state';
+import buildOldAuditsActions from './actions';
+/** @deprecated use auditLogs instead of audits */
+export declare type OldAuditsActions = ReturnType<typeof buildOldAuditsActions>;
+export { createOldAuditsState, buildOldAuditsActions };

package/audits-backward-compatibility/index.js

@@ -0,0 +1,6 @@
+import createOldAuditsState from './state';
+import buildOldAuditsActions from './actions';
+
+/** @deprecated use auditLogs instead of audits */
+
+export { createOldAuditsState, buildOldAuditsActions };

package/audits-backward-compatibility/interfaces.d.ts

@@ -0,0 +1,60 @@
+import { ContextOptions, AuditRowData, SortDirectionType } from '@frontegg/rest-api';
+/** @deprecated use auditLogs instead of audits */
+export interface DataSorting {
+    sortDirection: SortDirectionType;
+    sortBy: string;
+}
+/** @deprecated use auditLogs instead of audits */
+export interface HeaderProps {
+    chosen: boolean;
+    selected: boolean;
+    name: keyof AuditRowData;
+    type: string;
+    sortable: boolean;
+    filterable: boolean;
+    displayName: string;
+    showInTable: boolean;
+    showInMoreInfo: string;
+}
+/** @deprecated use auditLogs instead of audits */
+export interface Filter {
+    key: string;
+    value: string;
+}
+/** @deprecated use auditLogs instead of audits */
+export interface OldAuditsState {
+    total: number;
+    error?: {
+        metadata?: string;
+    };
+    offset: number;
+    filter: string;
+    sortBy: string;
+    filters: Filter[];
+    context: ContextOptions | null;
+    rowsData: AuditRowData[];
+    lastUpdated: Date;
+    isLoading: boolean;
+    totalToday: number;
+    headerProps: HeaderProps[];
+    themeAudits?: any;
+    currentPage: number;
+    isFetchMore: boolean;
+    sortDirection: SortDirectionType;
+    severeThisWeek: number;
+    predefinedFilters: {
+        [key: string]: string;
+    }[];
+    isDownloadingCsv?: boolean;
+    virtualScroll?: boolean;
+}
+/** @deprecated use auditLogs instead of audits */
+export interface LoadAudits {
+    count?: number;
+    sortBy?: string;
+    filter?: string | null;
+    offset?: number;
+    appendMode?: boolean;
+    onlyOneLoad?: boolean;
+    sortDirection?: SortDirectionType;
+}

package/audits-backward-compatibility/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/audits-backward-compatibility/index.js",
+  "types": "./index.d.ts"
+}

package/audits-backward-compatibility/state.d.ts

@@ -0,0 +1,5 @@
+import { OldAuditsState } from './interfaces';
+export declare const initialState: OldAuditsState;
+declare const _default: (overrideState?: Partial<OldAuditsState> | undefined) => OldAuditsState;
+/** @deprecated use auditLogs instead of audits */
+export default _default;

package/audits-backward-compatibility/state.js

@@ -0,0 +1,24 @@
+import { createProxy } from '../toolkit/proxy';
+export const initialState = {
+  total: 0,
+  offset: 0,
+  filter: '',
+  sortBy: 'createdAt',
+  context: null,
+  filters: [],
+  rowsData: [],
+  lastUpdated: new Date(),
+  isLoading: true,
+  isFetchMore: false,
+  totalToday: 0,
+  currentPage: 0,
+  headerProps: [],
+  sortDirection: 'desc',
+  severeThisWeek: 0,
+  predefinedFilters: [],
+  isDownloadingCsv: false,
+  virtualScroll: false
+};
+
+/** @deprecated use auditLogs instead of audits */
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/AcceptInvitationState/actions.d.ts

@@ -0,0 +1,12 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+import { AcceptInvitationState, AcceptInvitationStep } from './interfaces';
+import { IAcceptInvitation } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setAcceptInvitationState: (state: Partial<AcceptInvitationState>) => {
+        readonly error?: string | undefined;
+        readonly step: AcceptInvitationStep;
+    };
+    resetAcceptInvitationState: () => void;
+    acceptInvitation: (payload: IAcceptInvitation) => Promise<void>;
+};
+export default _default;

package/auth/AcceptInvitationState/actions.js

@@ -0,0 +1,43 @@
+import { snapshot } from 'valtio/vanilla';
+import { AcceptInvitationStep } from './interfaces';
+import { initialState } from './state';
+import { deepClone, errorHandler } from '../../helpers';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setAcceptInvitationState = state => {
+    Object.assign(store.auth.acceptInvitationState, state);
+    return snapshot(store.auth.acceptInvitationState);
+  };
+  const resetAcceptInvitationState = () => {
+    store.auth.acceptInvitationState = deepClone(initialState);
+  };
+  const acceptInvitation = async payload => {
+    if (!payload.token || !payload.userId) {
+      setAcceptInvitationState({
+        error: undefined,
+        step: AcceptInvitationStep.invalid
+      });
+      return;
+    }
+    try {
+      setAcceptInvitationState({
+        error: undefined,
+        step: AcceptInvitationStep.pending
+      });
+      await api.auth.acceptInvitation(payload);
+      setAcceptInvitationState({
+        step: AcceptInvitationStep.success
+      });
+    } catch (e) {
+      setAcceptInvitationState({
+        step: AcceptInvitationStep.failed,
+        error: errorHandler(e)
+      });
+    }
+  };
+  return {
+    setAcceptInvitationState,
+    resetAcceptInvitationState,
+    acceptInvitation
+  };
+});

package/auth/AcceptInvitationState/index.d.ts

@@ -1,117 +1,3 @@
-import { IAcceptInvitation } from '@frontegg/rest-api';
-import { AcceptInvitationState } from './interfaces';
-declare const acceptInvitationState: AcceptInvitationState;
-declare const reducers: {
-    setAcceptInvitationState: {
-        prepare: (payload: Partial<AcceptInvitationState>) => {
-            payload: Partial<AcceptInvitationState>;
-        };
-        reducer: (state: import("..").AuthState, { payload }: {
-            payload: Partial<AcceptInvitationState>;
-            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: 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: import("..").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;
-        };
-    };
-    resetAcceptInvitationState: (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: 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: import("..").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: {
-    acceptInvitation: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[IAcceptInvitation], IAcceptInvitation, string, never, never>;
-};
-/**
- *  To be used for actions types after dispatch, and should contains
- *  the reducers and actions as standalone function
- */
-declare type DispatchedActions = {
-    setAcceptInvitationState: (state: Partial<AcceptInvitationState>) => void;
-    resetAcceptInvitationState: () => void;
-    acceptInvitation: (payload: IAcceptInvitation) => void;
-};
-export declare type AcceptInvitationActions = DispatchedActions;
-export { acceptInvitationState, reducers as acceptInvitationReducers, actions as acceptInvitationActions };
+import createAcceptInvitationState from './state';
+import buildAcceptInvitationActions from './actions';
+export { createAcceptInvitationState, buildAcceptInvitationActions };

package/auth/AcceptInvitationState/index.js

@@ -1,31 +1,3 @@
-import { createAction } from '@reduxjs/toolkit';
-import { resetStateByKey, typeReducerForKey } from '../utils';
-import { AcceptInvitationStep } from './interfaces';
-import { authStoreName } from '../../constants';
-const acceptInvitationState = {
-  step: AcceptInvitationStep.validate
-};
-const reducers = {
-  setAcceptInvitationState: typeReducerForKey('acceptInvitationState'),
-  resetAcceptInvitationState: resetStateByKey('acceptInvitationState', {
-    acceptInvitationState
-  })
-};
-const actions = {
-  acceptInvitation: createAction(`${authStoreName}/acceptInvitation`, 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 { acceptInvitationState, reducers as acceptInvitationReducers, actions as acceptInvitationActions };
+import createAcceptInvitationState from './state';
+import buildAcceptInvitationActions from './actions';
+export { createAcceptInvitationState, buildAcceptInvitationActions };

package/auth/AcceptInvitationState/state.d.ts

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

package/auth/AcceptInvitationState/state.js

@@ -0,0 +1,6 @@
+import { createProxy } from '../../toolkit/proxy';
+import { AcceptInvitationStep } from './interfaces';
+export const initialState = {
+  step: AcceptInvitationStep.validate
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/auth/AccountSettingsState/actions.d.ts

@@ -0,0 +1,23 @@
+import { FronteggState, RestApi, SharedActions, WithCallback } from '../../interfaces';
+import { ISettingsResponse, IUpdateSettings } from '@frontegg/rest-api';
+import { AccountSettingsState } from './interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setAccountSettingsState: (state: Partial<AccountSettingsState>) => {
+        readonly loading: boolean;
+        readonly name?: string | undefined;
+        readonly website?: string | undefined;
+        readonly error?: any;
+        readonly address?: string | undefined;
+        readonly timezone?: string | undefined;
+        readonly dateFormat?: string | undefined;
+        readonly timeFormat?: string | undefined;
+        readonly currency?: string | undefined;
+        readonly logo?: string | undefined;
+    };
+    resetAccountSettingsState: () => void;
+    saveAccountSettings: (payload: WithCallback<IUpdateSettings, ISettingsResponse>) => Promise<void>;
+    loadAccountSettings: (payload?: WithCallback<{
+        silentLoading?: boolean | undefined;
+    }, boolean> | undefined) => Promise<void>;
+};
+export default _default;