@zeniai/client-epic-state 5.0.81 → 5.0.82-betaAK1

package/lib/esm/reducer.js

@@ -98,6 +98,7 @@ import companyHealthMetricView, { initialState as initialCompanyHealthMetricView
 import companyMonthEndReportView, { initialState as initialCompanyMonthEndReportViewState, } from './view/companyMonthEndReportView/companyMonthEndReportViewReducer';
 import companyTaskManagerView, { initialState as initialCompanyTaskManagerViewState, } from './view/companyTaskManagerView/companyTaskManagerViewReducer';
 import companyView, { initialState as initialCompanyViewState, } from './view/companyView/companyViewReducer';
+import createTransferEntry, { initialState as initialCreateTransferEntryState, } from './view/createTransferEntry/createTransferEntryReducer';
 import creditAgentView, { initialState as initialCreditAgentViewState, } from './view/creditAgentView/creditAgentViewReducer';
 import dashboard, { initialState as initialDashboardState, } from './view/dashboard/dashboardReducer';
 import dashboardLayout, { initialState as initialDashboardLayoutState, } from './view/dashboardLayout/dashboardLayoutReducer';
@@ -157,6 +158,8 @@ import internationalWireVerification, { initialState as initialInternationalWire
 import magicLinkView, { initialState as initialMagicLinkViewState, } from './view/spendManagement/billPay/magicLinkView/magicLinkViewReducer';
 import previousBills, { initialState as initialPreviousBillsState, } from './view/spendManagement/billPay/previousBills/previousBillsReducer';
 import wiseRedirect, { initialState as initialWiseRedirectState, } from './view/spendManagement/billPay/wiseRedirectView/wiseRedirectReducer';
+import autoSweepFlow, { initialState as initialAutoSweepFlowState, } from './view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowReducer';
+import cashManagementOverview, { initialState as initialCashManagementOverviewState, } from './view/spendManagement/cashManagement/cashManagementOverview/cashManagementOverviewReducer';
 import cardUserOnboarding, { initialState as initialCardUserOnboardingState, } from './view/spendManagement/chargeCards/cardUserOnboarding/cardUserOnboardingReducer';
 import cashbackDetail, { initialState as initialCashbackDetailState, } from './view/spendManagement/chargeCards/cashbackDetail/cashbackDetailReducer';
 import chargeCardConfig, { initialState as initialChargeCardConfigState, } from './view/spendManagement/chargeCards/chargeCardConfig/chargeCardConfigReducer';
@@ -308,6 +311,7 @@ const initialViewsState = {
     arAgingState: initialArAgingState,
     auditReportViewState: initialAuditReportViewState,
     authenticationViewState: initialAuthenticationViewState,
+    autoSweepFlowState: initialAutoSweepFlowState,
     autotransferRulesState: initialAutotransferRulesState,
     balanceSheetState: initialBalanceSheetState,
     bankAccountViewState: initialBankAccountView,
@@ -326,6 +330,7 @@ const initialViewsState = {
     cashBalanceState: initialCashBalanceState,
     cashFlowState: initialCashFlowState,
     cashInCashOutState: initialCashInCashOutState,
+    cashManagementOverviewState: initialCashManagementOverviewState,
     cashPositionState: initialCashPositionState,
     chargeCardConfigState: initialChargeCardConfigState,
     chargeCardDetailState: initialChargeCardDetailState,
@@ -360,6 +365,7 @@ const initialViewsState = {
     expenseAutomationReconciliationViewState: initialExpenseAutomationReconciliationViewState,
     expenseAutomationTransactionsViewState: initialExpenseAutomationTransactionsViewState,
     expenseAutomationViewState: initialExpenseAutomationViewState,
+    createTransferEntryState: initialCreateTransferEntryState,
     expressPayState: initialExpressPayState,
     featureNotificationViewState: initialFeatureNotificationViewState,
     fileViewState: initialFileViewState,
@@ -544,6 +550,7 @@ const viewReducers = {
     arAgingState: arAging,
     auditReportViewState: auditReportView,
     authenticationViewState: authentication,
+    autoSweepFlowState: autoSweepFlow,
     autotransferRulesState: autotransferRules,
     balanceSheetState: balanceSheet,
     bankAccountViewState: bankAccountView,
@@ -561,6 +568,7 @@ const viewReducers = {
     cashBalanceState: cashBalance,
     cashFlowState: cashFlow,
     cashInCashOutState: cashInCashOut,
+    cashManagementOverviewState: cashManagementOverview,
     cashPositionState: cashPosition,
     chargeCardConfigState: chargeCardConfig,
     chargeCardDetailState: chargeCardDetail,
@@ -595,6 +603,7 @@ const viewReducers = {
     expenseAutomationReconciliationViewState: expenseAutomationReconciliationView,
     expenseAutomationTransactionsViewState: expenseAutomationTransactionsView,
     expenseAutomationViewState: expenseAutomationView,
+    createTransferEntryState: createTransferEntry,
     expressPayState: expressPay,
     featureNotificationViewState: featureNotificationView,
     fileViewState: fileView,

package/lib/esm/view/createTransferEntry/createTransferEntryReducer.js

@@ -0,0 +1,82 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { initialCreateTransferEntryState, } from './createTransferEntryState';
+export const initialState = initialCreateTransferEntryState;
+const createTransferEntrySlice = createSlice({
+    name: 'createTransferEntry',
+    initialState,
+    reducers: {
+        fetchAccountsForTransferFlow(draft, action) {
+            const slice = draft.transferAccountsByType[action.payload.kind];
+            // Idempotent: a duplicate dispatch must not briefly downgrade
+            // 'Completed' back to 'In-Progress' (would clear loaded data from a
+            // consumer's perspective) nor restart the in-flight epic stream.
+            // The hook (`useFetchTransferAccountsForFlow`) is the sole caller and
+            // already dedupes via `store.getState()`; this guard is defense in
+            // depth for any future caller.
+            if (slice.fetchState === 'In-Progress' ||
+                slice.fetchState === 'Completed') {
+                return;
+            }
+            slice.fetchState = 'In-Progress';
+        },
+        updateAccountsForTransferFlow(draft, action) {
+            const slice = draft.transferAccountsByType[action.payload.kind];
+            slice.fetchState = 'Completed';
+            slice.accountIds = action.payload.accountIds;
+        },
+        updateAccountsForTransferFlowFailure(draft, action) {
+            draft.transferAccountsByType[action.payload.kind].fetchState = 'Error';
+        },
+        createTransferEntry: {
+            prepare(payload) {
+                return { payload };
+            },
+            /**
+             * Defense-in-depth: clear any stale `lastTransferEntryReplacement` on a
+             * fresh dispatch so a second `createTransferEntry` never inherits the
+             * previous run's replacement signal (e.g. if the prior `timer(0)` cleanup
+             * never fired). Mirrors the host hook's `consumedReplacementRef` guard
+             * (see `useTransferEntryRouteReplacement` in zeni-web-app-ui).
+             */
+            reducer(draft) {
+                draft.createTransferEntryStatus = 'In-Progress';
+                draft.lastTransferEntryReplacement = undefined;
+            },
+        },
+        createTransferEntrySuccess(draft) {
+            draft.createTransferEntryStatus = 'Completed';
+        },
+        createTransferEntryFailure(draft) {
+            draft.createTransferEntryStatus = 'Error';
+        },
+        resetCreateTransferEntryStatus(draft) {
+            draft.createTransferEntryStatus = 'Not-Started';
+        },
+        createTransferEntryReplacedTransaction: {
+            prepare(previousTransactionId, newTransactionId) {
+                return { payload: { newTransactionId, previousTransactionId } };
+            },
+            reducer(draft, action) {
+                draft.lastTransferEntryReplacement = action.payload;
+            },
+        },
+        /**
+         * One-shot acknowledgement: the host has consumed the route-replacement
+         * signal and navigated to the new transaction url, so we can drop the
+         * record. Re-dispatching is idempotent.
+         */
+        clearTransferEntryRouteReplacement(draft) {
+            draft.lastTransferEntryReplacement = undefined;
+        },
+        /**
+         * Full slice reset. Dispatched from `clearAllEpic` on tenant switch so
+         * stale per-tenant state (account-id pools, status, replacement signal)
+         * doesn't bleed across tenants.
+         */
+        clearCreateTransferEntry(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchAccountsForTransferFlow, updateAccountsForTransferFlow, updateAccountsForTransferFlowFailure, createTransferEntry, createTransferEntrySuccess, createTransferEntryFailure, resetCreateTransferEntryStatus, createTransferEntryReplacedTransaction, clearTransferEntryRouteReplacement, clearCreateTransferEntry, } = createTransferEntrySlice.actions;
+export default createTransferEntrySlice.reducer;

package/lib/esm/view/createTransferEntry/createTransferEntrySelector.js

@@ -0,0 +1,64 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { getAccountBase, getAccountBaseForCreditCardTransferAccounts, getAccountBaseForTransferAccounts, } from '../../entity/account/accountSelector';
+import { getAccountList } from '../accountList/accountListSelector';
+export function getCreateTransferEntryStatus(state) {
+    return state.createTransferEntryState.createTransferEntryStatus;
+}
+export function getLastTransferEntryReplacement(state) {
+    return state.createTransferEntryState.lastTransferEntryReplacement;
+}
+/**
+ * Shared resolver for the credit/debit dropdowns in the transfer drawer.
+ *
+ * Resolution policy (intentional):
+ * 1. Prefer the dedicated API fetch results (`transferEntryEligible` for the
+ *    debit pool, `creditCardOnlyEligible` for the credit-card-payment credit
+ *    pool).
+ * 2. If the dedicated fetch returns an empty list while the COA is loaded,
+ *    fall back to the COA: the full account list for `transferEntryEligible`,
+ *    and COA accounts filtered to `credit_card` for `creditCardOnlyEligible`.
+ *    This keeps the dropdown populated for older tenants where the dedicated
+ *    endpoints haven't been backfilled yet.
+ *
+ * Intent — what this selector deliberately does NOT do:
+ * - Does NOT distinguish "fetch in-flight" / "fetch errored" / "fetch returned
+ *   empty" — all three collapse to the COA fallback. The product preference
+ *   is "always show something selectable" over "show a spinner that may never
+ *   resolve". Loading/error UI belongs in the view layer; if you need a
+ *   spinner, observe the `fetchState` on `transferAccountsByType[kind]`
+ *   separately rather than changing the resolution policy here.
+ * - Does NOT enforce "API result is authoritative even if empty" — a tenant
+ *   whose dedicated endpoint is correctly returning `[]` (e.g. no eligible
+ *   transfer destinations) will still see the COA. That trade-off is
+ *   accepted because the alternative blocks the user from picking anything;
+ *   the backend distinguishes "no result" from "endpoint not implemented" by
+ *   surfacing an error response, which the view layer handles separately.
+ *
+ * Memoized with reselect so consuming view-models don't recompute on every
+ * unrelated state change.
+ */
+export const getResolvedTransferAccounts = createSelector([
+    (state) => state.accountState,
+    (state) => state.accountListState,
+    (state) => state.createTransferEntryState.transferAccountsByType
+        .transferEntryEligible.accountIds,
+    (state) => state.createTransferEntryState.transferAccountsByType
+        .creditCardOnlyEligible.accountIds,
+], (accountState, accountListState, transferEligibleIds, creditCardOnlyIds) => {
+    const accountList = getAccountList(accountState, accountListState, 'accountList');
+    const transferEligibleFromApi = transferEligibleIds
+        .map((id) => getAccountBaseForTransferAccounts(accountState, id))
+        .filter((account) => account != null);
+    const coaFallbackAllAccounts = accountList.accounts
+        .map((a) => getAccountBase(accountState, a.accountId, 'account_list'))
+        .filter((account) => account != null);
+    const transferAccountsList = transferEligibleFromApi.length > 0
+        ? transferEligibleFromApi
+        : coaFallbackAllAccounts;
+    const creditCardFromApi = creditCardOnlyIds
+        .map((id) => getAccountBaseForCreditCardTransferAccounts(accountState, id))
+        .filter((account) => account != null);
+    const coaFallbackCreditCards = coaFallbackAllAccounts.filter((a) => a.accountType === 'credit_card');
+    const creditCardTransferAccountsList = creditCardFromApi.length > 0 ? creditCardFromApi : coaFallbackCreditCards;
+    return { creditCardTransferAccountsList, transferAccountsList };
+});

package/lib/esm/view/createTransferEntry/createTransferEntryState.js

@@ -0,0 +1,17 @@
+/** Which pool `fetchAccountsForTransferFlow` / transfer-flow epic should load. */
+export const TRANSFER_ACCOUNTS_FETCH_TYPE = [
+    'transferEntryEligible',
+    'creditCardOnlyEligible',
+];
+const initialTransferAccountsState = {
+    accountIds: [],
+    fetchState: 'Not-Started',
+};
+export const initialCreateTransferEntryState = {
+    createTransferEntryStatus: 'Not-Started',
+    lastTransferEntryReplacement: undefined,
+    transferAccountsByType: {
+        transferEntryEligible: initialTransferAccountsState,
+        creditCardOnlyEligible: initialTransferAccountsState,
+    },
+};

package/lib/esm/view/createTransferEntry/epics/createTransferEntryEpic.js

@@ -0,0 +1,130 @@
+import { concat, from, timer } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { toTransactionID } from '../../../entity/transaction/payloadTypes/transactionIDPayload';
+import { removeTransaction, updateTransaction, } from '../../../entity/transaction/transactionReducer';
+import { isSuccessResponse } from '../../../responsePayload';
+import { removeTransactionFromAllTabs } from '../../expenseAutomationView/reducers/transactionsViewReducer';
+import { initializeTransactionDetailLocalData, removeTransactionDetail, } from '../../transactionDetail/transactionDetailReducer';
+import { getTransactionDetailKey } from '../../transactionDetail/transactionDetailState';
+import { clearTransferEntryRouteReplacement, createTransferEntry, createTransferEntryFailure, createTransferEntryReplacedTransaction, createTransferEntrySuccess, resetCreateTransferEntryStatus, } from '../createTransferEntryReducer';
+// ─── Pure helpers ────────────────────────────────────────────────────────────
+function transactionIdsAreEqual(a, b) {
+    return a.id === b.id && a.type === b.type;
+}
+const successSnackbar = () => openSnackbar({
+    messageSection: 'create_transfer_entry',
+    messageText: 'success',
+    type: 'success',
+});
+const failureSnackbar = () => openSnackbar({
+    messageSection: 'create_transfer_entry',
+    messageText: 'failed',
+    type: 'error',
+});
+function buildFailureActions() {
+    return [createTransferEntryFailure(), failureSnackbar()];
+}
+/**
+ * Defensive guard: a BE response that returns 200 with `transaction != null`
+ * but where the body lacks a usable id/type is unsafe to seed into the store —
+ * downstream code would store under a garbage key and the host hook would try
+ * to navigate to a broken url. Treat that case as failure so the source row
+ * stays visible and the user can retry.
+ */
+function isWellFormedTransactionPayload(t) {
+    return (t != null &&
+        typeof t.transaction_id === 'string' &&
+        t.transaction_id !== '' &&
+        typeof t.transaction_type === 'string' &&
+        t.transaction_type !== '');
+}
+function buildSuccessSideEffects(sourceTransactionId) {
+    return [
+        createTransferEntrySuccess(),
+        removeTransactionFromAllTabs(sourceTransactionId),
+        successSnackbar(),
+    ];
+}
+function buildPreviousTransactionCleanupActions(previousTransactionId) {
+    return [
+        removeTransaction(getTransactionDetailKey(previousTransactionId)),
+        removeTransactionDetail(previousTransactionId),
+        clearTransferEntryRouteReplacement(),
+    ];
+}
+/**
+ * Emits `resetCreateTransferEntryStatus()` (and, on the replacement path, the
+ * follow-up cleanup actions) one scheduler tick after the success actions.
+ *
+ * Why the `timer(0)` (and not synchronous emission):
+ * On the replacement path the host (web-app-ui) watches
+ * `lastTransferEntryReplacement`, navigates to the new transaction url, and
+ * then sees `clearTransferEntryRouteReplacement` clear the signal. If we
+ * dispatched the cleanup actions in the same tick as
+ * `createTransferEntryReplacedTransaction`, redux subscribers would observe
+ * `lastTransferEntryReplacement` flicker on then off in a single render, and
+ * the old transaction's state (which the still-mounted detail view may be
+ * reading) would be torn down before the host has had a chance to start
+ * navigating. Deferring by one microtask gives the host exactly one render
+ * pass to react before we tear down the previous transaction.
+ */
+function delayedResetAndPreviousCleanup(previousTransactionId) {
+    return timer(0).pipe(mergeMap(() => {
+        const actions = [resetCreateTransferEntryStatus()];
+        if (previousTransactionId != null) {
+            actions.push(...buildPreviousTransactionCleanupActions(previousTransactionId));
+        }
+        return from(actions);
+    }));
+}
+// ─── Success-path branches ───────────────────────────────────────────────────
+function handleSuccessWithoutTransactionBody(transactionId) {
+    return concat(from(buildSuccessSideEffects(transactionId)), delayedResetAndPreviousCleanup(undefined));
+}
+function handleSuccessWithTransactionBody(transactionPayload, vendorPayload, previousTransactionId, sourceTransactionId) {
+    const newTransactionId = toTransactionID(transactionPayload);
+    const replaced = !transactionIdsAreEqual(previousTransactionId, newTransactionId);
+    const immediate = [
+        updateTransaction(getTransactionDetailKey(newTransactionId), transactionPayload),
+        initializeTransactionDetailLocalData({
+            transactionId: newTransactionId,
+            vendorId: vendorPayload?.[0]?.vendor_id,
+        }),
+        ...buildSuccessSideEffects(sourceTransactionId),
+    ];
+    if (replaced) {
+        immediate.push(createTransferEntryReplacedTransaction(previousTransactionId, newTransactionId));
+    }
+    return concat(from(immediate), delayedResetAndPreviousCleanup(replaced ? previousTransactionId : undefined));
+}
+// ─── Top-level epic ──────────────────────────────────────────────────────────
+export const createTransferEntryEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(createTransferEntry.match), mergeMap((action) => {
+    const { transactionId, creditAccountIntegrationId, debitAccountIntegrationId, memo, transactionType, sourceTransactionType, } = action.payload;
+    const previousTransactionId = {
+        id: transactionId,
+        type: sourceTransactionType,
+    };
+    const payload = {
+        transaction_type: transactionType,
+        transaction_id: transactionId,
+        to_account_integration_id: creditAccountIntegrationId,
+        from_account_integration_id: debitAccountIntegrationId,
+        memo: memo ?? '',
+    };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/transaction-type-update`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const transaction = response.data?.transaction;
+            if (transaction != null) {
+                if (!isWellFormedTransactionPayload(transaction)) {
+                    return from(buildFailureActions());
+                }
+                return handleSuccessWithTransactionBody(transaction, response.data?.vendors, previousTransactionId, transactionId);
+            }
+            return handleSuccessWithoutTransactionBody(transactionId);
+        }
+        return from(buildFailureActions());
+    }), catchError(() => from(buildFailureActions())));
+}));

package/lib/esm/view/createTransferEntry/epics/fetchTransferAccountsEpic.js

@@ -0,0 +1,36 @@
+import { of } from 'rxjs';
+import { catchError, filter, groupBy, mergeMap, switchMap } from 'rxjs/operators';
+import { updateAccounts } from '../../../entity/account/accountReducer';
+import { isSuccessResponse } from '../../../responsePayload';
+import { fetchAccountsForTransferFlow, updateAccountsForTransferFlow, updateAccountsForTransferFlowFailure, } from '../createTransferEntryReducer';
+const REPORT_ID_BY_TYPE = {
+    transferEntryEligible: 'transfer_accounts',
+    creditCardOnlyEligible: 'credit_card_transfer_accounts',
+};
+const QUERY_BY_TYPE = {
+    transferEntryEligible: { is_only_include_transfer_accounts: true },
+    creditCardOnlyEligible: { is_include_only_credit_card_accounts: true },
+};
+/**
+ * Pools fetched concurrently: `groupBy(kind)` keeps `transferEntryEligible`
+ * and `creditCardOnlyEligible` in their own streams so a back-to-back dispatch
+ * of both does not cancel the first. Within a single type, a fresh dispatch
+ * supersedes any in-flight request (per-group `switchMap`).
+ */
+export const fetchTransferAccountsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchAccountsForTransferFlow.match), groupBy((action) => action.payload.kind), mergeMap((group$) => group$.pipe(switchMap((action) => {
+    const { kind } = action.payload;
+    const queryValue = QUERY_BY_TYPE[kind];
+    const reportId = REPORT_ID_BY_TYPE[kind];
+    const url = `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accounts?query=${encodeURIComponent(JSON.stringify(queryValue))}`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const accountIds = response.data.accounts.map((account) => account.account_id);
+            const actions = [
+                updateAccounts(response.data.accounts, reportId),
+                updateAccountsForTransferFlow({ accountIds, kind }),
+            ];
+            return of(...actions);
+        }
+        return of(updateAccountsForTransferFlowFailure({ kind }));
+    }), catchError(() => of(updateAccountsForTransferFlowFailure({ kind }))));
+}))));

package/lib/esm/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -5,6 +5,7 @@ import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { isVendorTransaction } from '../../../entity/transaction/stateTypes/vendorTransaction';
 import { filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, shouldAutoSelectAndAdd, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
 import { DEFAULT_COMPLETED_SUB_TAB, } from '../types/completedSubTab';
+import { TRANSACTIONS_TABS, } from '../types/transactionsViewState';
 export const initialTransactionTabViewState = {
     saveStatus: {
         fetchState: 'Not-Started',
@@ -1040,7 +1041,18 @@ const expenseAutomationTransactionsView = createSlice({
                 };
             },
         },
+        removeTransactionFromAllTabs: {
+            prepare(transactionId) {
+                return { payload: { transactionId } };
+            },
+            reducer(draft, action) {
+                const { transactionId } = action.payload;
+                for (const tab of TRANSACTIONS_TABS) {
+                    removeTransactionFromTabView(draft.transactionCategorizationView[tab], transactionId);
+                }
+            },
+        },
     },
 });
-export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, updateTransactionFilters, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, markCategoryClassRecommendationsInProgressForCategorization, markCategoryClassRecommendationsCompletedForCategorization, markCategoryClassRecommendationsFailureForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
+export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, updateTransactionFilters, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, markCategoryClassRecommendationsInProgressForCategorization, markCategoryClassRecommendationsCompletedForCategorization, markCategoryClassRecommendationsFailureForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, removeTransactionFromAllTabs, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
 export default expenseAutomationTransactionsView.reducer;

package/lib/esm/view/expenseAutomationView/selectors/transactionCategorizationSelector.js

@@ -8,6 +8,7 @@ import { getSupportedTransactionsByIds } from '../../../entity/transaction/trans
 import { applyTransactionFilters, } from '../transactionFilterHelpers';
 import { getAccountList, getNestedAccountListHierarchy, getUncategorizedAccounts, } from '../../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
+import { getResolvedTransferAccounts } from '../../createTransferEntry/createTransferEntrySelector';
 import { getProjectList } from '../../projectList/projectListSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 // Walks the tab's transactionReviewLocalDataById map and returns
@@ -81,8 +82,11 @@ export const toTransactionView = (transaction, transactionLocalData) => {
         transactionLocalData,
     };
 };
+// Re-exported here for back-compat. New code should import from
+// `view/createTransferEntry/createTransferEntrySelector`.
+export { getLastTransferEntryReplacement } from '../../createTransferEntry/createTransferEntrySelector';
 export function getExpenseAutomationTransactionView(state) {
-    const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, projectState, projectListState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
+    const { accountState, classState, classListState, accountListState, createTransferEntryState, expenseAutomationTransactionsViewState, expenseAutomationViewState, projectState, projectListState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
     const { selectedTransactionCategorizationCompletedSubTab, selectedTransactionCategorizationTab, } = expenseAutomationTransactionsViewState;
     const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, filters, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = getUncategorizedAccounts(accountState, accountListState, 'accountList');
@@ -214,6 +218,7 @@ export function getExpenseAutomationTransactionView(state) {
         : [];
     const transactionCompletionStatus = allSteps.find((step) => step.step === 'transaction_categorization')?.completionStatus;
     const completionStatus = transactionCompletionStatus ?? 'incomplete';
+    const { transferAccountsList, creditCardTransferAccountsList } = getResolvedTransferAccounts(state);
     const inFlightCategoryClassRecommendationsByTransactionId = getCategorizationInFlightRecommendationsByTransactionId(state);
     const hasInFlightCategoryClassRecommendations = getCategorizationHasInFlightRecommendations(state);
     return {
@@ -238,6 +243,7 @@ export function getExpenseAutomationTransactionView(state) {
         refreshStatus,
         saveStatus,
         markAsNotMiscategorizedStatus,
+        createTransferEntryStatus: createTransferEntryState.createTransferEntryStatus,
         completionStatus,
         totalCountByTab,
         parentTabTotalCountByTab,
@@ -245,6 +251,8 @@ export function getExpenseAutomationTransactionView(state) {
         uploadReceiptStatusById,
         selectedTransactionId,
         selectedTransactionLineId,
+        creditCardTransferAccountsList,
+        transferAccounts: transferAccountsList,
         selectedTransactionCategorizationCompletedSubTab,
     };
 }

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowPayload.js

@@ -0,0 +1,24 @@
+import { toAmount } from '../../../../commonStateTypes/amount';
+import { getNextTransferDate } from '../../../../commonStateTypes/workingDayHelper';
+import { toAutoSweepFrequency, } from './autoSweepFlowState';
+export const toSaveAutoSweepSettingsBody = (state) => ({
+    first_transfer_date: getNextTransferDate(state.frequency).format('YYYY-MM-DD'),
+    frequency: state.frequency,
+    memo: state.memo,
+    minimum_buffer_usd: state.bufferAmount.amount,
+});
+/**
+ * Map a `GET /cash-management/settings` payload into the slice's writable
+ * fields. Defensive on the frequency (string-from-the-wire → union via
+ * `toAutoSweepFrequency`, falling back to `'weekly'` if the server returns
+ * something we don't model yet).
+ */
+export const toAutoSweepFlowStatePatch = (payload) => {
+    const currencyCode = payload.source_bank_account.balances?.currency_code;
+    const currencySymbol = payload.source_bank_account.balances?.currency_symbol;
+    return {
+        bufferAmount: toAmount(payload.minimum_buffer_usd, currencyCode ?? 'USD', currencySymbol ?? '$'),
+        frequency: toAutoSweepFrequency(payload.frequency) ?? 'weekly',
+        settingsId: payload.cash_management_settings_id ?? undefined,
+    };
+};

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowReducer.js

@@ -0,0 +1,55 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toAutoSweepFlowStatePatch, } from './autoSweepFlowPayload';
+import { initialAutoSweepFlowState, } from './autoSweepFlowState';
+export const initialState = initialAutoSweepFlowState;
+const autoSweepFlow = createSlice({
+    name: 'autoSweepFlow',
+    initialState,
+    reducers: {
+        /**
+         * Kicks off `GET /cash-management/settings`. Flips the top-level
+         * fetchState to `In-Progress`; the fetch epic picks this up.
+         */
+        fetchCashManagementSettings(draft) {
+            draft.fetchState = 'In-Progress';
+            draft.error = undefined;
+        },
+        /**
+         * Hydrates the form fields with the server-side settings (and stashes
+         * the settings id for subsequent saves). Marks the GET as `Completed`.
+         */
+        updateCashManagementSettings(draft, action) {
+            const patch = toAutoSweepFlowStatePatch(action.payload.data);
+            draft.bufferAmount = patch.bufferAmount;
+            draft.frequency = patch.frequency;
+            draft.settingsId = patch.settingsId;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateCashManagementSettingsFetchStatus(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        /**
+         * Persists the form values into state and flips `saveStatus` to
+         * `In-Progress`; the save epic picks this up and PUTs the settings.
+         */
+        saveAutoSweepSettings(draft, action) {
+            draft.bufferAmount = action.payload.bufferAmount;
+            draft.frequency = action.payload.frequency;
+            draft.memo = action.payload.memo;
+            draft.saveStatus = { fetchState: 'In-Progress', error: undefined };
+        },
+        updateAutoSweepSettingsFetchStatus(draft, action) {
+            draft.saveStatus = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        clearAutoSweepFlow() {
+            return initialAutoSweepFlowState;
+        },
+    },
+});
+export const { fetchCashManagementSettings, updateCashManagementSettings, updateCashManagementSettingsFetchStatus, saveAutoSweepSettings, updateAutoSweepSettingsFetchStatus, clearAutoSweepFlow, } = autoSweepFlow.actions;
+export default autoSweepFlow.reducer;

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowSelector.js

@@ -0,0 +1,15 @@
+import { bufferAmountToRisk, } from './autoSweepFlowState';
+export const getAutoSweepFlow = (state) => {
+    const { bufferAmount, frequency, memo, saveStatus, settingsId, fetchState, error, } = state.autoSweepFlowState;
+    return {
+        fetchState,
+        error,
+        bufferAmount,
+        frequency,
+        memo,
+        risk: bufferAmountToRisk(bufferAmount.amount),
+        saveStatus,
+        settingsId,
+        version: 0,
+    };
+};

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/autoSweepFlowState.js

@@ -0,0 +1,45 @@
+import { toAmount } from '../../../../commonStateTypes/amount';
+import { stringToUnion } from '../../../../commonStateTypes/stringToUnion';
+/**
+ * Cadence at which the auto-sweep transfer fires. Lowercase to match the
+ * cash-management settings API contract (and the `SweepFrequency` literal
+ * already used by `<AutoSweepSetupPage>` in web-components).
+ */
+export const ALL_AUTO_SWEEP_FREQUENCIES = [
+    'daily',
+    'weekly',
+    'biweekly',
+    'monthly',
+];
+export const toAutoSweepFrequency = (v) => stringToUnion(v ?? '', ALL_AUTO_SWEEP_FREQUENCIES);
+/**
+ * Risk presets the auto-sweep setup form exposes. Each level maps to a
+ * canonical minimum-buffer amount (USD). Selecting a level in the UI is
+ * shorthand for choosing that buffer.
+ */
+export const ALL_AUTO_SWEEP_RISK_LEVELS = ['low', 'moderate', 'high'];
+export const toAutoSweepRiskLevel = (v) => stringToUnion(v ?? '', ALL_AUTO_SWEEP_RISK_LEVELS);
+export const RISK_BUFFER_AMOUNT = {
+    low: 15000,
+    moderate: 10000,
+    high: 5000,
+};
+/**
+ * Maps a buffer amount back onto the closest preset risk level. Falls back
+ * to `'moderate'` when the amount doesn't match a known preset (e.g. the
+ * server returned a custom value). The dropdown in `<AutoSweepSetupPage>`
+ * uses this so it can pre-select the user's existing band on edit.
+ */
+export const bufferAmountToRisk = (amount) => {
+    const match = Object.entries(RISK_BUFFER_AMOUNT).find(([, presetAmount]) => presetAmount === amount);
+    return match != null ? match[0] : 'moderate';
+};
+export const initialAutoSweepFlowState = {
+    bufferAmount: toAmount(10000, 'USD'),
+    frequency: 'weekly',
+    memo: '',
+    saveStatus: { fetchState: 'Not-Started', error: undefined },
+    settingsId: undefined,
+    fetchState: 'Not-Started',
+    error: undefined,
+};

package/lib/esm/view/spendManagement/cashManagement/autoSweepFlow/epics/fetchCashManagementSettingsEpic.js

@@ -0,0 +1,28 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { fetchCashManagementSettings, updateCashManagementSettings, updateCashManagementSettingsFetchStatus, } from '../autoSweepFlowReducer';
+/**
+ * Hits `GET /cash-management/settings` and hydrates the auto-sweep slice
+ * with the server's existing settings (frequency, minimum buffer, settings
+ * id). Called from the cash management overview page-fetch epic alongside
+ * the other top-level fetches.
+ *
+ * TODO: switch the endpoint to a base URL constant once the prod endpoint
+ * lands; right now this hits the dev environment directly.
+ */
+export const fetchCashManagementSettingsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCashManagementSettings.match), switchMap(() => zeniAPI
+    .getJSON(`https://dev.api.zeni.ai/cash-management-agent/1.0/cash-management/settings`)
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response) && response.data != null) {
+        return of(updateCashManagementSettings({ data: response.data }));
+    }
+    return of(updateCashManagementSettingsFetchStatus({
+        fetchState: 'Error',
+        error: response.status,
+    }));
+}), catchError((error) => of(updateCashManagementSettingsFetchStatus({
+    fetchState: 'Error',
+    error: createZeniAPIStatus('Unexpected Error', 'Fetch cash management settings REST API call errored out' +
+        JSON.stringify(error)),
+}))))));